tomcat的默认端口号_tomcat的端口号

web-4-理解Tomcat中的HTTP请求和Servlet响应处理机制

HTTP&Tomcat&Servlet

• 了解JavaWeb开发的技术栈
• 理解HTTP协议和HTTP请求与响应数据的格式
• 掌握Tomcat的使用
• 掌握在IDEA中使用Tomcat插件
• 理解Servlet的执行流程和生命周期
• 掌握Servlet的使用和相关配置

1.Web概述

1.1 Web和JavaWeb的概念

在网站工作流程介绍，我们已经知道了什么是web(不知道的可以自行查看我的文章进行查看)。那么现在我们学习JavaWeb，什么是JavaWeb现在我们开始学习

1.2 JavaWeb技术栈

JavaWeb: 可以理解为
Java技术开发网站(web),网站结构又分为两种

• C/S架构 (Client/Server，客户机/服务器模式）(了解即可,比如那些APP)
• B/S架构 (Browser/Server，浏览器/服务器模式）

1.2.1 B/S架构

什么是B/S架构?
B/S 架构：Browser/Server，浏览器/服务器 架构模式。
特点:

• 浏览器最主要的客户端，这种架构模式统一客户端，将系统核心代码存储在服务器端。浏览器(客户端)只需要请求到服务器，Web资源，服务器把Web资源发送给浏览器即可。

B/S架构上网过程如下:

例子:
打开浏览器访问百度首页，输入要搜索的内容，点击回车或百度一下，就可以和搜索相关的内容,这就是一个B/S架构过程

思考:搜索的内容并不在我们自己的点上，那么这些内容从何而来？

答案很明显内容从百度服务器返回给我们的

百度小细节:

逢年过节百度的logo会更换不同的图片，服务端发生变化，客户端不需做任务事情就能最新内容

从上面介绍我们可以发现B/S架构有以下好处:

• 易于维护升级,服务器端升级后，客户端无需任何部署就可以使用到新的版本。

了解B/S架构后，我们后台开发注意服务端的开发和维护工作。在服务端将来会放很多资源,都有哪些资源存放在服务端?

• 静态资源:HTML、CSS、JavaScript、图片等。负责页面展现，资源是一成不变的，运行在浏览器
• 动态资源:Servlet、JSP 等。负责逻辑处理，资源是变化的，运行在服务器。
• 数据库:负责存储数据
• HTTP协议：定义通信规则

接下来我们具体介绍一下这些资源

1.2.2 静态资源

静态资源是指不需要经过服务器处理的文件，例如HTML、CSS、JavaScript、图片等。这些文件的内容在请求时不会发生改变，服务器只需要将它们原封不动地发送给客户端即可。静态资源一般存储在服务器的文件系统中，客户端通过URL直接访问它们。

• 静态资源主要包含HTML、CSS、JavaScript、图片等，主要负责页面的展示。
• 前面已经学习(HTML+CSS+JavaScript),使用这些技术我们就可以制作出效果比较丰富的网页，将来展现给用户。但是由于做出来的这些内容都是静态的，这就会导致所有的人看到的内容将是一模一样。
• 在日常上网的过程中，我们除了看到这些好看的页面以外，还会碰到很多动态内容，比如我们常见的百度登录效果:

张三登录以后在网页的右上角看到的是 张三，而李四登录以后看到的则是李四。所以不同的用户访问相同的资源看到的内容大多数是不一样的，要想实现这样的效果，光靠静态资源是无法实现的。

1.2.3 动态资源

动态资源是需要服务器在请求时进行一定处理后才能返回给客户端的文件，例如JSP、Servlet、
http://
ASP.NET
等。这些文件包含了动态生成内容的代码，服务器在接收到客户端请求后，会执行相应的处理逻辑，然后生成最终的响应结果返回给客户端。

• 动态资源主要包含Servlet、JSP等，负责逻辑运算。
• 动态资源处理完逻辑后会把得到的结果交给静态资源来进行展示，动态资源和静态资源要结合一起使用。
• 动态资源虽然可以处理逻辑，但是当用户来登录百度的时候，就需要输入用户名和密码,这个时候我们就又需要解决的一个问题是，用户在注册的时候填入的用户名和密码

思考:用户名和密码数据都存储在哪里?我们需要的时候又是从哪里来取呢?

数据就是存储在数据库中，当我们需要的时候从数据库中

1.2.4 数据库

• 数据库主要负责存储数据。
• 整个Web的访问过程就如下图所示:

(1)浏览器发送一个请求到服务端，去请求所需要的相关资源;
(2)资源分为动态资源和静态资源,动态资源可以是使用Java代码按照Servlet和JSP的规范编写的内容;
(3)在Java代码可以进行业务处理(比如登录，注册等逻辑)也可以从数据库中读取数据;
(4)拿到数据后，把数据交给HTML页面进行展示,再结合CSS和JavaScript使展示效果更好;
(5)服务端将静态资源响应给浏览器;
(6)浏览器将这些静态资源进行解析;
(7)解析后将效果展示在浏览器，用户就可以看到最终的结果。
在整个Web的访问过程中，会设计到很多技术，这些技术有已经学习过的，也有还未涉及到的内容，都有哪些还没有涉及到呢?

1.2.5 HTTP协议

• HTTP协议:主要定义通信规则
• 浏览器发送请求给服务器，服务器响应数据给浏览器，这整个过程都需要遵守一定的规则，之前大家学习过TCP、UDP，这些都属于规则，这里我们需要使用的是HTTP协议，这也是一种规则。

1.2.6 Web服务器

• Web服务器:负责解析 HTTP 协议，解析请求数据，并发送响应数据
• 浏览器按照HTTP协议发送请求和数据，后台就需要一个Web服务器软件来根据HTTP协议解析请求和数据，然后把处理结果再按照HTTP协议发送给浏览器
• Web服务器软件有很多，我们介绍目前最为常用的Tomcat服务器

到这为止，关于JavaWeb中用到的技术栈我们就介绍完了，这里面就只有HTTP协议、Servlet、JSP以及Tomcat这些知识是没有学习过的，所以整个Web核心主要就是来学习这些技术。

2, HTTP

2.1 简介

HTTP概念

HyperText Transfer Protocol，超文本传输协议，规定了浏览器和服务器之间
数据传输的规则。

• 数据传输规则指的是请求数据和响应数据需要按照指定的格式进行传输。
• 如果想知道具体的格式，可以打开浏览器，点击F12打开开发者工具，点击Network来查看某一次请求的请求数据和响应数据具体的格式内容，如下图所示:

注意:在浏览器中如果看不到上述内容，需要清除浏览器的浏览数据。chrome浏览器可以使用ctrl+shift+Del进行清除。

HTTP主要学习以下两方面内容:

• 请求数据
• 响应数据

在学习这两方面之前，我们先了解一下HTTP协议特点:

• 基于TCP协议: 面向连接，安全
  TCP是一种面向连接的(建立连接之前是需要经过三次握手)、可靠的、基于字节流的传输层通信协议，在数据传输方面更安全。
• 基于请求-响应模型的:一次请求对应一次响应
  请求和响应是一一对应关系
• HTTP协议是无状态协议:对于事物处理没有记忆能力。每次请求-响应都是独立的
  无状态指的是客户端发送HTTP请求给服务端之后，服务端根据请求响应数据，响应完后，不会记录任何信息。这种特性有优点也有缺点，
• 缺点:多次请求间不能共享数据
• 优点:速度快 请求之间无法共享数据会引发的问题，如:
• 京东购物，加入购物车和去购物车结算是两次请求，
• HTTP协议的无状态特性，加入购物车请求响应结束后，并未记录加入购物车是何商品
• 发起去购物车结算的请求后，因为无法哪些商品加入了购物车，会导致此次请求无法正确展示数据 具体使用的时候，我们发现京东是可以正常展示数据的，原因是Java早已考虑到这个问题，并提出了使用会话技术(Cookie、Session)来解决这个问题。具体如何来做，我们后面会详细讲到。

思考:刚才提到HTTP协议是规定了请求和响应数据的格式，那具体的格式是什么呢?

2.2 HTTP-请求数据格式

2.2.1 格式介绍

HTTP-请求协议:浏览器将数据以请求格式发送到服务器

• 包括：请求行、请求头 、请求体 在HTTP1.1版本中，浏览器访问服务器的几种方式：

在我们实际应用中常用的也就是 ：GET、POST

GET方式的请求协议：。

• 请求行 ：HTTP请求中的第一行数据。由：请求方式、资源路径、协议/版本组成（之间使用空格分隔）
• 请求方式：GET
• 资源路径：/brand/findAll?name=OPPO&status=1
• 请求路径：/brand/findAll
• 请求参数：name=OPPO&status=1
• 请求参数是以key=value形式出现
• 多个请求参数之间使用&连接
• 请求路径和请求参数之间使用?连接

• 协议/版本：HTTP/1.1
• 请求头 ：第二行开始，上图黄色部分内容就是请求头。格式为key: value形式
• http是个无状态的协议，所以在请求头设置浏览器的一些自身信息和想要响应的形式。这样服务器在收到信息后，就可以知道是谁，想干什么了

常见的HTTP请求头有:

Host: 表示请求的主机名

User-Agent: 浏览器版本。 例如：Chrome浏览器的标识类似Mozilla/5.0 ...Chrome/79 ，IE浏览器的标识类似Mozilla/5.0 (Windows NT ...)like Gecko

Accept：表示浏览器能接收的资源类型，如text/*，image/*或者*/*表示所有；

Accept-Language：表示浏览器偏好的语言，服务器可以据此返回不同语言的网页；

Accept-Encoding：表示浏览器可以支持的压缩类型，例如gzip, deflate等。

Content-Type：请求主体的数据类型

Content-Length：数据主体的大小（单位：字节）

举例说明：服务端可以根据请求头中的内容来客户端的相关信息，有了这些信息服务端就可以处理不同的业务需求。

比如:

• 不同浏览器解析HTML和CSS标签的结果会有不一致，所以就会导致相同的代码在不同的浏览器会出现不同的效果
• 服务端根据客户端请求头中的数据到客户端的浏览器类型，就可以根据不同的浏览器设置不同的代码来达到一致的效果（这就是我们常说的浏览器兼容问题）
• 请求体 ：存储请求参数
• GET请求的请求参数在请求行中，故不需要设置请求体

POST方式的请求协议：

• 请求行(以上图中红色部分)：包含请求方式、资源路径、协议/版本
• 请求方式：POST
• 资源路径：/brand
• 协议/版本：HTTP/1.1
• 请求头(以上图中黄色部分)
• 请求体(以上图中绿色部分) ：存储请求参数
• 请求体和请求头之间是有一个空行隔开（作用：用于标记请求头结束）

GET请求和POST请求的区别：

2.3 HTTP-响应数据格式

2.3.1 格式介绍

HTTP-响应协议:服务器将数据以响应格式返回给浏览器

• 包括：响应行 、响应头 、响应体

• 响应行(以上图中红色部分)：响应数据的第一行。响应行由协议及版本、响应状态码、状态码描述组成
• 协议/版本：HTTP/1.1
• 响应状态码：200
• 状态码描述：OK
• 响应头(以上图中黄色部分)：响应数据的第二行开始。格式为key：value形式
• http是个无状态的协议，所以可以在请求头和响应头中设置一些信息和想要执行的动作，这样，对方在收到信息后，就可以知道你是谁，你想干什么

常见的HTTP响应头有:

  Content-Type：表示该响应内容的类型，例如text/html，image/jpeg ；
 
 Content-Length：表示该响应内容的长度（字节数）；
 
 Content-Encoding：表示该响应压缩算法，例如gzip ；
 
 Cache-Control：指示客户端应如何缓存，例如max-age=300表示可以最多缓存300秒 ;
 
 Set-Cookie: 告诉浏览器为当前页面所在的域设置cookie ;

• 响应体(以上图中绿色部分)： 响应数据的最后一部分。存储响应的数据
• 响应体和响应头之间有一个空行隔开（作用：用于标记响应头结束）

2.3.2 响应状态码

关于响应状态码，我们先主要认识三个状态码，其余的等后期用到了再去掌握：

• 200 ok 客户端请求成功
• 404 Not Found 请求资源不存在
• 500 Internal Server Error 服务端发生不可预期的错误

3 WEB服务器-Tomcat

3.1 简介

3.1.1 服务器概述

服务器硬件

• 指的也是计算机，只不过服务器要比我们日常使用的计算机大很多。

服务器，也称伺服器。是提供计算服务的设备。由于服务器需要响应服务请求，并进行处理，因此一般来说服务器应具备承担服务并且保障服务的能力。

服务器的构成包括处理器、硬盘、内存、系统总线等，和通用的计算机架构类似，但是由于需要提供高可靠的服务，因此在处理能力、稳定性、可靠性、安全性、可扩展性、可管理性等方面要求较高。

在网络环境下，根据服务器提供的服务类型不同，可分为：文件服务器，数据库服务器，应用程序服务器，WEB服务器等。

服务器只是一台设备，必须安装服务器软件才能提供相应的服务。

服务器软件

服务器软件：基于ServerSocket编写的程序

• 服务器软件本质是一个运行在服务器设备上的应用程序
• 能够接收客户端请求，并根据请求给客户端响应数据

3.1.2 Web服务器

Web服务器是一个应用程序(软件)，对HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作(不用程序员自己写代码去解析http协议规则)，让Web开发更加便捷。主要功能是
提供网上信息浏览服务。

Web服务器是安装在服务器端的一款软件，将来我们把自己写的Web项目部署到Tomcat服务器软件中，当Web服务器软件启动后，部署在Web服务器软件中的页面就可以直接通过浏览器来访问了。

Web服务器软件使用步骤

• 准备静态资源
• 下载安装Web服务器软件
• 将静态资源部署到Web服务器上
• 启动Web服务器使用浏览器访问对应的资源

介绍了Web服务器软件的使用后，思考一个问题。 思考:Web服务器是指将服务器软件安装到服务器上，那么web服务器有哪些？

• jetty
• WebLogic
• WebSphere
• Tomcat 当然除了我列举出来的服务器软件，还有很多服务器软件，我们要学习的是Tomcat,因为Tomcat是开源免费的轻量级web服务器，其他列举出来的服务器软件都是需要收费的。

我们会从以下这些方向去学习Tomcat:

1. 简介：初步认识下Tomcat
2. 基本使用: 安装、卸载、启动、关闭、配置和项目部署，这些都是对Tomcat的基本操作
3. IDEA中如何创建Maven Web项目
4. IDEA中如何使用Tomcat,后面这两个都是我们以后开发经常会用到的方式

3.1.3 Tomcat

Tomcat服务器软件是一个免费的开源的web应用服务器。是Apache软件基金会的一个核心项目。由Apache，Sun和其他一些公司及个人共同开发而成。

由于Tomcat只支持Servlet/JSP少量JavaEE规范，所以是一个开源免费的轻量级Web服务器。

JavaEE规范： JavaEE => Java Enterprise Edition(Java企业版)

avaEE规范就是指Java企业级开发的技术规范总和。包含13项技术规范：JDBC、JNDI、EJB、RMI、JSP、Servlet、XML、JMS、Java IDL、JTS、JTA、JavaMail、JAF

因为Tomcat支持Servlet/JSP规范，所以Tomcat也被称为Web容器、Servlet容器。JavaWeb程序需要依赖Tomcat才能运行。

Tomcat的官网: https://tomcat.apache.org/

3.2 基本使用

3.2.1 下载

直接从官方网站下载：https://tomcat.apache.org/download-90.cgi

Tomcat软件类型说明：

• tar.gz文件，是linux和mac操作系统下的压缩版本
• zip文件，是window操作系统下压缩版本（我们选择zip文件） 大家可以自行下载，也可以直接使用资料中已经下载好的资源，

3.2.2 安装与卸载

安装: Tomcat是绿色版，直接解压即安装

在D盘的tomcat目录下，将
apache-tomcat-9.0.78-windows-x64.zip进行解压缩，会得到一个
apache-tomcat-9.0.78的目录，Tomcat就已经安装成功。

注意:Tomcat进行解压缩的时候，最好不要包含中文和空格目录，如果存在可能会存在程序部署失败问题 apache-tomcat-9.0.27目录就能看到如下目录结构如下:

bin：目录下有两类文件:

• 一种是以.bat结尾的，是Windows系统的可执行文件
• 一种是以.sh结尾的，是Linux系统的可执行文件。

webapps：就是以后项目部署的目录

卸载：卸载比较简单，可以直接删除目录即可

3.2.3 启动与关闭

启动Tomcat :
方式一：

• 双击tomcat解压目录/bin/startup.bat文件即可启动tomcat

方式二：

• 使用cmd命令启动Tomcat(推荐使用，可以发现启动失败的问题)

注意: tomcat服务器启动后,黑窗口不会关闭,只要黑窗口不关闭,就证明tomcat服务器正在运行

Tomcat的默认端口为8080，所以在浏览器的地址栏输入：http://127.0.0.1:8080 即可访问tomcat服务器

127.0.0.1 也可以使用localhost代替。如：
http://localhost:8080

能看到以上图片中内容就说明Tomcat已经启动成功
注意 ：Tomcat启动的过程中，遇到控制台有中文乱码时，可以通常修改conf/logging.prooperties文件解决

关闭: 关闭有四种方式

1.强制关闭：直接x掉Tomcat窗口（不建议）

2.正常关闭：双击bin\shutdown.bat

3.正常关闭: 使用cmd命令行输入shutdown.bat

4.正常关闭：在Tomcat启动窗口中按下 Ctrl+C

• 说明：如果按下Ctrl+C没有反映，可以多按几次

3.2.4 常见问题

问题1：Tomcat启动时，窗口一闪而过

• 检查JAVA_HOME环境变量是否正确配置

问题2：端口号冲突

• 发生问题的原因：Tomcat使用的端口被占用了。
• 解决方案：换Tomcat端口号
• 要想修改Tomcat启动的端口号，需要修改 conf/server.xml文件

注: HTTP协议默认端口号为80，如果将Tomcat端口号改为80，则将来访问Tomcat时，将不用输入端口号。

3.2.5 部署项目

方式一:将项目放置到 webapps 目录下， 即部署完成

• 在webapps目录下创建一个文件夹hello
• 在hello文件夹下存放两个html文件，分别是b.html和index.html

a.html

   <!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>a</title>
</head>
<body>
 <h1>Hello A Html</h1>
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>Index</title>
</head>
<body>
 <h1 style="color: #FF3366">Hello Index</h1>
</body>
</html>

• 通过浏览器访问http://localhost:8080/hello/a.html，能看到下面的内容就说明项目已经部署成功。

思考:如何访问http://localhost:8080/hello,会看到什么内容?

默认访问的index.html页面

方式二:将项目压缩文件.war放置到 webapps 目录下， 即部署完成

项目中的资源也会越来越多，项目在拷贝的过程中也会越来越费时间，使用项目压缩文件.war解决

步骤:

• 将整个项目使用压缩工具打包成一个zip文件，注：在目录的下一级打包
• 改zip的扩展名为war
• 复制到webapps目录下，tomcat会自动解压成一个同名的目录。 注意:必须是zip压缩包,里面的文件不能有中文名 这里就不进行演示了，因为java项目是可以打包成war包的，上面只是演示

3.3 Maven创建Web项目

介绍完Tomcat的基本使用后，我们来学习在IDEA中如何创建Maven Web项目，学习这种方式的原因是以后Tomcat中运行的绝大多数都是Web项目，而使用Maven工具能更加简单快捷的把Web项目给创建出来，所以Maven的Web项目具体如何来构建呢?

在真正创建Maven Web项目之前，我们先要知道Web项目长什么样子，具体的结构是什么?

3.3.1 Web项目结构

Web项目的结构分为:开发中的项目和开发完可以部署的Web项目,这两种项目的结构是不一样的，我们一个个来介绍下:

• Maven Web项目结构: 开发中的项目
• 开发完成部署的Web项目

• 开发项目通过执行Maven打包命令package,可以到部署的Web项目目录
• 编译后的Java字节码文件和resources的资源文件，会被放到WEB-INF下的classes目录下
• pom.xml中依赖坐标对应的jar包，会被放入WEB-INF下的lib目录下

3.3.2 创建Maven Web项目

具体的步骤包含:

1.创建Maven项目

2.选择不使用Web项目骨架

3.输入Maven项目坐标创建项目

4.在pom.xml设置打包方式为war

5.补齐Maven Web项目缺失webapp的目录结构

6.补齐Maven Web项目缺失WEB-INF/web.xml的目录结构

1. 创建Maven项目

1. 选择不使用Web项目骨架

1. 输入Maven项目坐标创建项目

1. 在pom.xml设置打包方式为war,默认是不写代表打包方式为jar

1. 补齐Maven Web项目缺失webapp的目录结构

1. 补齐Maven Web项目缺失WEB-INF/web.xml的目录结构

1. 补充完后，最终的项目结构如下:

3.4 IDEA使用Tomcat

• Maven Web项目创建成功后，通过Maven的package命令可以将项目打包成war包，将war文件拷贝到Tomcat的webapps目录下，启动Tomcat就可以将项目部署成功，然后通过浏览器进行访问即可。
• 然而我们在开发的过程中，项目中的内容会经常发生变化，如果按照上面这种方式来部署测试，是非常不方便的

思考:如何在IDEA中能快速使用Tomcat呢?

在IDEA中集成使用Tomcat方式：

• 集成本地Tomcat

3.4.1 集成本地Tomcat

目标: 将刚才本地安装好的Tomcat9集成到IDEA中，完成项目部署，具体的实现步骤

1. 打开添加本地Tomcat的面板

1. 指定本地Tomcat的具体路径

1. 修改Tomcat的名称，此步骤可以不改，只是让名字看起来更有意义，HTTP port中的端口也可以进行修改，比如把8080改成80

1. 将开发项目部署项目到Tomcat中

扩展内容： xxx.war和 xxx.war exploded这两种部署项目模式的区别?

• war模式是将WEB工程打成war包，把war包发布到Tomcat服务器上
• war exploded模式是将WEB工程以当前文件夹的位置关系发布到Tomcat服务器上
• war模式部署成功后，Tomcat的webapps目录下会有部署的项目内容
• war exploded模式部署成功后，Tomcat的webapps目录下没有，而使用的是项目的target目录下的内容进行部署
• 建议大家开发选war:exploded模式

1. 部署成功后，就可以启动项目，为了能更好的看到启动的效果，可以在webapp目录下添加a.html页面

1. 启动成功后，可以通过浏览器进行访问测试

1. 最终的注意事项

至此，IDEA中集成本地Tomcat进行项目部署的内容我们就介绍完了

4. Servlet

4.1 简介

• Servlet 是 Java提供的一门动态web资源开发技术
• Servlet 是JavaEE 规范之一，其实就是一个接口，将来我们需要定义Servlet类实现Servlet接口，并由web服务器运行Servlet

介绍完Servlet是什么以后，接下来我们就按照快速入门->执行流程->生命周期->体系结构->urlPattern配置->XML配置的学习步骤，一步步完成对Servlet的知识学习，首选我们来通过一个入门案例来快速把Servlet用起来。

4.2 快速入门

具体的步骤包含:

1.创建 web项目，导入 Servlet依赖坐标

2.创建：定义一个类，实现 Servlet接口，并重写接口中所有方法，并在 service方法中输入一句话

3.配置：在类上使用@WebServlet 注解，配置该 Servlet的访问路径

4.访问：启动 Tomcat，浏览器输入URL 访问该Servlet

1. 创建 web项目，导入 Servlet依赖坐标

    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
    </dependencies>

1. 创建：定义一个类，实现 Servlet接口，并重写接口中所有方法，并在 service方法中输入一句话

1. 配置：在类上使用@WebServlet 注解，配置该 Servlet的访问路径

package com.zbbmeta.servlet;


import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;

@WebServlet("/hello")
public class HelloServlet implements Servlet {
    @Override
    public void init(ServletConfig config) throws ServletException {

    }

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

    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("Hello Servlet ...");
    }

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

    @Override
    public void destroy() {

    }
}

1. 访问：启动 Tomcat，浏览器输入URL 访问该Servlet

http://localhost:8080/tomcat_one_war_exploded/hello

1. 器访问后，在控制台会打印Hello Servlet ... 说明servlet程序已经成功运行。

4.3 执行流程

Servlet程序已经能正常运行，但是我们需要思考个问题: 我们并没有创建HelloServlet类的对象，也没有调用对象中的service方法，为什么在控制台就打印了- Hello Servlet ...这句话呢?

要想回答上述问题，我们就需要对Servlet的执行流程进行一个学习。

• 浏览器发出http://localhost:8080/tomcat_one_war_exploded/hello请求，从请求中可以解析出三部分内容，分别是localhost:8080、tomcat_one_war_exploded、hello
• 根据localhost:8080可以找到要访问的Tomcat Web服务器
• 根据tomcat_one_war_exploded可以找到部署在Tomcat服务器上的web-demo项目
• 根据hello可以找到要访问的是项目中的哪个Servlet类，根据@WebServlet后面的值进行匹配
• 找到HelloServlet这个类后，Tomcat Web服务器就会为HelloServlet这个类创建一个对象，然后调用对象中的service方法
• HelloServlet实现了Servlet接口，所以类中必然会重写service方法供Tomcat Web服务器进行调用
• service方法中有ServletRequest和ServletResponse两个参数，ServletRequest封装的是请求数据，ServletResponse封装的是响应数据，后期我们可以通过这两个参数实现前后端的数据交互

小结

介绍完Servlet的执行流程，需要大家掌握两个问题：

1. Servlet由谁创建?Servlet方法由谁调用?

Servlet由web服务器创建，Servlet方法由web服务器调用

1. 服务器怎么知道Servlet中一定有service方法?

因为我们自定义的Servlet,必须实现Servlet接口并复写其方法，而Servlet接口中有service方法

4.4 生命周期

介绍完Servlet的执行流程后，我们知道Servlet是由Tomcat服务器帮我们创建的。

思考:Tomcat什么时候创建的Servlet对象?

要想回答上述问题，我们就需要对Servlet的生命周期进行一个学习。

• 生命周期: 对象的生命周期指一个对象从被创建到被销毁的整个过程。
• Servlet运行在Servlet容器(web服务器)中，其生命周期由容器来管理，分为4个阶段：

1. 加载和实例化：默认情况下，当Servlet第一次被访问时，由容器创建Servlet对象

/**
 * 默认情况，Servlet会在第一次访问被容器创建，但是如果创建Servlet比较耗时的话，
 * 那么第一个访问的人等待的时间就比较长，用户的体验就比较差，
 * 那么我们能不能把Servlet的创建放到服务器启动的时候来创建，具体如何来配置?
 */
@WebServlet(value = "/hello",loadOnStartup = 1)
loadOnstartup的取值有两类情况
 （1）负整数:第一次访问时创建Servlet对象
 （2）0或正整数:服务器启动时创建Servlet对象，数字越小优先级越高

1. 初始化：在Servlet实例化之后，容器将调用Servlet的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化的工作。该方法只调用一次
2. 请求处理：每次请求Servlet时，Servlet容器都会调用Servlet的service()方法对请求进行处理
3. 服务终止：当需要释放内存或者容器关闭时，容器就会调用Servlet实例的destroy()方法完成资源的释放。在destroy()方法调用之后，容器会释放这个Servlet实例，该实例随后会被Java的垃圾收集器所回收

• 通过下面代码演示生命周期

package com.zbbmeta.servlet;


import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;

/**
 * 默认情况，Servlet会在第一次访问被容器创建，但是如果创建Servlet比较耗时的话，
 * 那么第一个访问的人等待的时间就比较长，用户的体验就比较差，
 * 那么我们能不能把Servlet的创建放到服务器启动的时候来创建，具体如何来配置?
 */
@WebServlet(value = "/hello",loadOnStartup = 1)
public class HelloServlet implements Servlet {

    /**
     * 初始化方法
     *1.调用时机：默认情况下，Servlet被第一次访问时，调用
     *      * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用
     * 2.调用次数: 1次
     * @param config
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig config) throws ServletException {
        System.out.println("Hello Servlet init ...");
    }
    /**
     * 销毁方法
     * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
     * 2.调用次数: 1次
     */
    @Override
    public void destroy() {
        System.out.println("Hello Servlet destroy ...");
    }

    /**
     * 提供服务
     * 1.调用时机:每一次Servlet被访问时，调用
     * 2.调用次数: 多次
     * @param req
     * @param res
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("Hello Servlet ...");
    }
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
    @Override
    public String getServletInfo() {
        return null;
    }
}

在控制台的结果:

注意:如何才能让Servlet中的destroy方法被执行？

小结

这节中需要掌握的内容是:

1. Servlet对象在什么时候被创建的?

默认是第一次访问的时候被创建，可以使用@WebServlet(value = “/hello”,loadOnStartup = 1)的loadOnStartup 修改成在服务器启动的时候创建。

1. Servlet生命周期中涉及到的三个方法，这三个方法是什么?什么时候被调用?调用几次?

涉及到三个方法，分别是 init()、service()、destroy()

init方法在Servlet对象被创建的时候执行，只执行1次

service方法在Servlet被访问的时候调用，每访问1次就调用1次

destroy方法在Servlet对象被销毁的时候调用，只执行1次

4.5 方法介绍

Servlet中总共有5个方法，我们已经介绍过其中的三个，剩下的两个方法作用分别是什么？

我们先来回顾下前面讲的三个方法，分别是:

• 初始化方法，在Servlet被创建时执行，只执行一次

void init(ServletConfig config) 

• 提供服务方法， 每次Servlet被访问，都会调用该方法

void service(ServletRequest req, ServletResponse res)

• 销毁方法，当Servlet被销毁时，调用该方法。在内存释放或服务器关闭时销毁Servlet

void destroy() 

剩下的两个方法是:

• Servlet信息

String getServletInfo() 
//该方法用来返回Servlet的相关信息，没有什么太大的用处，一般我们返回一个空字符串即可
public String getServletInfo() {
    return "";
}

• ServletConfig对象

ServletConfig getServletConfig()

getServletInfo()和getServletConfig()这两个方法使用的不是很多，大家了解下。

4.6 体系结构

通过上面的学习，我们知道要想编写一个Servlet就必须要实现Servlet接口，重写接口中的5个方法，虽然已经能完成要求，但是编写起来还是比较麻烦的，因为我们更的其实只有service方法，那有没有更简单方式来创建Servlet呢?

要想解决上面的问题，我们需要先对Servlet的体系结构进行下了解:

因为我们将来开发B/S架构的web项目，都是针对HTTP协议，所以我们自定义Servlet,会通过继承HttpServlet

具体的编写格式如下:

package com.zbbmeta.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/httptest")
public class HttpTestServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("httptest doPost ...");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("httptest doGet ...");
    }
}

• 要想发送一个GET请求，请求该Servlet，只需要通过浏览器发送http://localhost:8080/tomcat_one_war_exploded/httptest,就能看到doGet方法被执行了
• 要想发送一个POST请求，请求该Servlet，单单通过浏览器是无法实现的，这个时候就需要编写一个form表单来发送请求，在webapp下创建一个a.html页面，内容如下:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>a</title>
</head>
<body>
  <h1>Hello A Html</h1>
  <form action="httptest" method="post">
      <input name="username"/><input type="submit"/>
  </form>
</body>
</html>

启动测试，即可看到doPost方法被执行了。

Servlet的简化编写就介绍完了，接着需要思考两个问题:

1. HttpServlet中为什么要根据请求方式的不同，调用不同的方法?
2. 如何调用?

针对问题一，我们需要回顾之前的知识点前端发送GET和POST请求的时候，参数的位置不一致，GET请求参数在请求行中，POST请求参数在请求体中，为了能处理不同的请求方式，我们得在service方法中进行判断，然后写不同的业务处理，这样能实现，但是每个Servlet类中都将有相似的代码，针对这个问题，有什么可以优化的策略么?

package com.zbbmeta.servlet;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
@WebServlet("/demo1")
public class Demo1Servlet implements Servlet {
    @Override
    public void init(ServletConfig config) throws ServletException {
        
    }
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        //如何调用?
        //请求方式，根据不同的请求方式进行不同的业务处理
        HttpServletRequest request = (HttpServletRequest)req;
        //1. 请求方式
        String method = request.getMethod();
        //2. 判断
        if("GET".equals(method)){
            // get方式的处理逻辑
        }else if("POST".equals(method)){
            // post方式的处理逻辑
        }
    }
    @Override
    public String getServletInfo() {
        return null;
    }
    @Override
    public void destroy() {

    }
}

要解决上述问题，我们可以对Servlet接口进行继承封装，来简化代码开发。

package com.zbbmeta.servlet;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

public class MetaHttpServlet implements Servlet {
    @Override
    public void init(ServletConfig config) throws ServletException {

    }

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

    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest)req;
        //1. 请求方式
        String method = request.getMethod();
        //2. 判断
        if("GET".equals(method)){
            // get方式的处理逻辑
            doGet(req,res);
        }else if("POST".equals(method)){
            // post方式的处理逻辑
            doPost(req,res);
        }
    }
    protected void doPost(ServletRequest req, ServletResponse res) {
    }

    protected void doGet(ServletRequest req, ServletResponse res) {
    }

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

    @Override
    public void destroy() {

    }
}

有了MetaHttpServlet这个类，以后我们再编写Servlet类的时候，只需要继承MetaHttpServlet，重写父类中的doGet和doPost方法，就可以用来处理GET和POST请求的业务逻辑。接下来，可以创建Demo2Servlet代码

package com.zbbmeta.servlet;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebServlet("/demo2")
public class Demo2Servlet extends MetaHttpServlet {
    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {
        System.out.println("demo2 doGet extends MetaHttpServlet");
    }

    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
        System.out.println("demo2 doPost extends MetaHttpServlet");
    }
}

将来页面发送的是GET请求，则会进入到doGet方法中进行执行，如果是POST请求，则进入到doPost方法。这样代码在编写的时候就相对来说更加简单快捷。

类似MetaHttpServlet这样的类Servlet中已经为我们提供好了，就是HttpServlet,翻开源码，大家可以搜索service()方法，你会发现HttpServlet做的事更多，不仅可以处理GET和POST还可以处理其他五种请求方式。

    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                if (ifModifiedSince < lastModified) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);
            
        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);
            
        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);
            
        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);
            
        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);
            
        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);
            
            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

小结

1. HttpServlet的使用步骤

继承HttpServlet

重写doGet和doPost方法

1. HttpServlet原理

请求方式，并根据不同的请求方式，调用不同的doXxx方法

4.7 XML配置

前面对应Servlet的配置，我们都使用的是@WebServlet,这个是Servlet从3.0版本后开始支持注解配置，3.0版本前只支持XML配置文件的配置方法。

对于XML的配置步骤有两步:

• 编写Servlet类

package com.zbbmeta.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

//@WebServlet("/demo3")
public class Demo3Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("demo3 doGet ...");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("demo3 doPost ...");
    }
}

• 在web.xml中配置该Servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 
    Servlet 全类名
-->
    <servlet>
        <!-- servlet的名称，名字任意-->
        <servlet-name>demo3</servlet-name>
        <!--servlet的类全名-->
        <servlet-class>com.zbbmeta.servlet.Demo3Servlet</servlet-class>
    </servlet>
    <!-- 
        Servlet 访问路径
    -->
    <servlet-mapping>
        <!-- servlet的名称，要和上面的名称一致-->
        <servlet-name>demo3</servlet-name>
        <!-- servlet的访问路径-->
        <url-pattern>/demo3</url-pattern>
    </servlet-mapping>
</web-app>

访问流程如下图:

springboot葵花宝典 搜索观看更多内容

原创不易，转载请注明出处，感谢支持！如果本文对您有用，欢迎转发分享！