day09-HTTP&Tomcat&Servlet

Cx330_zhahui

于 2024-06-30 11:41:09 发布

阅读量524

点赞数 3

分类专栏： mysql&javaweb&Mybatis 文章标签： http tomcat servlet

本文链接：https://blog.csdn.net/qq_74289024/article/details/140078024

版权

mysql&javaweb&Mybatis 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

HTTP&Tomcat&Servlet

今日目标：

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

1，Web概述

1.1 Web和JavaWeb的概念

网络：由若干节点和连接这些节点的链路构成,表示诸多对象及其相互联系。
例如：我们可以用电脑、手机上网搜索。搜索内容在其他电脑上。
万维网：WWW：World Wide Web
定义了网络连接规则，例如：前面学的HTML，CSS和JS
网站：由域名、服务器、源文件和数据库四部分组成。
解释：有页面、有数据、有功能。例如：OA系统、APP、微信等

Web是全球广域网，也称为万维网(www)，能够通过浏览器访问的网站。
在我们日常的生活中，经常会使用浏览器去访问百度、京东、山东高合官网等这些网站，这些网站统称为Web网站。

我们知道了什么是Web，那么JavaWeb又是什么呢？顾名思义JavaWeb就是用Java技术来解决相关web互联网领域的技术栈。
等学习完JavaWeb之后，同学们就可以使用Java语言开发我们上述所说的网站。而国内很多大型网站公司也是首选Java语言来解决web互联网相关的问题。那都有哪些公司的系统是使用Java语言的呢?
在这里插入图片描述

使用Java语言开发互联网系统是有很多技术栈需要大家了解，具体都有哪些呢?

1.2 JavaWeb技术栈

了解JavaWeb技术栈之前，有一个很重要的概念要介绍。

1.2.1 B/S架构

什么是B/S架构?
B/S 架构：Browser/Server，浏览器/服务器架构模式，它的特点是，客户端只需要浏览器，应用程序的逻辑和数据都存储在服务器端。浏览器只需要请求服务器，获取Web资源，服务器把Web资源发送给浏览器即可。大家可以通过下面这张图来回想下我们平常的上网过程:
在这里插入图片描述

打开浏览器访问百度首页，输入要搜索的内容，点击回车或百度一下，就可以获取和搜索相关的内容
思考下搜索的内容并不在我们自己的点上，那么这些内容从何而来？答案很明显是从百度服务器返回给我们的
日常百度的小细节，逢年过节百度的logo会更换不同的图片，服务端发生变化，客户端不需做任务事情就能获取最新内容
所以说B/S架构的好处:易于维护升级：服务器端升级后，客户端无需任何部署就可以使用到新的版本。
了解了什么是B/S架构后，作为后台开发工程师的我们将来主要关注的是服务端的开发和维护工作。在服务端将来会放很多资源,都有哪些资源呢?

1.2.2 静态资源

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

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

1.2.3 动态资源

动态资源主要包含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://ip:80/demo/index.html

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

扩展：

HTTPS 协议是由 HTTP 加上 TLS/SSL 协议构建的可进行加密传输、身份认证的网络协议，主要通过数字证书、加密算法、非对称密钥等技术完成互联网数据传输加密，实现互联网传输安全保护。设计目标主要有三个。

（1）数据保密性：保证数据内容在传输的过程中不会被第三方查看。就像快递员传递包裹一样，都进行了封装，别人无法获知里面装了什么。

（2）数据完整性：及时发现被第三方篡改的传输内容。就像快递员虽然不知道包裹里装了什么东西，但他有可能中途掉包，数据完整性就是指如果被掉包，我们能轻松发现并拒收。

（3）身份校验安全性：保证数据到达用户期望的目的地。就像我们邮寄包裹时，虽然是一个封装好的未掉包的包裹，但必须确定这个包裹不会送错地方，通过身份校验来确保送对了地方。

1.2.6 Web服务器

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

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

在这里插入图片描述

扩展：

C/S结构

它指的是客户端——服务器的方式。其中C代表着Client，S代表着服务器。C/S结构的系统设计图如下：

2, HTTP

问题导入：

在我们上网冲浪过程中，是基于什么样的协议进行数据传输的？

在这里插入图片描述

2.1 简介

HTTP的全称是：Hyper Text Transfer Protocol，意为超文本传输协议。它指的是服务器和客户端之间交互必须遵循的一问一答的规则。形容这个规则：问答机制、握手机制。

它规范了请求和响应内容的类型和格式。

HTTP协议是由W3C组织管理和维护的。

HTTP 协议特点：

1.基于TCP协议：面向连接，

2.基于请求-响应模型的：一次请求对应一次响应

3.HTTP协议是无状态的协议：对于事务处理没有记忆能力。每次请求-响应都是独立的。

缺点：

多次请求间不能共享数据。（Java中使用会话技术（Cookie、Session）来解决这个问题）

优点：速度快安全

TCP数据安全原因

三次握手

在这里插入图片描述

四次挥手

在这里插入图片描述

2.1.1 HTTP协议版本

目前HTTP协议主要是1.0版本和1.1版本。这两个版本的区别主要是两个方面。

第一：HTTP1.1版本比1.0版本多了一些消息头。

第二：HTTP1.1版本和1.0版本的执行过程不一样。

执行过程如下：

HTTP1.0	HTTP1.1
创建连接（TCP/IP）	创建连接（TCP/IP）
发送请求	发送请求1
得到响应	得到响应1
关闭连接	发送请求2
创建连接（TCP/IP）	得到响应2
发送请求	…
得到响应	…
关闭连接	连接超时或手动关闭连接

2.1.2 HTTP协议相关说明

HTTP协议概念是客户浏览器和服务器一种一问一答的规则，那么必须要有问有答，而且要先问后答。
但是我们使用<script>,<link>和<img>标签，没有手动发起请求，但是仍然能从服务器端拿到数据，

原因就是：在浏览器遇到<script>,<link>,<img>标签时会自动发出请求。

2.2 HTTP协议组成

由HTTP协议的概念可知，它分为问和答两部分。其中问指的就是请求部分，而答指的就是响应部分。

2.2.1请求部分

请求数据分为3部分：

请求行：请求数据的第一行。其中GET表示请求方式，/表示请求资源路径，HTTP/1.1表示协议版本

请求头：第二行开始，格式为key：value形式。

请求体： POST请求的最后一部分，存放请求参数（载荷中的表单数据）

常见的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等。

引入资料中的demo-form 从idea中打开

在这里插入图片描述

post和get请求的对比

第一：GET请求请求参数在请求行中（地址中），没有请求体。POST请求请求参数在请求体中

第二：表单的输入域有name属性的才会被提交。不分get和post的请求方式。

第三：表单的enctype属性取值决定了请求正文的体现形式。概述的含义是：请求正文的MIME编码类型。

第四：GET请求请求参数大小有限制，POST没有

2.2.2 响应部分

响应数据分为3部分：

响应行：响应数据的第一行。其中HTTP/1.1表示协议版本，200表示响应状态码，OK表示状态码描述

响应头：第二行开始，格式为key：value形式

响应体：最后一部分。存放响应数据

常见的HTTP 响应头：

Content-Type：表示该响应内容的类型，例如text/html，image/jpeg；

Content-Length：表示该响应内容的长度（字节数）；

Content-Encoding：表示该响应压缩算法，例如gzip；

Cache-Control：指示客户端应如何缓存，例如max-age=300表示可以最多缓存300秒

常用状态码介绍：

状态码	说明
200	一切都OK>
302/307	请求重定向(客户端行为，两次请求，地址栏发生改变)
304	请求资源未发生变化，使用缓存
404	请求资源未找到
500	服务器错误

在这里插入图片描述

2.2.3 消息头的共性分析

消息头名称首字母大写，多个单词每个单词的首字母都大写。
多个单词用-分隔
名称和值之间用冒号加空格分隔
多个值之间用逗号加空格分隔
两个头之间用回车分隔

2.3 请求部分详解

2.3.1 请求行详解

请求行：GET /myapp/2.html HTTP/1.1

内容	说明
GET	请求的方式。（还有POST）
/myapp/2.html	请求的资源。
HTTP/1.1	使用的协议，及协议的版本。

2.3.2 请求消息头详解

内容	说明
Accept	告知服务器，客户浏览器所支持的MIME类型。
Accept-Encoding	告知服务器，客户浏览器所支持的压缩编码格式。最常用的就是gzip压缩。
Accept-Language	告知服务器，客户浏览器所支持的语言。一般都是zh_CN或en_US等。
Referer	告知服务器，当前请求的来源。只有当前请求有来源的时候，才有这个消息头。从地址栏输入的没有来源。作用：1 投放广告 2 防盗链
Content-Type	告知服务器，请求正文的MIME类型。
Content-Length	告知服务器，请求正文的长度。
User-Agent	浏览器相关信息
Connection: Keep-Alive	连接的状态：保持连接
If-Modified-Since	告知服务器，客户浏览器缓存文件的最后修改时间。
Cookie（）	会话管理相关，非常的重要。

2.3.3 请求正文详解

第一：只有post请求方式，才有请求的正文。get方式的正文是在地址栏中的。
第二：表单的输入域有name属性的才会被提交。不分get和post的请求方式。
第三：表单的enctype属性取值决定了请求正文的体现形式。概述的含义是：请求正文的MIME编码类型。

enctype取值	请求正文体现形式	示例
application/x-www-form-urlencoded	key=value&key=value	username=test&password=1234
multipart/form-data	此时变成了多部分表单数据。多部分是靠分隔符分隔的。	-----------------------------7df23a16c0210 Content-Disposition: form-data; name=“username” test -----------------------------7df23a16c0210 Content-Disposition: form-data; name=“password” 1234 -----------------------------7df23a16c0210 Content-Disposition: form-data; name=“headfile”; filename=“C:\Users\zhy\Desktop\请求部分.jpg” Content-Type: image/pjpeg -----------------------------7df23a16c0210

2.4 响应部分详解

2.4.1 响应行详解

响应行：HTTP/1.1 200 OK

内容	说明
HTTP/1.1	使用协议的版本。
200	响应状态码
OK	状态码描述

常用状态码介绍：

状态码	说明
200	一切都OK>
302/307	请求重定向(客户端行为，两次请求，地址栏发生改变)
304	请求资源未发生变化，使用缓存
404	请求资源未找到
500	服务器错误

2.4.2 响应消息头详解

消息头	说明
Location	请求重定向的地址，常与302,307配合使用。
Server	服务器相关信息。
Content-Type	告知客户浏览器，响应正文的MIME类型。
Content-Length	告知客户浏览器，响应正文的长度。
Content-Encoding	告知客户浏览器，响应正文使用的压缩编码格式。常用的gzip压缩。
Content-Language	告知客户浏览器，响应正文的语言。zh_CN或en_US等等。
Content-Disposition	告知客户浏览器，以下载的方式打开响应正文。
Refresh	定时刷新
Last-Modified	服务器资源的最后修改时间。
Set-Cookie（*******）	会话管理相关，非常的重要
Expires:-1	服务器资源到客户浏览器后的缓存时间
Cache-Control: no-cache	不要缓存，//针对http协议1.1版本
Pragma:no-cache	不要缓存，//针对http协议1.0版本

3, Tomcat

在讲web服务器之前我们先来了解一下什么是服务器？

服务器分类：

硬件服务器：

是计算机的一种，它比普通计算机运行更快、负载更高、价格更贵。服务器在网络中为其它客户机(如 PC 机、智能设备等)提供计算或者应用服务。服务器具有高速的 CPU 运算能力、长时间的可靠运行、强大的 I/O 外部数据吞吐能力以及更好的扩展性。

软件服务器：

web 服务器，或者应用服务器。跑我们写的项目的一个软件。

常见的应用服务器，请看下表：

服务器名称	说明
weblogic	实现了javaEE规范，重量级服务器，又称为javaEE容器
websphereAS	实现了javaEE规范，重量级服务器。
JBOSSAS	实现了JavaEE规范，重量级服务器。免费的。
Tomcat	实现了jsp/servlet规范，是一个轻量级服务器，开源免费。

引入

我们在页面中发送请求数据怎么发送给后端？在这个中间流程中经过了web服务器。

3.1 简介

为什么要有web服务器？

我们的后端代码无法直接接收请求和提供响应。

web服务器对 HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作。

3.1.1 什么是Web服务器

Web服务器是一个应用程序（软件），对 HTTP协议的操作进行封装，使得程序员不必直接对协议进行操作，让Web开发更加便捷。主要功能是“提供网上信息浏览服务”

3.2 基本使用

问题导入：

服务的下载、安装、启动、关闭。常见问题。

3.2.1 Tomcat下载与安装

Tomcat官网下载地址

为什么用tomcat:

免费、开源、技术先进、性能稳定。

在这里插入图片描述

3.2.2 Tomcat各版本所需支持

**重要：**tomcat版本和java JDK版本是有关系的。选择匹配的版本！！！

在这里插入图片描述

3.2.3 Tomcat目录结构详解（掌握）

在这里插入图片描述

3.2.4 Tomcat启动和停止及问题分析解决

1）启动和停止

Tomcat服务器的启动文件在二进制文件目录中：在这里插入图片描述
，这两个文件就是Tomcat的启动文件。

Tomcat服务器的停止文件也在二进制文件目录中：在这里插入图片描述
，这两个文件就是Tomcat的停止文件。

其中.bat文件是针对windows系统的运行程序，.sh文件是针对linux系统的运行程序。

2）启动问题

第一个问题：启动一闪而过

原因：没有配置环境变量。

解决办法：配置上JAVA_HOME环境变量

第二个：Address already in use : JVM_Bind

在这里插入图片描述

原因：端口被占用

解决办法：找到占用该端口的应用

进程不重要：使用cmd命令：netstat -a -o 查看pid 在任务管理器中结束占用端口的进程。

进程很重要：修改自己的端口号。修改的是Tomcat目录下\conf\server.xml中的配置。

在这里插入图片描述

第三个：启动产生很多异常，但能正常启动

原因：Tomcat中部署着很多项目，每次启动这些项目都会启动。而这些项目中有启动报异常的。

解决办法：

能找到报异常的项目，就把它从发布目录中移除。

不能确定报异常的项目，就重新解压一个新的Tomcat。

第四个：其它问题

例如：启动产生异常，但是不能正常启动。此时就需要解压一个新的Tomcat启动，来确定是系统问题，还是Tomcat的问题。

所以，此时就需要具体问题，具体分析，然后再对症解决。

3.2.5 配置

修改端口

Tomcat默认的端口是8080，要想修改Tomcat启动的端口号，需要修改 conf/server.xml

在这里插入图片描述

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

启动时可能出现的错误

Tomcat的端口号取值范围是0-65535之间任意未被占用的端口，如果设置的端口号被占用，启动的时候就会包如下的错误
Tomcat启动的时候，启动窗口一闪而过: 需要检查JAVA_HOME环境变量是否正确配置

在这里插入图片描述

3.2.6 部署

Tomcat部署项目：将项目放置到webapps目录下，即部署完成。
- 将 资料/2. Tomcat/hello 目录拷贝到Tomcat的webapps目录下
- 通过浏览器访问http://localhost/hello/a.html，能看到下面的内容就说明项目已经部署成功。
  
  但是呢随着项目的增大，项目中的资源也会越来越多，项目在拷贝的过程中也会越来越费时间，该如何解决呢?
一般JavaWeb项目会被打包称war包，然后将war包放到Webapps目录下，Tomcat会自动解压缩war文件
- 将 资料/2. Tomcat/haha.war目录拷贝到Tomcat的webapps目录下
- Tomcat检测到war包后会自动完成解压缩，在webapps目录下就会多一个haha目录
- 通过浏览器访问http://localhost/haha/a.html，能看到下面的内容就说明项目已经部署成功。

至此，Tomcat的部署就已经完成了，至于如何获得项目对应的war包，后期我们会借助于IDEA工具来生成。

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项目

介绍完Maven Web的项目结构后，接下来使用Maven来创建Web项目，创建方式有两种:使用骨架和不使用骨架

使用骨架

具体的步骤包含:

1.创建Maven项目

2.选择使用Web项目骨架

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

4.确认Maven相关的配置信息后，完成项目创建

5.删除pom.xml中多余内容

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

创建Maven项目
选择使用Web项目骨架
输入Maven项目坐标创建项目
确认Maven相关的配置信息后，完成项目创建
删除pom.xml中多余内容，只留下面的这些内容，注意打包方式 jar和war的区别
补齐Maven Web项目缺失的目录结构，默认没有java和resources目录，需要手动完成创建补齐，最终的目录结果如下

不使用骨架

具体的步骤包含:

1.创建Maven项目

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

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

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

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

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

创建Maven项目
选择不使用Web项目骨架
输入Maven项目坐标创建项目
在pom.xml设置打包方式为war,默认是不写代表打包方式为jar
补齐Maven Web项目缺失webapp的目录结构
补齐Maven Web项目缺失WEB-INF/web.xml的目录结构
补充完后，最终的项目结构如下:

上述两种方式，创建的web项目，都不是很全，需要手动补充内容，至于最终采用哪种方式来创建Maven Web项目，都是可以的，根据各自的喜好来选择使用即可。

小结

1.掌握Maven Web项目的目录结构

2.掌握使用骨架的方式创建Maven Web项目

在这里插入图片描述

3.掌握不使用骨架的方式创建Maven Web项目

3.4 IDEA使用Tomcat

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

在IDEA中集成使用Tomcat有两种方式，分别是集成本地Tomcat和Tomcat Maven插件

默认会访问index.html

3.4.1 集成本地Tomcat（了解即可）

工作中=几乎不用

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

打开添加本地Tomcat的面板
指定本地Tomcat的具体路径

在这里插入图片描述

修改Tomcat的名称，此步骤可以不改，只是让名字看起来更有意义，HTTP port中的端口也可以进行修改，比如把8080改成80
将开发项目部署项目到Tomcat中

扩展内容： xxx.war和 xxx.war exploded这两种部署项目模式的区别?
- war模式是将WEB工程打成war包，把war包发布到Tomcat服务器上
- war exploded模式是将WEB工程以当前文件夹的位置关系发布到Tomcat服务器上
- war模式部署成功后，Tomcat的webapps目录下会有部署的项目内容
- war exploded模式部署成功后，Tomcat的webapps目录下没有，而使用的是项目的target目录下的内容进行部署
- 建议大家都选war模式进行部署，更符合项目部署的实际情况
部署成功后，就可以启动项目，为了能更好的看到启动的效果，可以在webapp目录下添加a.html页面
启动成功后，可以通过浏览器进行访问测试
最终的注意事项

至此，IDEA中集成本地Tomcat进行项目部署的内容我们就介绍完了，整体步骤如下，大家需要按照流程进行部署操作练习。

在这里插入图片描述

3.4.2 Tomcat Maven插件(重点掌握)

在IDEA中使用本地Tomcat进行项目部署，相对来说步骤比较繁琐，所以我们需要一种更简便的方式来替换它，那就是直接使用Maven中的Tomcat插件来部署项目，具体的实现步骤，只需要两步，分别是:

在pom.xml中添加Tomcat插件

<build>
    <plugins>
    	<!--Tomcat插件 -->
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
                    <port>8081</port>
                    <path>/hello</path>
            </configuration>
        </plugin>
    </plugins>
</build>

使用Maven Helper插件快速启动项目，选中项目，右键–>Run Maven --> tomcat7:run

在这里插入图片描述

注意:

如果选中项目并右键点击后，看不到Run Maven和Debug Maven，这个时候就需要在IDEA中下载Maven Helper插件，具体的操作方式为: File --> Settings --> Plugins --> Maven Helper —> Install,安装完后按照提示重启IDEA，就可以看到了。

在这里插入图片描述

Maven Tomcat插件目前只有Tomcat7版本，没有更高的版本可以使用
使用Maven Tomcat插件，要想修改Tomcat的端口和访问路径，可以直接修改pom.xml

<build>
    <plugins>
    	<!--Tomcat插件 -->
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
            	<port>80</port><!--访问端口号 -->
                <!--项目访问路径
					未配置访问路径: http://localhost:80/tomcat-demo2/a.html
					配置/后访问路径: http://localhost:80/a.html
					如果配置成 /hello,访问路径会变成什么?
						答案: http://localhost:80/hello/a.html
				-->
                <path>/</path>
            </configuration>
        </plugin>
    </plugins>
</build>

小结

通过这一节的学习，大家要掌握在IDEA中使用Tomcat的两种方式，集成本地Tomcat和使用Maven的Tomcat插件。后者更简单，推荐大家使用，但是如果对于Tomcat的版本有比较高的要求，要在Tomcat7以上，这个时候就只能用前者了。

在这里插入图片描述

4， Servlet

4.1 简介

在这里插入图片描述

Servlet是JavaWeb最为核心的内容，它是Java提供的一门动态web资源开发技术。
使用Servlet就可以实现，根据不同的登录用户在页面上动态显示不同内容。
Servlet是JavaEE规范之一，其实就是一个接口，将来我们需要定义Servlet类实现Servlet接口，并由web服务器运行Servlet

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

模板-模式

4.2 快速入门

需求分析: 编写一个Servlet类，并使用IDEA中Tomcat插件进行部署，最终通过浏览器访问所编写的Servlet程序。

具体的实现步骤为:

创建Web项目web-demo，导入Servlet依赖坐标

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <!--
      此处为什么需要添加该标签?
      provided指的是在编译和测试过程中有效,最后生成的war包时不会加入
       因为Tomcat的lib目录中已经有servlet-api这个jar包，如果在生成war包的时候生效就会和Tomcat中的jar包冲突，导致报错
    -->
    <scope>provided</scope>
</dependency>
<build>
    <plugins>
      <!--Tomcat插件 -->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
      </plugin>
    </plugins>
  </build>

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

package com.itgaohe.web;

import javax.servlet.*;
import java.io.IOException;
@WebServlet("/demo1")
public class ServletDemo1 implements Servlet {

    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("servlet hello world~");
    }
    public void init(ServletConfig servletConfig) throws ServletException {}
    public ServletConfig getServletConfig() {return null;}
    public String getServletInfo() {return null;}
    public void destroy() {}
}

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

@WebServlet("/demo1")

访问:启动Tomcat,浏览器中输入URL地址访问该Servlet

http://localhost:8080/web-demo/demo1

器访问后，在控制台会打印servlet hello world~ 说明servlet程序已经成功运行。

至此，Servlet的入门案例就已经完成，大家可以按照上面的步骤进行练习了。

4.3 执行流程

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

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

在这里插入图片描述

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

小结

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

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

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

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

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

4.4 生命周期

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

接下来咱们再来思考一个问题:Tomcat什么时候创建的Servlet对象?

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

生命周期: 对象的生命周期指一个对象从被创建到被销毁的整个过程。
Servlet运行在Servlet容器(web服务器)中，其生命周期由容器来管理，分为4个阶段：
1. 加载和实例化：默认情况下，当Servlet第一次被访问时，由容器创建Servlet对象
```
默认情况，Servlet会在第一次访问被容器创建，但是如果创建Servlet比较耗时的话，那么第一个访问的人等待的时间就比较长，用户的体验就比较差，那么我们能不能把Servlet的创建放到服务器启动的时候来创建，具体如何来配置?

@WebServlet(urlPatterns = "/demo1",loadOnStartup = 1/2)
loadOnstartup的取值有两类情况
	（1）负整数:第一次访问时创建Servlet对象(默认值 访问的时候才初始化)
	（2）0或正整数:服务器启动时创建Servlet对象，数字越小优先级越高(启动的时候进行初始化）
```
1. 初始化：在Servlet实例化之后，容器将调用Servlet的init()方法初始化这个对象，完成一些如加载配置文件、创建连接等初始化的工作。该方法只调用一次
2. 请求处理：每次请求Servlet时，Servlet容器都会调用Servlet的==service()==方法对请求进行处理
3. 服务终止：当需要释放内存或者容器关闭时，容器就会调用Servlet实例的==destroy()==方法完成资源的释放。在destroy()方法调用之后，容器会释放这个Servlet实例，该实例随后会被Java的垃圾收集器所回收

通过案例演示下上述的生命周期

package com.itgaohe.web;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;
/**
* Servlet生命周期方法
*/
@WebServlet(urlPatterns = "/demo2",loadOnStartup = 1)
public class ServletDemo2 implements Servlet {

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

    /**
     * 提供服务
     * 1.调用时机:每一次Servlet被访问时，调用
     * 2.调用次数: 多次
     * @param req
     * @param res
     * @throws ServletException
     * @throws IOException
     */
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("servlet hello world~");
    }

    /**
     * 销毁方法
     * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
     * 2.调用次数: 1次
     */
    public void destroy() {
        System.out.println("destroy...");
    }
    public ServletConfig getServletConfig() {
        return null;
    }

    public String getServletInfo() {
        return null;
    }


}

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

在这里插入图片描述

在Terminal命令行中，先使用mvn tomcat7:run启动，然后再使用ctrl+c关闭tomcat

小结

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

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

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

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()

ServletConfig对象，在init方法的参数中有，而Tomcat Web服务器在创建Servlet对象的时候会调用init方法，必定会传入一个ServletConfig对象，我们只需要将服务器传过来的ServletConfig进行返回即可。具体如何操作?

package com.itgaohe.web;

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

/**
 * Servlet方法介绍
 */
@WebServlet(urlPatterns = "/demo3",loadOnStartup = 1)
public class ServletDemo3 implements Servlet {

    private ServletConfig servletConfig;
    /**
     *  初始化方法
     *  1.调用时机：默认情况下，Servlet被第一次访问时，调用
     *      * loadOnStartup: 默认为-1，修改为0或者正整数，则会在服务器启动的时候，调用
     *  2.调用次数: 1次
     * @param config
     * @throws ServletException
     */
    public void init(ServletConfig config) throws ServletException {
        this.servletConfig = config;
         System.out.println(config);
        System.out.println("init...");
    }
    public ServletConfig getServletConfig() {
        return servletConfig;
    }
    
    /**
     * 提供服务
     * 1.调用时机:每一次Servlet被访问时，调用
     * 2.调用次数: 多次
     * @param req
     * @param res
     * @throws ServletException
     * @throws IOException
     */
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        System.out.println("servlet hello world~");
    }

    /**
     * 销毁方法
     * 1.调用时机：内存释放或者服务器关闭的时候，Servlet对象会被销毁，调用
     * 2.调用次数: 1次
     */
    public void destroy() {
        System.out.println("destroy...");
    }
    
    public String getServletInfo() {
        return "";
    }
}

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

4.5.2 Servlet的线程安全问题

Servlet 是在单例多线程环境下运行的。其运行可能会出现线程安全问题

一、线程安全问题
1、什么是线程安全问题
同时满足以下两个条件，则会出现线程安全问题：

（1）存在多线程并发访问
（2）存在可修改的共享数据
当多个线程同时修改同一个共享数据时，后修改的数据会将先修改的数据覆盖，对数据先进行修改的用户读取到的不是自己修改后的数据，这就是线程安全问题。

解决办法：把成员变量变为局部变量或者加锁

private  String money;
@Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        String user = req.getParameter("user");
        this.money = req.getParameter("money");
        System.out.println("demo1");
        if(user.equals("zs")){
            System.out.println("我要针对你，给我等5s来取钱");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        res.getWriter().write(user+this.money);
    }

分别访问两个页面传递参数

http://localhost:8080/servlet-demo/d2?user=zhangsan&money=2000
http://localhost:8080/servlet-demo/d2?user=zs&money=200

先开启满足user=zs的进入等待再开启不满足user=zs的，此时我们发现最后运行的结果 money均于2000 而user=zs真正的money值为200 发生线程安全问题。

解决：把成员变量变为局部变量

//    private  String money;
 @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        String user = req.getParameter("user");
        String money= req.getParameter("money");
        System.out.println("demo1");
        if(user.equals("zs")){
            System.out.println("我要针对你，给我等5s来取钱");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        res.getWriter().write(user+money);
    }

4.6 体系结构（了解）

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

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

在这里插入图片描述

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

具体的编写格式如下:

@WebServlet("/demo4")
public class ServletDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //TODO GET 请求方式处理逻辑
        System.out.println("get...");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //TODO Post 请求方式处理逻辑
        System.out.println("post...");
    }
}

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

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/web-demo/demo4" method="post">
        <input name="username"/><input type="submit"/>
    </form>
</body>
</html>

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

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

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

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

package com.itgaohe.web;

import javax.servlet.*;
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("/demo5")
public class ServletDemo5 implements Servlet {

    public void init(ServletConfig config) throws ServletException {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    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方式的处理逻辑
        }
    }

    public String getServletInfo() {
        return null;
    }

    public void destroy() {

    }
}

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

package com.itgaohe.web;

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

public class MyHttpServlet implements Servlet {
    public void init(ServletConfig config) throws ServletException {

    }

    public ServletConfig getServletConfig() {
        return null;
    }

    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) {
    }

    public String getServletInfo() {
        return null;
    }

    public void destroy() {

    }
}

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

@WebServlet("/demo5")
public class ServletDemo5 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {
        System.out.println("get...");
    }

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

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

类似MyHttpServlet这样的类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);
        }
    }

4.7 urlPattern配置

Servlet类编写好后，要想被访问到，就需要配置其访问路径（urlPattern）

一个Servlet,可以配置多个urlPattern

在这里插入图片描述

package com.itgaohe.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
* urlPattern: 一个Servlet可以配置多个访问路径
*/
@WebServlet(urlPatterns = {"/demo7","/demo8"})
public class ServletDemo7 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {
        
        System.out.println("demo7 get...");
    }
    @Override
    protected void doPost(ServletRequest req, ServletResponse res) {
    }
}

在浏览器上输入http://localhost:8080/web-demo/demo7,http://localhost:8080/web-demo/demo8这两个地址都能访问到ServletDemo7的doGet方法。

urlPattern配置规则

精确匹配

在这里插入图片描述

/**
 * UrlPattern:
 * * 精确匹配
 */
@WebServlet(urlPatterns = "/user/select")
public class ServletDemo8 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

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

访问路径http://localhost:8080/web-demo/user/select

目录匹配

在这里插入图片描述

package com.itgaohe.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
 * UrlPattern:
 * * 目录匹配: /user/*
 */
@WebServlet(urlPatterns = "/user/*")
public class ServletDemo9 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

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

访问路径http://localhost:8080/web-demo/user/任意

思考:

访问路径http://localhost:8080/web-demo/user是否能访问到demo9的doGet方法?
访问路径http://localhost:8080/web-demo/user/a/b是否能访问到demo9的doGet方法?
访问路径http://localhost:8080/web-demo/user/select是否能访问到demo9还是demo8的doGet方法?

答案是: 能、能、demo8，进而我们可以得到的结论是/user/*中的/*代表的是零或多个层级访问目录同时精确匹配优先级要高于目录匹配。

扩展名匹配

在这里插入图片描述

package com.itgaohe.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
 * UrlPattern:
 * * 扩展名匹配: *.do
 */
@WebServlet(urlPatterns = "*.do")
public class ServletDemo10 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

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

访问路径http://localhost:8080/web-demo/任意.do

注意:

如果路径配置的不是扩展名，那么在路径的前面就必须要加/否则会报错

在这里插入图片描述

如果路径配置的是*.do,那么在*.do的前面不能加/,否则会报错

在这里插入图片描述

任意匹配

在这里插入图片描述

package com.itgaohe.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
 * UrlPattern:
 * * 任意匹配： /
 */
@WebServlet(urlPatterns = "/")
public class ServletDemo11 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

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

访问路径http://localhost:8080/demo-web/任意

package com.itgaohe.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

/**
 * UrlPattern:
 * * 任意匹配： /*
 */
@WebServlet(urlPatterns = "/*")
public class ServletDemo12 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

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

访问路径`http://localhost:8080/demo-web/任意

注意:/和/*的区别?

当我们的项目中的Servlet配置了 “/”,会覆盖掉tomcat中的DefaultServlet,当其他的url-pattern都匹配不上时都会走这个Servlet
当我们的项目中配置了"/*",意味着匹配任意访问路径
DefaultServlet是用来处理静态资源，如果配置了"/"会把默认的覆盖掉，就会引发请求静态资源的时候没有走默认的而是走了自定义的Servlet类，最终导致静态资源不能被访问

小结

urlPattern总共有四种配置方式，分别是精确匹配、目录匹配、扩展名匹配、任意匹配
五种配置的优先级为精确匹配 > 目录匹配> 扩展名匹配 > /* > / ,无需记，以最终运行结果为准。

4.8 XML配置（了解）

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

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

编写Servlet类

package com.itgaohe.web;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

public class ServletDemo13 extends MyHttpServlet {

    @Override
    protected void doGet(ServletRequest req, ServletResponse res) {

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

在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>demo13</servlet-name>
        <!--servlet的类全名-->
        <servlet-class>com.itgaohe.web.ServletDemo13</servlet-class>
    </servlet>

    <!-- 
        Servlet 访问路径
    -->
    <servlet-mapping>
        <!-- servlet的名称，要和上面的名称一致-->
        <servlet-name>demo13</servlet-name>
        <!-- servlet的访问路径-->
        <url-pattern>/demo13</url-pattern>
    </servlet-mapping>
</web-app>

这种配置方式和注解比起来，确认麻烦很多，所以建议大家使用注解来开发。但是大家要认识上面这种配置方式，因为并不是所有的项目都是基于注解开发的。

今日总结：

1、能够说出HTTP是什么

超文本传输协议。它指的是服务器和客户端之间交互必须遵循的一问一答的规则。

缺点：多请求不能共享数据

https

2、能够说出HTTP请求数据和响应数据的组成格式

请求行：永远位于请求的第一行
请求消息头：从第二行开始，到第一个空行结束
请求的正文：从第一个空行后开始，到正文的结束数据

响应行：永远位于响应的第一行
响应消息头：从第二行开始，到第一个空行结束
响应的正文：从第一个空行后开始，到正文的结束数据

3、能够说出get和post请求方式的区别

get 和 post的区别（面试题）

快 get
安全性 post
数据大小 post大
加密 post
url get
上传和下载 post

4、能够说出200,404,500响应状态码的含义

状态码	说明
200	一切都OK>
302/307	请求重定向(客户端行为，两次请求，地址栏发生改变)
304	请求资源未发生变化，使用缓存
404	请求资源未找到
500	服务器错误

5、能够说出Tomcat的作用

硬件服务器：一台可以联网的电脑。

软件服务器：软件。跑javaweb程序的！

7、能够修改Tomcat启动端口号

maven中修改重点掌握！（操作）

8、能够在Tomcat中部署web项目

maven中修改重点掌握！（操作）

9、能够使用IDEA创建Maven Web项目

maven中修改重点掌握！（操作）

10、能够在IDEA中集成Tomcat

maven中修改重点掌握！（操作）

11、能够说出什么是Servlet

接收请求、处理请求、给出响应！

12、能够说出Servlet生命周期方法

初始化默认第一次访问时初始化。 tomcat启动的时候初始化。

tips:初始化: 映射路径和 java资源servlet产生绑定

使用service 访问时

销毁清理内存、destory()时、关闭服务器

13、能够使用继承HttpServlet的方式编写Servlet

操作！

14、能够修改Servlet的urlpatterns配置

操作！

//1.精准匹配-- 最常用
//@WebServlet("/DemoServlet5")
//2.前缀匹配-目录匹配  *通配  --权限，拦截
//@WebServlet("/d/*")
//3.扩展名匹配 - 后缀匹配  -- 框架
//@WebServlet("*.do")
//4. 多路径匹配
@WebServlet({"/demo5","/demo6"})

15、能够使用XML配置Servlet

了解！(忘记)

在这里插入图片描述

作业：

面这种配置方式，因为并不是所有的项目都是基于注解开发的。

Cx330_zhahui

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
day09-HTTP&Tomcat&Servlet

网络：由若干节点和连接这些节点的链路构成,表示诸多对象及其相互联系。例如：我们可以用电脑、手机上网搜索。搜索内容在其他电脑上。万维网WWW定义了网络连接规则，例如：前面学的HTMLCSS和JS网站：由域名、服务器、源文件和数据库四部分组成。解释：有页面、有数据、有功能。例如：OA系统、APP、微信等Web是全球广域网，也称为万维网(www)，能够通过浏览器访问的网站。在我们日常的生活中，经常会使用浏览器去访问百度京东山东高合官网等这些网站，这些网站统称为Web网站。
复制链接

扫一扫