# javaee入门

# 第一章 前端和后端的链接

# 一、 web 概念

这是百度百科的解释：

web（World Wide Web）即全球广域网，也称为万维网，它是一种基于超文本和HTTP的、全球性的、动态交互的、跨平台的分布式图形信息系统。是建立在Internet上的一种网络服务，为浏览者在Internet上查找和浏览信息提供了图形化的、易于访问的直观界面，其中的文档及超级链接将Internet上的信息节点组织成一个互为关联的网状结构。

万维网不等于互联网，万维网是互联网的一个应用，简单的理解万维网就是由大量的服务器，比如百度、比如淘宝、比如我们的元动力网站组成，用户可以通过在浏览器中使用网址（资源定位符）来获取网络资源。如果我们想开发一个web应用，就需要开发应用，并部署在服务器上，当然这个服务器可以被其他人访问。

# 1、软件架构

 C/S： 客户端/服务器端 ------------> QQ , 360 ...    client server
 B/S： 浏览器/服务器端 ------------> 京东， 网易 ， 淘宝   brower/server

# 2、资源分类

1. 静态资源： 所有用户访问后，得到的结果都是一样的，称为静态资源。静态资源可以直接被浏览器解析。如图片、视频等。

2. 动态资源: 每个用户访问相同资源后，得到的结果可能不一样 , 称为动态资源。动态资源被访问后，需要先转换为静态资源，再返回给浏览器，通过浏览器进行解析。比如我们之前写的登录，不同的人登录后显示的用户名并不相同。

• 如：servlet,jsp,php,asp....

# 3、常见的web服务器

# （1）概念

1. 服务器：安装了服务器软件的计算机

2. 服务器软件：接收用户的请求，处理请求，做出响应

3. web服务器软件：接收用户的请求，处理请求，做出响应。

在web服务器软件中，可以部署web项目，让用户通过浏览器来访问这些项目 ​

# （2）常见服务器软件

动态服务器

• webLogic：oracle公司，大型的JavaEE服务器，支持JavaEE规范，收费的。
• webSphere：IBM公司，大型的JavaEE服务器，支持JavaEE规范，收费的。
• JBOSS：JBOSS公司的，大型的JavaEE服务器，支持JavaEE规范，收费的。
• Tomcat：Apache基金组织，中小型的JavaEE服务器，仅仅支持少量的JavaEE规范servlet/jsp。开源的，免费的。（300左右的并发）

静态的服务器

• Nginx：（代理，反向代理等）极高的并发 Nginx处理静态文件、索引文件，自动索引的效率非常高。当然除了当做高性能的静态服务器，它还有很多强大的功能，我们后边会有专项课程学习。

# 二、Hello World

我们已经学习了javase、mysql以及前端知识，jdbc负责java和持久层，那前端怎么和我们的java配合使用呢？

我们回想mysql的链接，不同的客户端通过url访问mysql，是通过套接字进行链接的：

与此同时，我们的浏览器也是使用url访问网站的啊，我们不妨尝试一下，建立一个服务器监听在8888端口，

很明显，我们启动的服务是基于TCP协议的套接字:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static void main(String[] args) throws Exception {
        // 启动一个服务器
        ServerSocket serverSocket = new ServerSocket(8080);
        Socket accept = serverSocket.accept();
        // 获得输入流
        InputStream inputStream = accept.getInputStream();
        byte[] buf = new byte[1024];
        int len;
        while ((len = inputStream.read(buf)) != -1){
            System.out.print(new String(buf,0,len));
        }
        inputStream.close();;
        accept.close();
    }

我们打开一个浏览器，在浏览器中输入：

我们观察一下后台的输出：

1
2
3
4
5
6
7
8
9
10
11
12

GET / HTTP/1.1
Host: 127.0.0.1:8888
Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36
Sec-Fetch-User: ?1
Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9

我们发现浏览器给我们发送了一系列的消息，当然我们现在可能看不懂。这其实就是一个报文，是浏览器传递给你的一些消息：比如这个User-Agent就是告诉服务器我是从什么样的客户端来的，Host就是这个消息的目标主机。

很明显，浏览器貌似也是通过socket和我们的服务器建立了TCP连接。

我们不妨把浏览器给我们发送的信息称之为请求，而这种请求的格式满足了http这样一个协议，在浏览器中我们打开百度后会显示对应的页面，是因为百度的服务器收到请求后会给浏览器响应，而我们刚才写的服务器，并没有对请求做出任何的响应。

这也就意味着，我们接收到http请求后，按照http协议的规范，书写http的响应，就能让浏览器做出相应的回应。

这里有一个最简单的响应报文：

1
2
3
4
5

HTTP/1.1 200 OK
Content-Length: 39
Content-Type: text/html;charset=UTF-8

<h1 style=\"color:red\">hello server!<h1>

这个报文的意图很明显：

• 第一行：服务器告诉浏览器，我们这个请求成功了。
• 第二行和第三行：是服务器告诉浏览器，我们这个响应的类型是个网页，内容长度是39字符。
• 最后一行是具体的网页数据。

所以，我们的Java代码可以这样去写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Server {
    public static void main(String[] args) throws IOException {
        // 创建一个服务器监听在8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        Socket server = serverSocket.accept();
        OutputStream outputStream = server.getOutputStream();
        // 按照http协议的格式封装一个报文
        String response = "HTTP/1.1 200 OK\r\n" +
                "Content-Length: 39\r\n" +
                "Content-Type: text/html;charset=UTF-8\r\n\r\n" +
                "<h1 style=\"color:red\">hello server!<h1>";
        // 将报文写出给浏览器
        outputStream.write(response.getBytes());
        outputStream.flush();
        // 这个输出流不要着急关，因为突然的关闭会导致浏览器和服务器的连接断开
    }
}

我们再来从浏览器访问我们的服务器看看：

发现红色的hello server已经在浏览器上了。

# 三、深入HTTP协议

# 1、HTTP协议简介

超文本传输协议（英文：HyperText Transfer Protocol，缩写：HTTP）是一种用于分布式、协作式和超媒体信息系统的应用层协议。HTTP是万维网的数据通信的基础，它和TCP/IP协议簇的其他协议一样，也是用于客户端和服务端的通信。

HTTP的发展是由蒂姆·伯纳斯-李于1989年在欧洲核子研究组织（CERN）所发起。HTTP的标准制定由万维网协会（World Wide Web Consortium，W3C）和互联网工程任务组（Internet Engineering Task Force，IETF）进行协调，最终发布了一系列的RFC，其中最著名的是1999年6月公布的 RFC 2616，定义了HTTP协议中现今广泛使用的一个版本——HTTP 1.1。

2014年12月，互联网工程任务组（IETF）的Hypertext Transfer Protocol Bis（httpbis）工作小组将HTTP/2标准提议递交至IESG进行讨论，于2015年2月17日被批准。 HTTP/2标准于2015年5月以RFC 7540正式发表，取代HTTP 1.1成为HTTP的实现标准。

注：什么是超文本

在互联网早期，我们输入的信息只能保存在本地，信息都是以文本的形式存在，但随着计算机的发展，人们不再满足与两台电脑之间的文字传输，还想要传输图片、音频、视频，甚至点击文字能实现超链接跳转，此时文本的语义就被扩大了，这种扩大后的文本就称之为超文本。

# 2、HTTP协议概述

HTTP是一个客户端终端（用户）和服务器端（网站）请求和应答的标准协议。我们通过使用网页浏览器或者其它的工具发起HTTP请求，这个客户端为我们称之为用户代理程序（user agent），服务器上存储着一些资源，比如HTML文件和图像。我们称这个应答服务器为源服务器（origin server）。

通常，由HTTP客户端发起一个请求，此时创建一个到服务器指定端口（默认是80端口）的tcp连接。HTTP服务器则在那个端口监听客户端的请求。一旦收到请求，服务器会向客户端返回一个状态，比如"HTTP/1.1 200 OK"，以及返回的内容，如请求的文件、错误消息、或者其它信息。

# 3、HTTP工作原理

以下是 HTTP 请求/响应的步骤：

1. 客户端连接到Web服务器。

​ 浏览器向 DNS 服务器请求解析该 URL 中的域名所对应的 IP 地址，一个HTTP客户端，通常是浏览器，与 Web服务器的HTTP端口（默认为80）建立一个TCP套接字连接。

2. 发送HTTP请求。

   通过【TCP套接字】，客户端向Web服务器发送一个文本的请求报文，一个请求报文由【请求行、请求头部、空行和请求数据】4部分组成。

3. 服务器接受请求并返回HTTP响应

   Web服务器【解析请求，定位请求资源】，然后将资源的复本写到TCP套接字，由客户端读取。一个响应由【状态行、响应头部、空行和响应数据】4部分组成。

4. 服务器释放连接TCP连接。

   若connection 模式为close，则服务器主动关闭TCP连接，客户端被动关闭连接，释放TCP连接。

   若connection 模式为keepalive，则该连接会保持一段时间，在该时间内可以继续接收请求。无论如何都会释放。

5. 客户端浏览器解析HTML内容

   客户端浏览器首先解析状态行，查看表明请求是否成功的状态代码。然后解析每一个响应头，响应头告知以下为若干字节的HTML文档和文档的字符集。客户端浏览器读取响应数据HTML，根据HTML的语法对其进行格式化，并在浏览器窗口中显示。

从以上的内容我们大致可以总结出以下几点：

1、Http是基于请求和响应的。

2、需要依托TCP协议进行三次握手连接、传输数据。

3、TCP的连接会被主动断开，并不是一直保持连接。

# 4、HTTP报文格式

一个完整的HTTP协议的报文主要由以下三个部分组成：

1. 起始行（请求行、响应行）：起始行 start line : 描述请求或响应的基本信息。
2. 首部字段（请求头、响应头）：使用key-value的形式更加详细的说明报文。
3. 消息正文（请求体、响应体）：实际的传输数据，不一定是文本，也有可能是图片、音频、视频等二进制数据。

一个请求报文的格式如下：

一个响应的报文格式如下：

接下来我们一点一点拨开http的面纱。

# （1）HTTP请求方法

​ HTTP/1.1协议中共定义了八种方法（也叫“动作”）来以不同方式操作指定的资源，我们目前最常见的有两种一种get，另外一种叫post。

​ 请求的目的就是获取或操作资源，互联网的任何数据，我们都能称之为资源，数据库内的一条数据，一个网页，一个视频都是资源。请求的方法决定了我们怎么去操作这个资源。

GET

向指定的资源发出“显示”请求。使用GET方法应该只用在读取数据，而不应当被用于产生“副作用”的操作中，常用语查询数据的请求。

POST

向指定资源提交数据，请求服务器进行处理（例如提交表单或者上传文件）。数据被包含在请求本文中。这个请求可能会创建新的资源或修改现有资源，或二者皆有。常用于对数据的增删改操作。

请求方式: get与post请求（通过form表单我们自己写写看）

• GET提交的数据会放在URL之后，也就是请求行里面，以?分割URL和传输数据，参数之间以&相连，如EditBook?name=test1&id=123456.（请求头里面那个content-type做的这种参数形式，后面讲） POST方法是把提交的数据放在HTTP包的请求体中.
• GET提交的数据大小有限制（因为浏览器对URL的长度有限制），而POST方法提交的数据没有限制.
• GET与POST请求在服务端获取请求数据方式不同，就是我们自己在服务端取请求数据的时候的方式不同了，这句废话昂。

# （2）URI

URI叫统一资源标识符 Uniform Resource Identifier，这是一个比较广的概念。

目前，我们有几种方式来表示本机或者网络的一个资源：

1. 通过【定位】的方式来标识资源，这种方式叫【统一资源定位符】，也就是我们说的【URL】（Uniform Resource Locator）。这种方式下我们可以这样表示一个资源，【http://www.aaa.com/image/girl.png】。很明显URL和位置密切相关，一旦目标主机挂了，或者目标资源更换了位置，URL就失效了。open in new window
2. 通过【命名】的方式来标识资源，这种方式叫【统一资源命名符】，也就是我们说的【URN】（Uniform Resource Name）。这种方式下每一个资源都有一个独立的资源名称，比如【DFAS12B12G3HJK1GHJ3G1HJG23G】，根据这个名字我们就能找到对应的资源，但是这种方式下，我们需要有一个解析器负责根据名字找到对应的资源位置，好处是不管资源怎么变动，我们都可以根据资源名字获取资源。

​ 但是事实上，理论上URN对我们更友好，但是互联网的资源这么多，专门为这么多资源搭建一个资源解析服务器也不太靠谱，所以我们见到的URI主要是以URL为主，可以说URL 约等于 URI。

我们不妨再回顾一下之前学过的URL格式：

超文本传输协议（HTTP）的统一资源定位符将从因特网获取信息的五个基本元素包括在一个简单的地址中：

• 协议：一般为http或https。
• URI：直接定位到对应的资源。
• 主机：通常为域名，有时为IP地址。
• 端口号：以数字方式表示，若为HTTP的默认值“:80”可省略，数字为0~65536。
• uri：以“/”字符区别路径中的每一个目录名称，根路径为‘/’。
• 查询：GET模式的窗体参数，以“?”字符为起点，每个参数以“&”隔开，再以“=”分开参数名称与数据，通常以UTF8的URL编码，避开字符冲突的问题。

1

以http://www.ydlclass.com:80/news/index.html?id=250&age=1 为例, 其中：

【http】是协议；【www.xinzhi.comopen in new window】是服务器； 【80】，是服务器上的默认网络端口号，默认不显示； 【/news/index.html】，是路径（URI：直接定位到对应的资源）； 【?id=250&page=1】，是查询条件。 大多数网页浏览器不要求用户输入网页中“[http://”的部分，因为绝大多数网页内容是超文本传输协议文件。 “80”是超文本传输协议文件的常用默认端口号，因此一般也不必写明。一般来说用户只要键入统一资源定位符的一部分

# （3）响应码

• 1xx消息——请求已被服务器接收，继续处理
• 2xx成功——请求已成功被服务器接收、理解、并接受
• 3xx重定向——需要后续操作才能完成这一请求
• 4xx请求错误——请求含有词法错误或者无法被执行，客户端
• 5xx服务器错误——服务器在处理某个正确请求时发生错误，500

一些常见的响应码

我们用一个简单的例子感受一下重定向：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Server302 {
    public static void main(String[] args) throws IOException {
        // 创建一个服务器监听在8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        Socket server = serverSocket.accept();

            OutputStream outputStream = server.getOutputStream();
            // 按照http协议的格式封装一个可以重定向的报文
            String response = "HTTP/1.1 302 Moved Temporarily\r\n" +
                    "Location: https://www.baidu.com\r\n\r\n";
            // 将报文写出给浏览器
            outputStream.write(response.getBytes());
            outputStream.flush();
            // 这个输出流不要着急关，因为突然的关闭会导致浏览器和服务器的连接断开
    }
}

当我们访问 127.0.0.1:8888 时，发现网页居然打开了百度，就相当于自动给我们在浏览器输入http://www.baidu.comopen in new window，并按下了回车。

# （3）http首部字段

​ http首部字段是构成http报文的重要元素，它能起到传递额外重要信息的作用，首部信息一般会提供报文类型、编码和大小、认证信息，缓存策略等信息。

**不用记、不用记。**如果需要记忆和深入目前只有一个Content-Type

HTTP/1.1 规范定义了如下 47 种首部字段，分为四大类，我们大致预览一下，不能一一讲解，详情可以通过看书深入理解

1、通用首部字段 9个

2、请求首部字段 共18个

3、响应首部字段 共9个

4、实体首部字段 共10个

# （4）http内容协商

​ 同一个web网页可能存在多个相同内容的网页，比如英文版和中文版，它们内容相同，语言却不同。当浏览器默认的语言不同，访问相同uri会出现不同结果，这种机制就是内容协商。

​ 内容协商机制是指客户端和服务器就响应的资源内容进行协商交涉，然后提供给客户端最合适的资源。内容协商会以响应资源的语言、字符集、编码等方式作为判断的标准。

​ 共有3种不同的方法可以决定服务器上哪个页面最适合客户端：让客户端来选择、服务器自动判定、让中间代理来选。这3种技术分别称为客户端驱动的协商、服务器驱动的协商以及透明协商。

客户端驱动

客户端发起请求，服务器发送可选项列表，客户端作出选择后再发送第二次请求。

• 优点：比较容易实现。

• 缺点：增加了时延，至少要发送两次请求，第一次请求获取资源列表，第二次获取选择的副本。

服务器驱动

服务器检查客户端的请求首部集并决定提供哪个版本的页面。

• 优点：比客户端驱动的协商要快。
• 缺点：首部集不匹配，服务器要做猜测。

透明协商

某个中间设备（通常是缓存代理）代表客户端进行协商。

• 优点：免除了web服务器的协商开销，比客户端驱动的协商要快。
• 缺点：HTTP并没有提供相应的规范。

其中，服务器驱动的解决方案应用较为广泛。

通用的内容协商首部集

客户端可以用下面列出的HTTP首部集发送用户的偏好信息：

• Accept：告知服务器发送何种媒体类型；
• Accept-Language：告知服务器发送何种语言；
• Accept-Charset：告知服务器发送何种字符集；
• Accept-Encoding：告知服务器采用何种编码。

【媒体类型】

​ 因特网上有数千种不同类型的数据，HTTP仔细地给每种要通过web传输的对象都打上了名为MIME类型（MIME type）的数据格式标签。最初设计MIME（Multipurpose Internet Mali Extension，多用途英特网邮件扩藏）是为了解决在不同的电子邮件系统之间搬移报文时存在的问题。MIME 在电子邮件系统中工作得非常好，因此 HTTP 也采纳了它，用它来描述并标记多媒体内容。

MIME 类型是一种文本标记，表示一种【主要的对象类型】和一个特定的【子类型】，中间由一条斜杠来分隔。

• HTML 格式的文本文档由【text/html】 类型来标记
• 普通的 ASCII 文本文档由 【text/plain】 类型来标
• JPEG 版本的图片为 【image/jpeg】 类型
• GIF 格式的图片为【image/gif】 类型
• Apple 的 QuickTime 电影为【video/quicktime 】类型
• 微软的 PowerPoint 演示文件为【application/vnd.ms-powerpoint】类型

当然还有很多很多.....

而我们以后见的最多的要数以下两种，这两种类型都是用来传递数据：

• application/json，学习了前端知识后，想必大家对json已经不再陌生了。
• application/x-www-form-urlencoded，我们之前都学习过表单，urlencoded格式，又叫 form 格式，它是一种表单格式。它使用键值对的方式进行表示，键和值之间用=，多个键值对之间用&

比如我们想在客户端和服务之间传递信息：

可以是这样的

1

name=polo&age=35&smoke=false

也可以是

1
2
3
4
5

{
  "name" :"polo",
  "age":35,
  "smoke":false
}

更多的mimeType可以查看：https://www.w3school.com.cn/media/media_mimeref.aspopen in new window

【注意】这些首部与实体首部非常类似。不过，这两种首部的用途截然不同。

实体首部集像运输标签，它们描述了把报文从服务器传输给客户端的过程中必须的各种报文主体属性。

而内容协商首部集是由客户端发送给服务器用于交换偏好信息的，以便服务器可以从文档的不同版本中选择出最符合客户端偏好的那个来提供服务。

服务器用下面列出的实体首部集来匹配客户端的Accept首部集：

目前为止，关于http协议的基础知识我们讲的差不多了，更多的知识会在后期的学习中不断的深入，我们不妨先将我们的小项目完善一下吧。

# 四、项目完善

本次项目的目的是实现一个小程序，在浏览器中输入URL能够打开一个文件夹下的html页面。

我们不妨将请求和响应封装成两个对象，毕竟字符串的操作实在是痛苦：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

/**
 * 将接收的请求报文转化为请求对象
 */
public class Request {

    private String protocol;
    // 请求方式
    private String type;
    // uri
    private String uri;
    // 请求头
    private Map<String,String> header = new HashMap<>();
    // 请求体
    private String body;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }


    public String getUri() {
        return uri;
    }

    public void setUri(String uri) {
        this.uri = uri;
    }

    public Map<String, String> getHeaders() {
        return header;
    }

    public void setHeaders(Map<String, String> header) {
        this.header = header;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getHeader(String key){
        return header.get(key);
    }

    public void addHeader(String key,String value){
        header.put(key,value);
    }

    public String getProtocol() {
        return protocol;
    }

    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

/**
 * 处理请求报文
 */
public class RequestHandler {

    /**
     * 将获取的请求报文封装成一个请求对象
     * @param requestMessage
     * @return
     */
    public static Request hand(String requestMessage){

        Request request = new Request();
        // 通过大量的截串获取对应信息
        String[] headerAndBody = requestMessage.split("\r\n\r\n");
        // 判断有没有请求体
        if(headerAndBody.length > 1){
            request.setBody(headerAndBody[1]);
        }
        // 将请求行和首部信息截取
        String[] lineAndHeader = headerAndBody[0].split("\r\n");
        String line = lineAndHeader[0];
        // 使用空格截取请求行信息
        String[] lines = line.split(" ");
        request.setType(lines[0]);
        request.setUri(lines[1]);
        request.setProtocol(lines[2]);
        // 遍历请求头
        for (int i = 1; i < lineAndHeader.length; i++) {
            String[] split = lineAndHeader[i].split(": ");
            request.addHeader(split[0],split[1]);
        }
        return request;
    }
}

响应：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

/**
 * 响应
 */
public class Response {

    // 协议
    private String protocol = "Http/1.1";
    // 响应码
    private String code = "200";
    // 信息
    private String message = "ok";
    // 响应头
    private Map<String,String> header = new HashMap<>();
    // 响应体
    private String body;

    public String getProtocol() {
        return protocol;
    }

    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Map<String, String> getHeaders() {
        return header;
    }

    public void setHeaders(Map<String, String> header) {
        this.header = header;
    }

    public String getHeader(String key){
        return header.get(key);
    }

    public void addHeader(String key,String value){
        header.put(key,value);
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

/**
 * @author itnanls(私信联系)
 * 处理响应的工具类
 */
public class ResponseHandler {

    // 定义我们网站的根目录
    public static final String BASE_PATH = "D:/www/";

    /**
     * 此方法用来生成一个响应的字符串
     * @param path
     * @return
     */
    public static String build(String path){
        String htmlPath = BASE_PATH + path;
        try ( FileInputStream fis = new FileInputStream(htmlPath)){
            // 使用输入流读取文件的内容
            String body = IOUtils.readString(fis);

            Response response = new Response();
            response.setBody(body);
            response.addHeader("Content-Type","text/html;charset=UTF-8");
            response.addHeader("Content-Length",Integer.toString(body.length()));

            return build(response);

        }catch (IOException e){
            e.printStackTrace();
        }
        return null;
    }


    // 将响应对象序列化成字符串报文
    public static String build(Response response){
        StringBuilder sb = new StringBuilder();
        sb.append(response.getProtocol()).append(" ")
                .append(response.getCode()).append(" ")
                .append(response.getMessage()).append("\r\n");
        for(Map.Entry<String,String> entry : response.getHeaders().entrySet()){
            sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\r\n");
        }

        if(response.getBody() != null){
            sb.append("\r\n").append(response.getBody());
        }
        return sb.toString();
    }
}

创建一个IO工具类负责从流中读取数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class IOUtils {

    // 读取流中的数据
    public static String readString(InputStream inputStream){
        try {
            int len;
            byte[] buffer = new byte[1024];
            StringBuilder sb = new StringBuilder();
            while (inputStream.available() > 0){
                len = inputStream.read(buffer);
                sb.append(new String(buffer,0,len));
            }
            return sb.toString();
        }catch (IOException e){
            e.printStackTrace();
        }
        return null;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

/**
 * 每个客户端的请求使用独立的线程处理
 * 当然你可以写成NIO的模式，只是比较复杂而已
 */
public class UserThread implements Runnable {

    private final Socket socket;

    public UserThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream();
        ) {
            String requestMessage = IOUtils.readString(inputStream);
            Request request = RequestHandler.hand(requestMessage);
            String uri = request.getUri();
            // 按照http协议的响应格式封装响应报文
            // 浏览器除了发送我们的请求，还会发送/favicon.ico请求，用来获取网站图标
            // 我们把它排除掉，不处理
            if (!"/favicon.ico".equals(uri)){
                // 直接使用输出流输出到浏览器
                String response = ResponseHandler.build(uri);
                outputStream.write(response.getBytes());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11

public class Server {
    public static void main(String[] args) throws IOException {
        // 创建一个服务器监听在8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        ExecutorService executorService = Executors.newFixedThreadPool(100);
        while (true){
            Socket server = serverSocket.accept();
            executorService.submit(new UserThread(server));
        }
    }
}

# 五、处理其他请求

我们给项目做一个升级版本，做一个登录的功能，能和数据库交互。

我们在D:/www下新建一个登录的页面，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
 <form action="/register.do" method="post">
    用户名：<input type="text" name="username" id="username" /> <br />
    密码：<input type="password" name="password" id="password" /><br />
    <input type="submit" value="注册" />
</form>   
</body>
</html>

我们首先拿个页面做注册，注册的本质就是插入一条数据，我们也是简单演示，其他额外的判断我们统统不做。

我们不妨先把数据层面的代码准备好：

首先，我们用最简单的方式搞一个获取连接的工具类，这里是为了简单的观察本质，所以我们也不用连接池，怎么简单怎么来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class JDBCUtil {
    public static Connection getConnection(){
        // 1.数据库连接的4个基本要素：
        InputStream in = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        try {
            properties.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }

        String url = properties.getProperty("url");
        String user = properties.getProperty("username");
        String password = properties.getProperty("password");

        //2.获取连接
        try {
            return DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
}

//User

1
2
3
4
5
6
7
8
9

public class User implements Serializable {

    private static final Long serialVersionUID = 1L;

    private Integer id;
    private String username;
    private String password;
    .... 省略其他
}

// 注册的本质就是插入一条数据，登录的本质就是通过用户名获取用户比较密码，我们先将这两个方法准备好。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public class UserDao {

    // 插入一个用户
    public void insertUser(User user){
        String sql = "insert into user (username,password)values(?,?)";
        try(Connection connection = JDBCUtil.getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1,user.getUsername());
            preparedStatement.setString(2,user.getPassword());
            preparedStatement.execute();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 根据用户名获取用户
    public User findUserByUsername(String username){
        String sql = "select id,username,password from user where username = ?";
        try(Connection connection = JDBCUtil.getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1,username);
            ResultSet resultSet = preparedStatement.executeQuery();
            if(resultSet.first()){
                User user = new User();
                user.setId(resultSet.getInt("id"));
                user.setUsername(resultSet.getString("username"));
                user.setPassword(resultSet.getString("password"));
                return user;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
}

核心的问题来了，

当页面点击提交按钮实际上是发送一个post请求，从浏览器我们可以看得出来。

与此同时，后台也出现了问题：

在处理注册信息的时候，还是以文件的方式去寻找了，但是我们不希望如此，

我们希望的是将来能有一个类去独立处理这个请求，那怎么办？

此时我们希望不同的请求能有不同的方式，

此时我们将响应的处理抽象成一个接口：

1
2
3
4
5
6
7
8
9
10

public interface Servlet {

    /**
     * 这个方法专门用来处理请求和响应
     * @param request
     * @param response
     */
    void service(Request request,Response response);

}

将之前的RespsoneHandler改为HTMLRespsoneHandler，专门处理网页

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

/**
 * @author itnanls(私信联系)
 * 处理响应的工具类
 */
public class HTMLResponseHandler implements ResponseHandler {

    private HTMLResponseHandler(){}

    private final static HTMLResponseHandler htmlResponseHandler
            = new HTMLResponseHandler();

    public static HTMLResponseHandler getInstance(){
        return htmlResponseHandler;
    }

    // 定义我们网站的根目录
    public static final String BASE_PATH = "D:/www/";

    /**
     * 此方法用来生成一个响应的字符串
     * @param request
     * @return
     */
    public String build(Request request){
        String htmlPath = BASE_PATH + request.getUri();
        try ( FileInputStream fis = new FileInputStream(htmlPath)){
            // 使用输入流读取文件的内容
            String body = IOUtils.readString(fis);

            Response response = new Response();
            response.setBody(body);
            response.addHeader("Content-Type","text/html;charset=UTF-8");
            response.addHeader("Content-Length",Integer.toString(body.getBytes().length));

            return response.buildMessage();

        }catch (IOException e){
            e.printStackTrace();
        }
        return null;
    }

}

于此同时，我们再创建一个：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/**
 * @author itnanls(私信联系)
 * 处理响应的工具类
 */
public class DoResponseHandler implements ResponseHandler {

    private DoResponseHandler(){}

    private final static DoResponseHandler htmlResponseHandler
            = new DoResponseHandler();

    public static DoResponseHandler getInstance(){
        return htmlResponseHandler;
    }


    /**
     * 此方法用来生成一个响应的字符串
     * @param request
     * @return
     */
    public String build(Request request){
        // 我要根据不同的uri得到不同的处理结果
        // 我们需要一个统一的出来请求响应的工具，不妨起个名字叫servlet
        Servlet servlet = Container.ENV.get(request.getUri());
        Response response = new Response();
        servlet.service(request,response);
        return response.buildMessage();
    }
}

于是我们可以根据不同的请求处理不同的响应了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class RegisterServlet implements Servlet{

    UserDao userDao = new UserDao();

    @Override
    public void service(Request request, Response response) {
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        User user = new User(username,password);
        userDao.insertUser(user);
        response.setBody("成功");
        response.addHeader("Content-Type","text/plain;charset=UTF-8");
        response.addHeader("Content-Length",Integer.toString(response.getBody().getBytes().length));
    }
}

接下来就是登录了：

我们写一个登录的servlet来处理这个uri

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class LoginServlet implements Servlet{

    UserDao userDao = new UserDao();

    @Override
    public void service(Request request, Response response) {
        String username = request.getParameter("username");
        User user = userDao.findUserByUsername(username);
        // 1、没有查询到用户
        // 2、查询到用户，但是密码不对
        if(user == null || user.getPassword().equals(request.getParameter("password"))){
            response.setBody("登陆失败");
            response.addHeader("Content-Type","text/html;charset=UTF-8");
            response.addHeader("Content-Length",Integer.toString(response.getBody().getBytes().length));
        } else {
            response.setBody("登陆成功");
            response.addHeader("Content-Type","text/html;charset=UTF-8");
            response.addHeader("Content-Length",Integer.toString(response.getBody().getBytes().length));
        }
    }
}

并且注册进去

1

ENV.put("/login.do",new LoginServlet());

登录是成功了，但是登录没有状态，哪里能说明这个客户端登录成功了呢？

# 六、状态的保存

http本身是不保存状态的，啥意思？就是客户端到服务器的连接不是长时间保持的，一个连接断开后，下一个请求会建立新的tcp连接，服务器不会知道我们之前连接过，说的简单一点就是，你登录了但是服务器不知道。

所以推出了session和cookie机制

cookie是记录在浏览器端的一个字符串，是一段不超过4KB的小型文本数据，由一个名称（Name）、一个值（Value）和其它几个用于控制Cookie有效期、安全性、使用范围的可选属性组成，

session是保存在服务器端的一个对象，比如map。它们俩互相配合让服务器有了能识别客户端一些状态的能力，意思就是服务就能知道这个客户端有没有登录等。cookie就相当于通行证，session就是门房，进去时需要从门房识别一个身份。

创建过程：

1. 当浏览器第一次向客户端发送请求时，服务器会为它创建一个session，同时相应会加一个头（Set-Cookie: jsessionid=ewrwerwer123）
2. 浏览器察觉到这个响应头之后会将信息保存在cookie当中，以后访问这个网站的时候就会一直带着这个cookie。
3. 当下一个请求发起时，会带着这个cookie的信息，服务器通过查询id找的session，通过session内保存的信息，就能获得这个客户端的状态。

那我们继续改造：

我们先看看请求中有没有cookie

我们尝试给它加个cookie

目前代码多了，我们就在打开html的地方处理一下

1

response.addHeader("set-Cookie", "jsessionid="+UUID.randomUUID());

重新观察

一次访问没有：

二次访问已经有了：

当然我们只是想在没有Cookie的创建：

1
2
3

if(cookie == null || !cookie.contains("jsessionid")){
    response.addHeader("set-Cookie", "jsessionid="+UUID.randomUUID());
}

处理请求和响应事实上是一个很麻烦的工作，我们确实需要一个工具帮我们方便的处理请求和响应。

这样有了id，我们还需要给每个客户端分配一个柜子：

先搞一个大柜子，每个session我们就用map处理，不就是存一点数据嘛！

1
2

public static final ConcurrentHashMap<String, Map<String,Object>> SESSIONS
            = new ConcurrentHashMap<>(8);

为每一个客户端分配一点点空间

1
2
3
4
5
6
7
8
9
10

if(cookie == null || !cookie.contains("jsessionid")){
    String sessionId = UUID.randomUUID().toString();
    response.addHeader("set-Cookie", "jsessionid="+sessionId);
    Container.SESSIONS.put(sessionId,new HashMap<>());
} else {
    String id = cookie.split("=")[1];
    Map<String, Object> session = Container.SESSIONS.get(id);
    if(session == null)
        Container.SESSIONS.put(id,new HashMap<>());
}

登录之后我们就能搞点事情了：

在登录servlet中添加：

1
2
3
4
5
6

String cookie = request.getHeader("Cookie");
if(cookie != null){
    String sessionId = cookie.split("=")[1];
    Map<String, Object> session = Container.SESSIONS.get(sessionId);
    session.put("user",user);
}

不妨我们再添加一个首页：

如果登录了就显示首页欢迎您：xxx，没有登录就显示首页两个字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class IndexServlet implements Servlet {

    @Override
    public void service(Request request, Response response) {
        String cookie = request.getHeader("Cookie");
        if (cookie != null) {
            String sessionId = cookie.split("=")[1];
            Map<String, Object> session = Container.SESSIONS.get(sessionId);
            if (session != null &&  session.get("user") != null) {
                Object user = session.get("user");
                User u = (User) user;
                response.setBody("首页，欢迎您：" + u.getUsername());
                response.addHeader("Content-Type", "text/html;charset=UTF-8");
                response.addHeader("Content-Length", Integer.toString(response.getBody().getBytes().length));
                return;
            }

        }

        response.setBody("首页");
        response.addHeader("Content-Type", "text/html;charset=UTF-8");
        response.addHeader("Content-Length", Integer.toString(response.getBody().getBytes().length));

    }
}

1

ENV.put("/index.do",new IndexServlet());

我们的项目目前先到此为止，从这个项目中，我们体会了很多。

配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<web-app>
    <data-source>
        <properties name="url">jdbc:mysql://127.0.0.1:3306/ydlclass?characterEncoding=utf8&serverTimezone=Asia/Shanghai</properties>
        <properties name="username">root</properties>
        <properties name="password">root</properties>
        <properties name="driverName">com.mysql.cj.jdbc.Driver</properties>
    </data-source>

    <servlets>
        <servlet>
            <url>/user</url>
            <servlet-class>com.ydlclass.controller.UserServlet</servlet-class>
        </servlet>
        <servlet>
            <url>/login</url>
            <servlet-class>com.ydlclass.controller.LoginServlet</servlet-class>
        </servlet>
        <servlet>
            <url>/register</url>
            <servlet-class>com.ydlclass.controller.RegisterServlet</servlet-class>
        </servlet>
        <servlet>
            <url>/index</url>
            <servlet-class>com.ydlclass.controller.IndexServlet</servlet-class>
        </servlet>
    </servlets>
</web-app>

# 第二章 JAKARTAEE历史

# 一、历史渊源

# 1、JavaEE

我们学习Java都知道Java是一门语言，它可以分为以下几个版本：

• JavaSE是指Java Standard Edition，Java标准版，就是一般Java程序的开发就可以(如桌面程序)，可以看作是JavaEE的子集。
• JavaEE是指Java Enterprise Edition，Java企业版，多用于企业级开发，包括web开发等等。也叫J2EE。
• JavaME是指Java Platform，Micro Edition。Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。

其实，怎么理解这个事情呢，用一个最简单的例子。

​ windows有基础的家庭版，是不是也有旗舰版，很明显旗舰版的功能要比家庭版强大，当然也更贵，你用盗版当我没说。当然它还有移动端的版本。

​ 其实就是这个道理，windows就好比Java语言，家庭版就好比Javase，旗舰版就好比Javaee，移动版就好比Javame。

​ 起初，SUN公司希望靠Javaee收版权费，但是受到Spring这些开源社区挑战之后，SUN公司又把它调整为一个半开源的版本，SUN公司找了一些联盟公司给它贡献组件，这个时期，SUN公司对外宣传Java EE是一套标准协议，他和他的联盟公司在这套协议下给大家贡献各种企业级框架。

​ 这就好比，有很多人在家庭版上开发了很多免费的程序，我们只要装上，功能比旗舰版还要强大。

​ 我们目前的理解就是Javaee是一个标准，定义了很多企业级开发的标准，说的简单一点就是，我写一些接口，大家可以按照我的规定写代码，这样我们的代码就能统一，扩展性就更好，但是标准是标准，做不做也是另一回事，我们不妨看几个Javeee的标准：

我们在这里列举几个常见的Javaee规范

1. JDBC（Java data base connectivity）：JDBC对程序员来讲是API，对实现与数据库连接的服务提供商而言是接口模型。
2. Servlet：Servlet是小服务程序的意思，JavaServlet就是一种小型的Java程序，一个servlet就是Java编程语言中的一个类。servlet和用户的通信采用请求/响应模式，用于动态响应客户机请求形式扩展了web服务器的功能，servlet全部由Java写成并且生成html。servlet和jsp结合使用，能提供更为强大的服务器功能。
3. JSP（Java Service Pages）：JSP是一种服务器端的编程技术，创建动态的，与平台无关构建基于Web的应用程序，是为了提供一种声明性的、以表示为中心的开发Servlet方法而设计的。它也是可移植的独立于平台或应用程序的方法来提供动态内容的有效方式，提供了方法来为web客户生成动态内容。提供了开发基于Servlet的动态内容的简单方法，并带有分离内容和显示逻辑的优点。
4. XML（Extensible Markup Language）：可扩展标记语言，标准通用标记语言的子集。Java提供了极好的技术支持和丰富的库来解析，修改或查询XML文档。
5. JNDI（Java naming and directoryinterface Java命名和目录接口）：包含大量的命名和目录服务，使用通用接口来访问不同种类的服务。
6. EJB（ Enterprise JavaBean）：EJB是JavaEE的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。
7. RMI （Remote method invoke ）：RMI调用远程对象上的方法，使用了序列化方式在客户端和服务端传递数据。
8. JavaMail：提供了一组抽象类定义构成一个邮件系统的对象，这些抽象类和接口支持消息存储、格式和传输的许多不同的实现，它是阅读，撰写和发送电子信息的可选包。
9. JMS（ Java Message Service）：JMS是Java消息服务应用程序接口，是一个Java平台中关于面向消息中间件的API，用于在两个应用程序之间，或分布式系统中发布消息，进行异步通信。

# 2、JAKARTA EE

​ 大名鼎鼎的Apache是Java开源组织的殿堂，现如今包含了350多个开源项目。当时Apache组织里面有很多C语言开发的项目，Java还是一门小众语言。为了发展Java Web项目，一群有志之士聚集在一起，启动了Jakarta项目。

​ 后来，Java变得非常的火爆，以至于Jakarta项目囊括了众多基于Java语言的开源软件。最后，不得不把个别项目从Jakarta中独立出来，成为Apache软件基金会的顶级项目，例如：Struts，HttpClient，Tomcat，Ant，Maven，JMeter，Velocity，JMeter，Commons等。一直到2011年12月，在所有子项目都被迁移为独立项目后，Jakarta名称就不再使用了。

​ 2017 年 8 月，Oracle（甲骨文）决定将 Java EE（Java Enterprise Edition）移交给开源组织，但是附加条件是：不允许开源组织用 Java 的名号。最终，Eclipse基金会接手了Java EE。但是，在给项目命名的时候，Eclipse基金会一筹莫展。为了起出合适的名字，Eclipse决定开始民意投票，并给出了 "Jakarta EE" 和 "Enterprise Profile" 两个备选名字。最后，Jakarta 以 64.4% 的票数获胜。从此之后，Java EE 正式更名为 Jakarta EE（雅加达）。从这个民意归属来看，再次证明了，Jakarta 的影响是及其深远的。

​ 我们打开官网：https://jakarta.ee/zh/about/，他是这么形容JAKARTAopen in new window EE的：

​ 其实，Java EE在中国从来没有大规模的流行过，Java EE在Web的代表核心就是EJB，现在根本没人用这个了。但是在Javaee中流行起来的几个标准流行至今，需要我们重点学习一下。

更多的标准我们可以看这里：https://jakarta.ee/specifications/open in new window

# 二、Tomcat

# 1、简介

​ Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成。由于有了Sun 的参与和支持，最新的【Servlet 和JSP 规范】总是能在Tomcat 中得到体现。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web 应用服务器。

​ Tomcat最初是由Sun的软件架构师open in new window詹姆斯·邓肯·戴维森开发的。后来他帮助将其变为开源项目，并由Sun贡献给Apache软件基金会open in new window。由于大部分开源项目O'Reilly都会出一本相关的书，并且将其封面设计成某个动物的素描，因此他希望将此项目以一个动物的名字命名。因为他希望这种动物能够自己照顾自己，最终，他将其命名为Tomcat（英语公猫或其他雄性猫科动物）。而O'Reilly出版的介绍Tomcat的书籍（ISBN 0-596-00318-8）[1]的封面也被设计成了一个公猫的形象。而Tomcat的Logo兼吉祥物也被设计为一只公猫。

对于tomcat的版本和servlet和jsp标准，以及jdk的支持如下：

所以我们要注意的是，引入的包一定要匹配

# 2、Tomcat 安装

下载

我们这里下载一个10.0版本，我们依然可以使用java8。

https://tomcat.apache.org/download-10.cgiopen in new window

安装

将下载的 .zip 压缩包 ， 解压到系统的目录（建议是没有中文不带空格的目录）下即可。

# 3、Tomcat 目录结构

Tomcat 的主要目录文件如下 ：

# 4、Tomcat 启动停止

启动

1

双击 bin/startup.bat 文件 ；

停止

1

双击 bin/shutdown.bat 文件 ；

访问

1

http://localhost:8080 

如果你能顺利打开这个页面就ok了：

# 第三章 Web开发进阶

# 一、Tomcat 架构

# 1、Http服务器请求处理

浏览器发给服务端的是一个HTTP格式的请求，HTTP服务器收到这个请求后，需要调用服务端程序来处理，所谓的服务端程序就是你写的Java类，一般来说不同的请求需要由不同的Java类来处理。

HTTP服务器不直接调用业务类，而是把请求交给容器来处理，容器通过Servlet接口调用业务类。因此Servlet接口和Servlet容器的出现，达到了HTTP服务器与业务类解耦的目的。而Servlet接口和Servlet容器这一整套规范叫作Servlet规范。Tomcat按照Servlet规范的要求实现了Servlet容器，同时它们也具有HTTP服务器的功能。作为Java程序员，如果我们要实现新的业务功能，只需要实现一个Servlet，并把它注册到Tomcat（Servlet容器）中，剩下的事情就由Tomcat帮我们处理了。

# 2、Servlet容器工作流程

为了解耦，HTTP服务器不直接调用Servlet，而是把请求交给Servlet容器来处理，那Servlet容器又是怎么工作的呢？

当客户请求某个资源时，HTTP服务器会用一个ServletRequest对象把客户的请求信息封装起来，然后调用Servlet容器的service方法，Servlet容器拿到请求后，根据请求的URL和Servlet的映射关系，找到相应的Servlet，如果Servlet还没有被加载，就用反射机制创建这个Servlet，并调用Servlet的init方法来完成初始化，接着调用Servlet的service方法来处理请求，把ServletResponse对象返回给HTTP服务器，HTTP服务器会把响应发送给客户端。

# 二、Tomcat架构和执行流程

# 1、首先介绍几个概念

Server：服务器，启动一个tomcat就是启动了一个服务器，一个Server可以有多个Service，一个Service可以有多个Connectior和Engine

Service：服务，一个server可以包含多个service 一个service维护多个Connector和一个Engine

Engine：叫引擎，也有资料叫Container，一个服务可以开一个引擎，就是一个公司可以有很多个门，不同身份的人从不同的门进，但是具体干活的就一个部门。引擎负责处理请求，不需要考虑请求链接，协议等。

Context：一个Context管理一个应用，其实就是我们写的程序。

Wrapper：每个都封装着一个Servlet（当然只局限于普通的Http请求）。

dns www.ydl.comopen in new window ---> 127.0.0.1,www.ydl2.com--->127.0.0.1

# 2、Tomcat运行流程

客户发送一个请求：http://localhost:8080/test/index.html。请求被发送到本机端口8080后，执行流程如下：open in new window

1. 被在那里侦听的Coyote HTTP/1.1 Connector获得,然后引擎负责处理请求，不需要考虑请求链接，协议等。
2. Connector把该请求交给它所在的Service的Engine来处理，并等待Engine的回应。
3. Engine获得请求localhost:8080/test/index.jsp，匹配它所有虚拟主机Host。
4. Engine匹配到名为localhost的Host(即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机)。
5. localhost Host获得请求/test/index.jsp，匹配它所拥有的所有Context。
6. Host匹配到路径为/test的Context(如果匹配不到就把该请求交给路径名为""的Context去处理)。
7. path="/test"的Context获得请求/index.jsp，在它的mapping table中寻找对应的servlet。
8. Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类，构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法。
9. Context把执行完了之后的HttpServletResponse对象返回给Host。
10. Host把HttpServletResponse对象返回给Engine。
11. Engine把HttpServletResponse对象返回给Connector。
12. Connector把HttpServletResponse对象返回给客户browser。

​ 我们在使用tomcat的时候可以不理会中间的实现的任何过程，专心于我们的业务代码的编写，不停的写servlet就行了，极大的提升了写代码的效率。

# 3、Tomcat 服务器配置

​ Tomcat 服务器的配置主要集中于 tomcat/conf 下的 catalina.policy、catalina.properties、context.xml、server.xml、tomcat-users.xml、web.xml 文件。

# （1）server.xml

server.xml 是tomcat 服务器的核心配置文件，包含了Tomcat的 Servlet 容器（Catalina）的所有配置。由于配置的属性特别多，我们在这里主要讲解其中的一部分重要配置。

【Server】是server.xml的根元素，用于创建一个Server实例，默认使用的实现类是 org.apache.catalina.core.StandardServer。

1
2
3

<Server port="8005" shutdown="SHUTDOWN">
    ...
</Server>

port : Tomcat 监听的关闭服务器的端口。

shutdown： 关闭服务器的指令字符串。

【Connector】 用于创建链接器实例。默认情况下，server.xml 配置了两个链接器，一个支持HTTP协议，一个支持AJP协议。因此大多数情况下，我们并不需要新增链接器配置，只是根据需要对已有链接器进行优化。

1

<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />

属性说明：

1） port： 端口号，Connector 用于创建服务端Socket 并进行监听， 以等待客户端请求链接。如果该属性设置为 0，Tomcat将会随机选择一个可用的端口号给当前Connector 使用。

2） protocol ： 当前Connector 支持的访问协议。 默认为 HTTP/1.1 。

3） connectionTimeOut : Connector 接收链接后的等待超时时间， 单位为 毫秒。 -1 表示不超时。

完整的配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />

  <GlobalNamingResources>

    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>


  <Service name="Catalina">

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

    <Engine name="Catalina" defaultHost="localhost">

      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t "%r" %s %b" />

      </Host>
    </Engine>
  </Service>
</Server>

​ 我们能得知的信息是：有个默认的服务是Catalina，这个服务默认开放了8080端口的连接器，默认的引擎也叫Catalina，它管理一个默认的主机localhost，localhost的根目录是webapp。

不妨我们打开webapp，我们能看到这里边已经有了几个项目了。

​ 这里边已经有了几个工程，这几个工程有管理工具，有例子程序，我们以后项目就可以放在这里。如果输入的后没有加项目名字，默认会进入ROOT，比如我们看到的首页就是ROOT中的工程。

​ 我们不妨在webapp中新建，app文件

重新启动tomcat，访问localhost:8080/app/index.html

结果如下。

给一个service增加监听端口：

1
2
3
4
5
6
7
8
9
10

<Service name="Catalina">
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

    <Connector port="9090" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="9443" />
    ...
</Service>

意思就是同时开了8080、9090以及8443和9443四个端口。这里只是测试，一般是没有必要的。

9090端口一样能打开，这就相当于给我们的服务开了好几个门，通过这几个门，数据都能进来。

比如我们可以这样去操作：

我们在hosts文件中再配置一个主机域名

路径是：C:\Windows\System32\drivers\etc

受用notepad++修改hosts文件：

再给我们本机配置一个主机域名：这时不管是localhost还是www.ydl.com都会指向本机：

接着就该位置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13

<Engine name="Catalina" defaultHost="localhost"> 
    <!-- 配置一个新的host指向d盘的目录 -->
    <Host name="www.ydl.com"  appBase="D:\\webapps"
          unpackWARs="true" autoDeploy="true">
    </Host>

    <!-- 原有的也是默认的host -->
    <Host name="localhost"  appBase="webapps"
          unpackWARs="true" autoDeploy="true">
        ...
    </Host>

</Engine>

当然我们在D盘下新建webapps，这只是个目录的名字，你可以在任何的地方，叫任何的名字：

我们新建目录app，并在app下新建index.html。

1

<h1>www.ydl.com</h1>

启动tomcat，访问http://www.ydl.com:8080/app/index.htmlopen in new window

成功了，这里我们验证了多了主机域名。

# 4、创建Javaweb项目

# （1）创建项目

直接创建一个Java项目，我们自己尝试构建：

# （2）创建名字

# （3）项目结构

按照我的项目结构创建目录。

# （4）构建web项目

进入项目构建的选项卡中：快捷键是 ctrl + shift + alt + s，也可以先点击file，再进入。

在facets选项中给项目添加特性：

点击加号，选择web，点击OK

这个指的是我们的xml所在的位置，一定要修改正确

很明显，我这个不对，如果不对，就点击减号删除掉，点击加新增一个。

修改后：

保证路径正确就行了，这个路径也要正确，如果不正确自行修改

添加一个artifacts，

它会自动给你添加：

点击确定，配置完成。

# （5）配置web服务器（tomcat）

点击+ 选择 tomcat Server 选择local

选择我们的tomcat10

选择artfacts，讲我们的工程部署上去。

点击确定

# （6）部署文件

# （7）启动

乱码修改：

# 第四章 Servlet规范

# 一、Servlet概述

# 1、 什么是 Servlet

​ Servlet 是基于 Jakarta 技术的 Web 组件，由容器管理，可生成动态内容。与其他基于 Jakarta 技术的组件一样，servlet 是独立于平台的 Java 类，它们被编译为与平台无关的字节码，这些字节码可以动态加载到支持 Jakarta 技术的 Web 服务器中并由其运行。容器，有时也称为 servlet 引擎，是提供 servlet 功能的 Web 服务器扩展。Servlet 通过 servlet 容器实现的请求/响应范式与 Web 客户端交互。

# 2、 什么是 Servlet 容器

​ Servlet 容器是 Web 服务器或应用程序服务器的一部分，它提供发送请求和响应的网络服务、解码基于 MIME 的请求以及格式化基于 MIME 的响应。Servlet 容器还通过其生命周期包含和管理 Servlet。

Servlet 容器可以内置到主机 Web 服务器中，也可以通过该服务器的本机扩展 API 作为附加组件安装到 Web 服务器。Servlet 容器也可以内置于或可能安装在支持 Web 的应用程序服务器中。

​ 所有 Servlet 容器都必须支持 HTTP 作为请求和响应的协议，但可以支持其他基于请求/响应的协议，例如 HTTPS（基于 SSL 的 HTTP）。容器必须实现的 HTTP 规范的必需版本是 HTTP/1.1 和 HTTP/2。

​ Java SE 8 是必须用来构建 Servlet 容器的底层 Java 平台的最低版本。

# 3、 一个例子

以下是一个典型的事件序列：

1. 客户端（例如，Web 浏览器）访问 Web 服务器并发出 HTTP 请求。
2. 请求由 Web 服务器接收并传递给 Servlet 容器。Servlet 容器可以在与主机 Web 服务器相同的进程中运行，也可以在同一主机上的不同进程中运行，或者在与其处理请求的 Web 服务器不同的主机上运行。
3. Servlet 容器根据其Servlet 的配置确定调用哪个 Servlet，并使用代表请求和响应的对象调用它。
4. Servlet 使用请求对象来找出远程用户是谁、POST作为此请求的一部分发送的HTTP参数以及其他相关数据。Servlet 执行它编程的任何逻辑，并生成数据发送回客户端。它通过响应对象将此数据发送回客户端。
5. Servlet 处理完请求后，Servlet 容器会确保正确刷新响应，并将控制权返回给主机 Web 服务器。

# 4、Servlet架构

下图展示了Servlet在Web应用程序中的位置：

# 二、Servlet核心技术

# 1、Servlet加载时机

​ 在默认情况下，当Web客户第一次请求访问某个Servlet时，Web容器会创建这个Servlet的实例。 当设置了web.xml中的子元素后，Servlet容器在启动Web应用时，将按照指定顺序创建并初始化这个Servlet。设置的数值大于0即可。例如：

1
2
3
4
5

<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.ydlclass.servlet.HelloServlet</servlet-class>
    <load-on-startup>2</load-on-startup>
</servlet>

# 2、Servlet的生命周期

先看与Servlet生命周期有关的三个方法：init(), service(), destroy(). Servlet生命周期可被定义为从创建直到毁灭的整个过程。以下是三个方法分别对应的Servlet过程：

• init()：Servlet进行初始化；
• service()：Servlet处理客户端的请求；
• destroy()：Servlet结束，释放资源；

在调用destroy()方法后，Servlet由JVM的垃圾回首器进行垃圾回收。

现在我们来详细讨论Servlet生命周期的方法：

init()方法：

​ Servlet被装载后，Servlet容器创建一个Servlet实例并且调用Servlet的init()方法进行初始化在Servlet生命周期中init()方法只被调用一次。

​ 当用户调用一个Servlet时，Servlet容器就会创建一个Servlet实例，每一个用户请求都会产生一个新的线程，init()方法简单的创建或加载一些数据，这些数据将会被用在Servlet的整个生命周期。

init()方法的定义如下：

1
2
3

public void init() throws ServletException {
  // 初始化代码...
}

service()方法：

​ service()方法是执行实际任务的主要方法。Servlet 容器（即 Web 服务器）调用 service()方法来处理来自客户端（浏览器）的请求，并把格式化的响应写回给客户端。

​ 每次服务器接收到一个 Servlet 请求时，服务器会产生一个新的线程并调用服务。service()方法检查 HTTP 请求类型（GET、POST、PUT、DELETE 等），并在适当的时候调用doGet()、doPost()等方法。

service()的定义如下：

1
2
3
4

public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException{
// service()代码...
}

destroy()方法：

​ destroy()方法只会被调用一次，在Servlet生命周期结束时被调用。destroy()方法可以让Servlet关闭数据库连接、停止后台、把cookie列表或点击计数器写入到磁盘，并执行其他类似的清理活动。 在调用destroy()方法之后，Servlet对象被标记为垃圾回收。

destroy()方法的定义如下所示：

1
2
3

public void destroy() {
    // 终止化代码...
  }

总结：

• 在首次访问某个Servlet时，init()方法会被执行，而且也会执行service()方法。
• 再次访问时，只会执行service()方法，不再执行init()方法。
• 在关闭Web容器时会调用destroy()方法。

# 3、实现一个Servlet

​ 当服务器接收到一个请求，就要有一个Servlet去处理这个请求，所以完成一个Servlet通常需要两步走。一方面要写一个java程序定义一个Servlet，另一方面要配置一下Servlet确定这个Servlet要处理哪一个请求。

# （1）创建Servlet的三种方式

• 实现javax.servlet.Servlet接口。
• 继承javax.servlet.GenericServlet类。
• 继承javax.servlet.http.HttpServlet类。

我们在日常开发中一般会使用第三种方法来进行Servlet的创建，前两种方法理解即可。

**注意：**创建Servlet文件后，需要在web.xml文件中完成Servlet配置，才可以使用。

通过实现Servlet接口，这个接口定义了servlet的生命周期，所有的方法需要我们实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class UserServlet implements Servlet {
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {

    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.getWriter().print("<h1>hello servlet</h1>");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {

    }
}

GenericServlet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    private static final long serialVersionUID = 1L;
    private transient ServletConfig config;

    public GenericServlet() {
    }

    public void destroy() {
    }

    public String getServletInfo() {
        return "";
    }

    public void init() throws ServletException {
    }

    public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    public String getServletName() {
        return this.config.getServletName();
    }

    ....
}

1
2
3
4
5
6

public class UserServlet extends GenericServlet {
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        servletResponse.getWriter().print("<h1>hello servlet</h1>");
    }
}

Http只是会根据请求的类型进行特殊的调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.servlet.http;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.servlet.DispatcherType;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public abstract class HttpServlet extends GenericServlet {


    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_get_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    protected long getLastModified(HttpServletRequest req) {
        return -1L;
    }



    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    // 还是会调用它，只是会根据请求的类型进行特殊的调用
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        long lastModified;
        if (method.equals("GET")) {
            lastModified = this.getLastModified(req);
            if (lastModified == -1L) {
                this.doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader("If-Modified-Since");
                } catch (IllegalArgumentException var9) {
                    ifModifiedSince = -1L;
                }

                if (ifModifiedSince < lastModified / 1000L * 1000L) {
                    this.maybeSetLastModified(resp, lastModified);
                    this.doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            lastModified = this.getLastModified(req);
            this.maybeSetLastModified(resp, lastModified);
            this.doHead(req, resp);
        } else if (method.equals("POST")) {
            this.doPost(req, resp);
        } else if (method.equals("PUT")) {
            this.doPut(req, resp);
        } else if (method.equals("DELETE")) {
            this.doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            this.doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            this.doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[]{method};
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(501, errMsg);
        }

    }

    ...

}

HttpServletRequest和ServletRequest都是接口

HttpServletRequest继承自ServletRequest

HttpServletRequest比ServletRequest多了一些针对于Http协议的方法。 例如：

getHeader()， getMethod() ， getSession()

# 三、Servlet的匹配规则

# 1、四种匹配规则

# （1） 精确匹配

<url-pattern>中配置的项必须与url完全精确匹配。

1
2
3
4
5
6

<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>/user/users.html</url-pattern>
    <url-pattern>/index.html</url-pattern>
    <url-pattern>/user/addUser</url-pattern>
</servlet-mapping>

当在浏览器中输入如下几种url时，都会被匹配到该servlet 　　http://localhost:8080/appDemo/user/users.htmlopen in new window 　　http://localhost:8080/appDemo/index.htmlopen in new window 　　http://localhost:8080/appDemo/user/addUseropen in new window

注意：

http://localhost:8080/appDemo/user/addUser?username=Tom&age=23open in new window 会被匹配到MyServlet。

# （2） 路径匹配

以“/”字符开头，并以“/*”结尾的字符串用于路径匹配

1
2
3
4

<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>/user/*</url-pattern>
</servlet-mapping>

路径以/user/开始，后面的路径可以任意。比如下面的url都会被匹配。

• http://localhost:8080/appDemo/user/users.htmlopen in new window
• http://localhost:8080/appDemo/user/addUseropen in new window
• http://localhost:8080/appDemo/user/bb//sdf/sdf/sdf/updateUseropen in new window

# （3）扩展名匹配

以“*.”开头的字符串被用于扩展名匹配

1
2
3
4
5

<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>*.jsp</url-pattern>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

则任何扩展名为jsp或action的url请求都会匹配，比如下面的url都会被匹配

• http://localhost:8080/appDemo/user/users.jspopen in new window
• http://localhost:8080/appDemo/toHome.actionopen in new window

# （4） 缺省匹配

1
2
3
4

<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

# 2、匹配顺序

1. 精确匹配。

2. 路径匹配，先最长路径匹配，再最短路径匹配。

3. 扩展名匹配。

   注意：使用扩展名匹配，前面就不能有任何的路径。

4. 缺省匹配，以上都找不到Servlet，就用默认的Servlet，配置为<url-pattern>/</url-pattern>

# 3、需要注意的问题

路径匹配和扩展名匹配无法同时设置

​ 匹配方法只有三种，要么是路径匹配（以“/”字符开头，并以“/*”结尾），要么是扩展名匹配（以“*.”开头），要么是精确匹配，三种匹配方法不能进行组合，不要想当然使用通配符。

• 如<url-pattern>/user/*.action</url-pattern>是非法的

• 另外注意：<url-pattern>/aa/*/bb</url-pattern>是精确匹配，合法，这里的*不是通配的含义

"/*"和"/"含义并不相同

• “/*”属于路径匹配，并且可以匹配所有request，由于路径匹配的优先级仅次于精确匹配，所以“/*”会覆盖所有的扩展名匹配，很多404错误均由此引起，所以这是一种特别恶劣的匹配模式。

• “/”是servlet中特殊的匹配模式，切该模式有且仅有一个实例，优先级最低，不会覆盖其他任何url-pattern，只是会替换servlet容器的内建default servlet ，该模式同样会匹配所有request。

Tomcat在%CATALINA_HOME%\conf\web.xml文件中配置了默认的Servlet，配置代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <init-param>
            <param-name>listings</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
<servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>fork</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>xpoweredBy</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
 </servlet>
<servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern>
</servlet-mapping>

    <!-- The mappings for the JSP servlet -->
<servlet-mapping>
        <servlet-name>jsp</servlet-name>
        <url-pattern>*.jsp</url-pattern>
        <url-pattern>*.jspx</url-pattern>
</servlet-mapping>

• “/*”和“/”均会拦截静态资源的加载，需要特别注意

# 4、举例

实际请求映射的结果

# 四、请求和响应

# 1、请求-reques

# （1）request概述

request是Servlet.service()方法的一个参数，类型为javax.servlet.http.HttpServletRequest。在客户端发出每个请求时，服务器都会创建一个request对象，并把请求数据封装到request中，然后再调用Servlet.service()方法时传递给service()方法，这说明在service()方法中可以通过request对象来获取请求数据。

request的功能可以分为以下几种：

• 封装了请求头数据；

• 封装了请求正文数据，如果是GET请求，那么就没有正文；

• request是一个域对象，可以把它当成Map来添加获取数据；

• request提供了请求转发和请求包含功能。（以后学习）

# （2）request获取请求头数据

request与请求头相关的方法有：

• String getHeader(String name)：获取指定名称的请求头；

• Enumeration getHeaderNames()：获取所有请求头名称；

• int getIntHeader(String name)：获取值为int类型的请求头。

# （3）request获取请求相关的其它方法

• request中还提供了与请求相关的其他方法，有些方法是为了我们更加便捷的方法请求头数据而设计，有些是与请求URL相关的方法。

• int getContentLength()：获取请求体的字节数，GET请求没有请求体，没有请求体返回-1；

• String getContentType()：获取请求类型，如果请求是GET，那么这个方法返回null；如果是POST请求，那么默认为application/x-www-form-urlencoded，表示请求体内容使用了URL编码；

• String getMethod()：返回请求方法，例如：GET

• Locale getLocale()：返回当前客户端浏览器的Locale。java.util.Locale表示国家和言语，这个东西在国际化中很有用；

• String getCharacterEncoding()：获取请求编码，如果没有setCharacterEncoding()，那么返回null，表示使用ISO-8859-1编码；

• void setCharacterEncoding(String code)：设置请求编码，只对请求体有效！注意，对于GET而言，没有请求体！！！所以此方法只能对POST请求中的参数有效！

• String getContextPath()：返回上下文路径，例如：/hello

• String getQueryString()：返回请求URL中的参数，例如：name=zhangSan

• String getRequestURI()：返回请求URI路径，例如：/hello/oneServlet

• StringBuffer getRequestURL()：返回请求URL路径，例如：http://localhost/hello/oneServlet，即返回除了参数以外的路径信息；open in new window

• String getServletPath()：返回Servlet路径，例如：/oneServlet

• String getRemoteAddr()：返回当前客户端的IP地址；

• String getRemoteHost()：返回当前客户端的主机名，但这个方法的实现还是获取IP地址；

• String getScheme()：返回请求协议，例如：http；

• String getServerName()：返回主机名，例如：localhost

• int getServerPort()：返回服务器端口号，例如：8080

案例：request.getRemoteAddr()：封IP

可以使用request.getRemoteAddr()方法获取客户端的IP地址，然后判断IP是否为禁用IP。

1
2
3
4
5
6

String ip = request.getRemoteAddr();      
if(ip.equals("127.0.0.1")) {       
    response. getWriter().print("您的IP已被禁止！");      
} else {       
    response.getWriter().print("Hello!");      
}  

# （4）request获取请求参数

最为常见的客户端传递参数方式有两种：

• 浏览器地址栏直接输入：一定是GET请求；

• 超链接：一定是GET请求；

• 表单：可以是GET，也可以是POST，这取决与<form>的method属性值。

GET请求和POST请求的区别：

l GET请求：

• 请求参数会在浏览器的地址栏中显示，所以不安全；

• 请求参数长度限制长度在1K之内；

• GET请求没有请求体，无法通过request.setCharacterEncoding()来设置参数的编码；

l POST请求：

• 请求参数不会显示浏览器的地址栏，相对安全；

• 请求参数长度没有限制；

下面是使用request获取请求参数的API：

• String getParameter(String name)：通过指定名称获取参数值；

1
2
3
4
5
6
7
8
9
10
11
12
13

public void doGet(HttpServletRequest  request, HttpServletResponse response)  throws ServletException,  IOException {      
    String v1 = request.getParameter("p1");      
    String v2 = request.getParameter("p2");      
    System.out.println("p1=" + v1);      
    System.out.println("p2=" + v2);    
}

public void doPost(HttpServletRequest  request, HttpServletResponse response) throws ServletException,  IOException {      
    String v1 = request.getParameter("p1");      
    String v2 = request.getParameter("p2");      
    System.out.println("p1=" + v1);     
    System.out.println("p2=" + v2);      
}  

• String[] getParameterValues(String name)：当多个参数名称相同时，可以使用方法来获取；

1
2
3

public void doGet(HttpServletRequest  request, HttpServletResponse response)   throws ServletException,  IOException {      
    String[] names =  request.getParameterValues("name");                                                            System.out.println(Arrays.*toString*(names));    
}

• Enumeration getParameterNames()：获取所有参数的名字；

1
2
3
4
5
6

public void doPost(HttpServletRequest  request, HttpServletResponse response)  throws ServletException,  IOException {      
    Enumeration names =  request.getParameterNames();      
    while(names.hasMoreElements()) {       
        System.out.println(names.nextElement());      
    }    
}

• Map getParameterMap()：获取所有参数封装到Map中，其中key为参数名，value为参数值，因为一个参数名称可能有多个值，所以参数值是String[]，而不是String。

1
2
3
4
5

Map<String,String[]> paramMap =  request.getParameterMap();      
for(String name : paramMap.keySet()) {       
    String[] values =  paramMap.get(name);       
    System.*out*.println(name + ": " + Arrays.*toString*(values));     
}

# （5）请求转发-重要

请求转发表示由多个Servlet共同来处理一个请求。例如Servlet1来处理请求，然后Servlet1又转发给Servlet2来继续处理这个请求。

在AServlet中，把请求转发到BServlet：

1
2
3
4
5
6
7

public class AServlet extends HttpServlet {    
    public void doGet(HttpServletRequest  request, HttpServletResponse response) throws ServletException,  IOException {      
        System.out.println("AServlet");     
        RequestDispatcher rd =  request.getRequestDispatcher("/BServlet");      
        rd.forward(request, response);    
    }  
}

1
2
3
4
5

public class BServlet extends HttpServlet {    
    public void doGet(HttpServletRequest  request, HttpServletResponse response)  throws ServletException,  IOException {      
        System.out.println("BServlet");    
    }  
} 

# （6）request 域方法

一个请求会创建一个request对象，如果在一个请求中经历了多个Servlet，那么多个Servlet就可以使用request来共享数据。

下面是request的域方法：

• void setAttribute(String name, Object value)：用来存储一个对象，也可以称之为存储一个域属性，

• Object getAttribute(String name)：用来获取request中的数据，当前在获取之前需要先去存储才行，例如：String value = (String)request.getAttribute(“xxx”);，获取名为xxx的域属性；

• void removeAttribute(String name)：用来移除request中的域属性，如果参数name指定的域属性不存在，那么本方法什么都不做；

• Enumeration getAttributeNames()：获取所有域属性的名称；

域方法通常在进行重定向时使用，多个Servlet共享数据。

# 2、响应-response

# （1）response概述

​ response是Servlet.service方法的一个参数，类型为javax.servlet.http.HttpServletResponse。

​ 在客户端发出每个请求时，服务器都会创建一个response对象，并传入给Servlet.service()方法。response对象是用来对客户端进行响应的，这说明在service()方法中使用response对象可以完成对客户端的响应工作。

response对象的功能分为以下四种：

• 设置响应头信息；

• 发送状态码；

• 设置响应正文；

• 重定向。

# （2）response响应正文

response是响应对象，向客户端输出响应正文（响应体）可以使用response的响应流，repsonse一共提供了两个响应流对象：

• PrintWriter out = response.getWriter()：获取字符流，处理字符；

• ServletOutputStream out = response.getOutputStream()：获取字节流，处理文件；

注意，在一个请求中，不能同时使用这两个流！也就是说，要么你使用repsonse.getWriter()，要么使用response.getOutputStream()，但不能同时使用这两个流。不然会抛出IllegalStateExceptionopen in new window异常。

# a、字符响应流

（1）字符编码

**重要：**在使用response.getWriter()时需要注意默认字符编码为ISO-8859-1，如果希望设置字符流的字符编码为utf-8，可以使用response.setCharaceterEncoding(“gbk”)来设置。这样可以保证输出给客户端的字符都是使用UTF-8编码的！

​ 但客户端浏览器并不知道响应数据是什么编码的！如果希望通知客户端使用UTF-8来解读响应数据，那么还是使用**response.setContentType("text/html;charset=utf-8")**方法比较好，

​ 因为这个方法不只会调用response.setCharaceterEncoding(“utf-8”)，还会设置content-type响应头，客户端浏览器会使用content-type头来解读响应数据。

（2）缓冲区

response.getWriter()是PrintWriter类型，所以它有缓冲区，缓冲区的默认大小为8KB。也就是说，在响应数据没有输出8KB之前，数据都是存放在缓冲区中，而不会立刻发送到客户端。当Servlet执行结束后，服务器才会去刷新流，使缓冲区中的数据发送到客户端。

如果希望响应数据马上发送给客户端：

• 向流中写入大于8KB的数据；

• 调用response.flushBuffer()方法来手动刷新缓冲区；

# （3）设置响应头信息

可以使用response对象的setHeader()方法来设置响应头！使用该方法设置的响应头最终会发送给客户端浏览器！

• response.setHeader(“content-type”, “text/html;charset=utf-8”)：

设置content-type响应头，该头的作用是告诉浏览器响应内容为html类型，编码为utf-8。而且同时会设置response的字符流编码为utf-8，即response.setCharaceterEncoding(“utf-8”)；

• response.setHeader("Refresh","5; URL=http://www.baidu.cnopen in new window")：5秒后自动跳转到百度主页。

# （4）设置状态码及其他方法

• response.setContentType("text/html;charset=utf-8")：等同于调用response.setHeader(“content-type”, “text/html;charset=utf-8”)；用它就行了。

• response.setCharacterEncoding(“utf-8”)：设置字符响应流的字符编码为utf-8；

• response.setStatus(200)：设置状态码；

• response.sendError(404, “您要查找的资源不存在”)：当发送错误状态码时，Tomcat会跳转到固定的错误页面去，但可以显示错误信息。

重定向和请求转发

# （5）重定向，重要

什么是重定向

当你访问http://www.sun.com时open in new window，你会发现浏览器地址栏中的URL会变成http://www.oracle.com/us/sun/index.htm，这就是重定向了。open in new window

重定向是服务器通知浏览器去访问另一个地址，即再发出另一个请求。

完成重定向

响应码为200表示响应成功，而响应码为302表示重定向。所以完成重定向的第一步就是设置响应码为302。

因为重定向是通知浏览器再第二个请求，所以浏览器需要知道第二个请求的URL，所以完成重定向的第二步是设置Location头，指定第二个请求的URL地址。

1
2
3
4
5
6

compublic class AServlet extends HttpServlet {    
public void doGet(HttpServletRequest  request, HttpServletResponse response)  throws ServletException,  IOException {      
    response.setStatus(302);      
    response.setHeader("Location", "http://www.baidu.com");    
}  
}  

上面代码的作用是：当访问AServlet后，会通知浏览器重定向到百度主页。客户端浏览器解析到响应码为302后，就知道服务器让它重定向，所以它会马上获取响应头Location，然发出第二个请求。

便捷的重定向方

1
2
3
4
5

public class AServlet extends HttpServlet {    
    public void doGet(HttpServletRequest  request, HttpServletResponse response)  throws ServletException,  IOException {      
        response.sendRedirect("http://www.baidu.com");    
    }  
}  

response.sendRedirect()方法会设置响应头为302，以设置Location响应头。

如果要重定向的URL是在同一个服务器内，那么可以使用相对路径，例如：

1
2
3
4
5

public class AServlet extends HttpServlet {  
    public void doGet(HttpServletRequest  request, HttpServletResponse response)       throws ServletException,  IOException {      
    response.sendRedirect("/hello/BServlet");    
    }  
}  

重定向的URL地址为：http://localhost:8080/hello/BServlet。open in new window

重定向小结

• 重定向是两次请求，请求转发是一次

• 重定向的URL可以是其它应用，不局限于当前应用；

• 重定向的响应头为302，并且必须要有Location响应头；

• 重定向就不要再使用response.getWriter()或response.getOutputStream()输出数据，不然可能会出现异常。

# 3、重定向和转发的区别

• 重定向是两次请求，转发是一个请求
• 重定向是浏览器的行为，请求转发是服务器行为
• 重定向浏览器的地址会发生改变，转发不会
• 重定向可以重定向到任何地址，转发只能在项目内转发

# 4、session和cookie

​ 会话的概念：在计算机中，尤其是在网络应用中，称为“会话控制”。

​ http是无状态的，它不保存状态，意思就是一个浏览器发的请求，随后就断开了，下一次发送请求就和上一次无关了。

​ 比如一个用户购买一个商品，第一次需要登录，如果再买一个时向服务器发送请求，服务器如果不知道是谁发的，那么他就得再登录一次，这显然是不合理的，于是就提出了cookie和session的概念。

​ cookie是记录在浏览器端的一个字符串，它的大小不能超过4k，session是保存在服务器端的一个对象。它们两互相配合让服务器有了能识别客户端一些状态的能力，意思就是服务就能知道这个客户端有没有登录等。cookie就相当于通行证，session就是门房，进去时需要从门房识别一个身份。

# （1）cookie

cookie是可以通过key和value构建的，我们可以给cookie添加一个有效期，单位是秒：

1

Set-Cookie：customer=huangxp; path=/foo; domain=.ibm.com; expires= Wednesday, 22-OCT-05 23:12:40 GMT;

1
2

Cookie cookie = new Cookie("jsession", UUID.randomUUID().toString());
resp.addCookie(cookie);

cookie除了key-value之外，还有一些字段用来控制cookie的行为：

expires/Max-Age 字段

​ 为此cookie超时时间。若设置其值为一个时间，那么当到达此时间后，此cookie失效。不设置的话默认值是Session，当浏览器关闭(不是浏览器标签页，而是整个浏览器) 后，此cookie失效。

1、过期时间，定cookie的生命期。如果是正数单位是秒，如果是负数代表关闭浏览器失效，如果设置成零也就是将cookie失效。

2、具体是值是过期日期。如果想让cookie的存在期限超过当前浏览器会话时间，就必须使用这个属性。当过了到期日期时，浏览器就可以删除cookie文件，没有任何影响。

Secure字段

设置是否只能通过https来传递此条cookie

• 安全，指定cookie的值通过网络如何在用户和WEB服务器之间传递。
• 这个属性的值或者是“secure”，或者为空。缺省情况下，该属性为空，也就是使用不安全的HTTP连接传递数据。如果一个 cookie 标记为secure，那么，它与WEB服务器之间就通过HTTPS或者其它安全协议传递数据。不过，设置了secure属性不代表其他人不能看到你机器本地保存的cookie。换句话说，把cookie设置为secure，只保证cookie与WEB服务器之间的数据传输过程加密，而保存在本地的cookie文件并不加密。如果想让本地cookie也加密，得自己加密数据。

Http字段

cookie的httponly属性。若此属性为true，则只有在http请求头中会带有此cookie的信息，而不能通过document.cookie来访问此cookie。

• 如果在Cookie中设置了”HttpOnly”属性，那么通过后台程序读取，JS脚本将无法读取到Cookie信息，这样能有效的防止XSS攻击。
• 但是设置HttpOnly属性，Cookie盗窃的威胁并没有彻底消除，因为cookie还是有可能传递的过程中被监听捕获后信息泄漏。

domain字段

• 域，指定关联的WEB服务器或域。
• 值是域名。这是对path路径属性的一个延伸。如果我们想让dev.mycompany.comopen in new window 能够访问bbs.mycompany.com设置的cookies，该怎么办? 我们可以把domain属性设置成“mycompany.comopen in new window”，并把path属性设置成“/”。不能把cookies域属性设置成与设置它的服务器的所在域不同的值。

Path字段

path字段为可以访问此cookie的页面路径。 比如domain是abc.comopen in new window，path是/test，那么只有/test路径下的页面可以读取此cookie。

• 路径，指定与cookie关联的WEB页。
• 值可以是一个目录，或者是一个路径。如果/head/index.html 建立了一个cookie，那么在/head/目录里的所有页面，以及该目录下面任何子目录里的页面都可以访问这个cookie。这就是说，在/head/stories/articles 里的任何页面都可以访问/head/index.html建立的cookie。但是，如果/zdnn/ 需要访问/head/index.html设置的cookies，该怎么办?这时，我们要把cookies的path属性设置成“/”。在指定路径的时候，凡是来自同一服务器，URL里有相同路径的所有WEB页面都可以共享cookies。现在看另一个例子：如果想让 /head/filters/ 和/head/stories/共享cookies，就要把path设成“/head”。

# （2）session