Javaweb复习资料（二）

傷城~ 2022-10-07 00:41 162阅读 0赞

### 文章目录 ###

*  Javaweb部分复习
 *  一、Tomcat
 *   *  1.1 Tomcat介绍
     *   *  1.1.1 关于服务器
         *  1.1.2 Tomcat下载与安装
         *  1.1.3 Tomcat各版本所需支持
         *  1.1.4 Tomcat目录结构详解
     *  1.2 Tomcat基本使用
     *   *  1.2.1 Tomcat启动和停止及问题分析解决
         *   *  1）启动和停止
             *  2）启动时问题
         *  1.2.2 IDEA集成Tomcat服务器
 *  二、servlet基础
 *   *  1.1 Servlet概述
     *  1.2 Servlet入门
     *   *  1.2.1 Servlet编写步骤
         *   *  1.2.1.1 编码步骤
             *  1.2.1.2 测试
         *  1.2.2 Servlet执行过程分析
         *  1.2.3 Servlet类视图
         *  1.2.4 Servlet编写方式
         *   *  1.2.4.1 编写方式说明（※）
             *  1.2.4.2 HttpServlet的使用细节
 *  三、Servlet细节进阶（能懂就懂）
 *   *  1.1 Servlet的生命周期
     *  1.2 Servlet的线程安全
     *   *  解决方法
     *  1.3 Servlet的注意事项
     *   *  1.3.1 映射Servlet的细节
         *   *  第一种：指名道姓的方式
             *  第二种：/开头+通配符的方式
             *  第三种：通配符+固定格式结尾
         *  第四种：多种映射顺序
         *  1.3.2 多路径映射Servlet
         *  1.3.3 启动时创建Servlet
         *   *  方式的选择
         *  1.3.4 默认Servlet
     *  1.4 Servlet关系总图
     *   *  哎，事真多，微笑面对吧
 *  四、响应
 *   *  1.1 响应对象概述
     *   *  1.1.1 关于响应
         *  1.1.2 常用响应对象
     *  1.2 常用方法介绍
     *   *  1.2.1 API 介绍
         *  1.2.2 常用响应状态码
     *  1.3 响应对象的使用示例
     *   *  1.3.1 响应字节流输出中文乱码问题
         *  1.3.3 响应-生成验证码
         *  1.3.4 设置响应消息头 —— 控制缓存
         *  1.3.5 设置响应消息头 —— 定时刷新
         *  1.3.6 请求重定向：注意地址栏发生改变。
         *  1.3.7 响应和消息头组合应用 —— 文件下载
         *  1.3.8 响应对象注意事项
 *  五、请求对象
 *   *  2.1 请求对象概述
     *   *  2.1.1 关于请求
         *  2.1.2 常用请求对象
     *  2.2 常用方法介绍
     *  2.3 请求对象的使用示例
     *   *  2.3.1 请求对象常用方法1-获取各种路径
         *  2.3.2 请求对象常用方法2-获取请求头信息
         *  2.3.3 请求对象常用方法3-获取请求参数（非常重要）
         *  2.3.4 用流的形式读取请求信息
         *  2.3.5 请求正文中中文编码问题
         *  2.3.6 请求转发（与重定向的区别）
         *  2.3.7 请求包含
         *  2.3.8 更细节问题
 *  六、cookie
 *  七、session
 *  八、jsp（※）
 *   *  1 JSP基础
     *   *  1.1 JSP简介
         *  1.2 JSP和HTML以及Servlet的适用场景
         *  1.3 JSP简单入门
         *  1.4 JSP说明
         *   *  1）执行过程分析图
             *  2）JSP的.java文件内容分析（看不懂跳过，反jsp本质就是servlet）
     *  2 JSP应用
     *   *  2.1 JSP语法
         *   *  1）Java代码块
             *  2）JSP表达式
             *  3）JSP声明
             *  4）JSP注释
             *  5）语法的示例
         *  2.2 JSP指令
         *   *  1）page指令
             *  2）include指令
             *  3）taglib指令
         *  2.3 JSP细节
         *   *  1）九大隐式对象
             *  2）PageContext对象
             *  3）四大域对象
             *  4）四大域对象作用范围
         *  2.4 JSP最佳实战效果——MVC模型
 *  九、知识补充：
 *   *  JDK、JRE、JVM和SDK是啥啊都？
     *  Servlet编写三种方式
     *   *  1. 第一种：实现Servlet接口，接口中的方法必须全部实现。
         *  2. 第二种：继承GenericServlet，
         *  3. 第三种：继承HttpServle
     *  request获取请求参数
     *   *  1. 获取请求参数
         *   *  getParameter()方法的示例代码
             *  getParameterValues()方法的示例代码
             *  getParameterNames()方法的示例代码
             *  总结：
         *  2. 封装请求参数到实体类中
         *   *  第一种：最简单直接的封装方式
             *  第二种：使用反射方式封装
             *  第三种：使用反射封装，同时请求参数的值是一个数组
             *  第四种：使用apache的commons-beanutils实现封装

# Javaweb部分复习 #

保姆级复习资料又来啦，开始复习吧！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70]

# 一、Tomcat #

## 1.1 Tomcat介绍 ##

### 1.1.1 关于服务器 ###

服务器的概念非常的广泛，它可以指代一台特殊的计算机（相比普通计算机运行更快、负载更高、价格更贵），也可以指代用于部署网站的应用。我们这里说的服务器，其实是web服务器，或者应用服务器。它本质就是一个软件，一个应用。作用就是发布我们的应用（工程），让用户可以通过浏览器访问我们的应用。

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

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

### 1.1.2 Tomcat下载与安装 ###

[Tomcat官网下载地址][Tomcat]

详细安装与配置可以参考下面的博文：[https://yangyongli.blog.csdn.net/article/details/117822418][https_yangyongli.blog.csdn.net_article_details_117822418]

### 1.1.3 Tomcat各版本所需支持 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 1]

### 1.1.4 Tomcat目录结构详解 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 2]

## 1.2 Tomcat基本使用 ##

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

#### 1）启动和停止 ####

Tomcat服务器的启动文件在二进制文件目录中：![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kuzFuo6W-1623549085998)(assets/1574762703742.png)\]][img-kuzFuo6W-1623549085998_assets_1574762703742.png]  
，这两个文件就是Tomcat的启动文件。

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

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

#### 2）启动时问题 ####

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

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

解决办法：配置上JAVA\_HOME环境变量

**第二个：Address already in use : JVM\_Bind**

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RP9XU6bl-1623549086001)(assets/1574768107180.png)\]][img-RP9XU6bl-1623549086001_assets_1574768107180.png]

原因：端口被占用

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

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

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

![在这里插入图片描述][20210613104818518.png]

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

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

解决办法：

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

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

**第四个：其它问题**

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

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

### 1.2.2 IDEA集成Tomcat服务器 ###

**第一步**

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1R7OJtIz-1623549086003)(assets/IDEA配置Tomcat1.png)\]][img-1R7OJtIz-1623549086003_assets_IDEA_Tomcat1.png]

**第二步**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 3]

**第三步**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 4]

**第四步**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 5]

# 二、servlet基础 #

## 1.1 Servlet概述 ##

Servlet是SUN公司提供的一套规范，名称就叫Servlet规范，它也是JavaEE规范之一。我们可以像学习Java基础一样，通过API来学习Servlet。这里需要注意的是，在我们之前JDK的API中是没有Servlet规范的相关内容，需要使用JavaEE的API。目前在Oracle官网中的最新版本是[JavaEE8][]，该网址中介绍了JavaEE8的一些新特性。当然，我们可以通过访问[官方API][API]，学习和查阅里面的内容。

打开官方API网址，在左上部分找到javax.servlet包，在左下部分找到Servlet，如下图显示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 6]

通过阅读API，我们得到如下信息：

第一：Servlet是一个运行在web服务端的java小程序

第二：它可以用于接收和响应客户端的请求

第三：要想实现Servlet功能，可以实现Servlet接口，继承GenericServlet或者HttpServlet

第四：每次请求都会执行service方法

第五：Servlet还支持配置

具体请看下图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 7]

## 1.2 Servlet入门 ##

### 1.2.1 Servlet编写步骤 ###

#### 1.2.1.1 编码步骤 ####

*  第一步：前期准备-创建JavaWeb工程
 *  第二步：编写一个普通类继承GenericServlet并重写service方法
 *  第三步：在web.xml配置Servlet

#### 1.2.1.2 测试 ####

**在Tomcat中部署项目**，**然后在浏览器访问Servlet**

出现下面这就成功了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 8]

### 1.2.2 Servlet执行过程分析 ###

我们通过浏览器发送请求，请求首先到达Tomcat服务器，由服务器解析请求URL，然后在部署的应用列表中找到我们的应用。接下来，在我们的应用中找应用里的web.xml配置文件，在web.xml中找到FirstServlet的配置，找到后执行service方法，最后由FirstServlet响应客户浏览器。整个过程如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 9]

一句话总结执行过程：

浏览器——>Tomcat服务器——>我们的应用——>应用中的web.xml——>FirstServlet——>响应浏览器

我们可以看到，在编译器里的部分只是后面web.xml到Servlet的部分。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 10]

### 1.2.3 Servlet类视图 ###

在《Tomcat和Http协议》这天课程和刚才的入门案例中，我们都定义了自己的Servlet，实现的方式都是选择继承GenericServlet，在Servlet的API介绍中，它提出了我们除了继承GenericServlet外还可以继承HttpServlet，通过查阅servlet的类视图，我们看到GenericServlet还有一个子类HttpServlet。同时，在service方法中还有参数ServletRequest和ServletResponse，它们的关系如下图所示：

![打][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 11]

### 1.2.4 Servlet编写方式 ###

#### 1.2.4.1 编写方式说明（※） ####

[https://yangyongli.blog.csdn.net/article/details/117871787][https_yangyongli.blog.csdn.net_article_details_117871787]

#### 1.2.4.2 HttpServlet的使用细节 ####

**第一步：在入门案例的工程中创建一个Servlet继承HttpServlet**

注意：不要重写任何方法，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 12]

**第二步：部署项目并测试访问**

当我们在地址栏输入ServletDemo2的访问URL时，出现了访问错误，状态码是405。提示信息是：方法不允许。

**第三步：分析原因**

得出HttpServlet的使用结论：

**我们继承了HttpServlet，需要重写里面的doGet和doPost方法来接收get方式和post方式的请求。**

为了实现代码的可重用性，我们只需要在doGet或者doPost方法中一个里面提供具体功能即可，而另外的那个方法只需要调用提供了功能的方法。

# 三、Servlet细节进阶（能懂就懂） #

## 1.1 Servlet的生命周期 ##

对象的生命周期，就是对象从生到死的过程，即：出生——活着——死亡。用更偏向 于开发的官方说法就是对象创建到销毁的过程。

*  出生（对象的建立）：请求第一次到达Servlet时，对象就创建出来，并且初始化成功。只出生一次，就放到内存中。
 *  活着（对象的应用）：服务器提供服务的整个过程中，该对象一直存在，每次只是执行service方法。
 *  死亡（对象的销毁）：当服务停止时，或者服务器宕机时，对象消亡。

通过分析Servlet的生命周期我们发现，它的实例化和初始化只会在请求第一次到达Servlet时执行，而销毁只会在Tomcat服务器停止时执行。

由此我们得出一个结论，Servlet对象只会创建一次，销毁一次。所以，Servlet对象只有一个实例。如果一个对象实例在应用中是唯一的存在，那么我们就说它是单实例的，即运用了单例模式

## 1.2 Servlet的线程安全 ##

由于Servlet运用了单例模式，即整个应用中只有一个实例对象，所以我们需要分析这个唯一的实例中的类成员是否线程安全。接下来，我们来看下面的的示例：

/* Servlet线程安全 */
    public class ServletDemo04 extends HttpServlet{ 
        //1.定义用户名成员变量：定义在类里面，这样就会发生线程安全问题，造成数据共享
        private String username = null;
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
                //2.获取用户名
                username = req.getParameter("username");
    
                try { 
                    Thread.sleep(3000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
                //3.获取输出流对象
                PrintWriter pw = resp.getWriter();
    
                //4.响应给客户端浏览器
                pw.print("welcome:" + username);
    
                //5.关流
                pw.close();
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            doGet(req,resp);
        }
    }

启动两个浏览器，输入不同的参数，访问之后发现输出的结果都是一样，所以出现线程安全问题

例如下图是上面案例的测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 13]

通过上面的测试我们发现，在Servlet中定义了类成员之后，多个浏览器都会共享类成员的数据。

其实每一个浏览器端发送请求，就代表是一个线程，那么多个浏览器就是多个线程，所以测试的结果说明了多个线程会共享Servlet类成员中的数据，其中任何一个线程修改了数据，都会影响其他线程。因此，我们可以认为Servlet它不是线程安全的。

分析产生这个问题的根本原因，其实就是因为Servlet是单例，单例对象的类成员只会随类实例化时初始化一次，之后的操作都是改变，而不会重新初始化。

### 解决方法 ###

解决这个问题也非常简单，就是在Servlet中定义类成员要慎重。

*  如果类成员是共用的，并且只会在初始化时赋值，其余时间都是获取的话，那么是没问题。
 *  如果类成员并非共用，或者每次使用都有可能对其赋值，那么就要考虑线程安全问题了，把它定义到doGet或者doPost方法里面去就可以了。

还可以再给他进一步加上线程锁，对数据进行保护。

可以参考下面改进后的代码

/* Servlet线程安全 */
    public class ServletDemo04 extends HttpServlet{ 
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            //1.定义用户名成员变量：放在doGet里，作为临时变量
            String username = null;
            // 加上线程同步锁，进一步保护数据
            synchronized (this) { 
                //2.获取用户名
                username = req.getParameter("username");
    
                try { 
                    Thread.sleep(3000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
                //3.获取输出流对象
                PrintWriter pw = resp.getWriter();
    
                //4.响应给客户端浏览器
                pw.print("welcome:" + username);
    
                //5.关流
                pw.close();
            }
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            doGet(req,resp);
        }
    }

## 1.3 Servlet的注意事项 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 14]

### 1.3.1 映射Servlet的细节 ###

Servlet支持三种映射方式，以达到灵活配置的目的。

首先编写一个Servlet，代码如下：

/** * 演示Servlet的映射方式 * @author 黑马程序员 * @Company http://www.itheima.com */
    public class ServletDemo5 extends HttpServlet { 
    
        /** * doGet方法输出一句话 * @param req * @param resp * @throws ServletException * @throws IOException */
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            System.out.println("ServletDemo5接收到了请求");
        }
    
        /** * 调用doGet方法 * @param req * @param resp * @throws ServletException * @throws IOException */
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            doGet(req,resp);
        }
    }

#### 第一种：指名道姓的方式 ####

此种方式，只有和映射配置一模一样时，Servlet才会接收和响应来自客户端的请求。

例如：映射为：/servletDemo5

访问URL：[http://localhost:8585/servlet\_demo/servletDemo5  
][http_localhost_8585_servlet_demo_servletDemo5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 15]

#### 第二种：/开头+通配符的方式 ####

此种方式，只要符合目录结构即可，不用考虑结尾是什么。

例如：映射为：/servlet/\*

访问URL：http://localhost:8585/servlet/itheima

http://localhost:8585/servlet/itcast.do

这两个URL都可以。因为用的\*，表示/servlet/后面的内容是什么都可以。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 16]

#### 第三种：通配符+固定格式结尾 ####

此种方式，只要符合固定结尾格式即可，其前面的访问URI无须关心（注意协议，主机和端口必须正确）

例如：映射为：\*.do

访问URL：http://localhost:8585/servlet/itcast.do

http://localhost:8585/itheima.do

这两个URL都可以方法。因为都是以.do作为结尾，而前面用\*号通配符配置的映射，所有无须关心。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 17]

### 第四种：多种映射顺序 ###

通过测试我们发现，Servlet支持多种配置方式，但是由此也引出了一个问题，当有两个及以上的Servlet映射都符合请求URL时，由谁来响应呢？注意：HTTP协议的特征是一请求一响应的规则。那么有一个请求，必然有且只有一个响应。所以，我们接下来明确一下，多种映射规则的优先级。

先说结论：指名道姓的方式优先级最高，带有通配符的映射方式，有/的比没/的优先级高

所以，我们前面讲解的三种映射方式的优先级为：第一种>第二种>第三种。

演示代码如下：

/** * 它和ServletDemo5组合演示Servlet的访问优先级问题 * @author 黑马程序员 * @Company http://www.itheima.com */
    public class ServletDemo6 extends HttpServlet { 
    
        /** * doGet方法输出一句话 * @param req * @param resp * @throws ServletException * @throws IOException */
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            System.out.println("ServletDemo6接收到了请求");
        }
    
        /** * 调用doGet方法 * @param req * @param resp * @throws ServletException * @throws IOException */
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            doGet(req,resp);
        }
    }

<servlet>
        <servlet-name>servletDemo6</servlet-name>
        <servlet-class>com.itheima.web.servlet.ServletDemo6</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>servletDemo6</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

运行结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 18]

### 1.3.2 多路径映射Servlet ###

上面我们讲解了Servlet的多种映射方式，这一小节我们来介绍一下，一个Servlet的多种路径配置的支持。

它其实就是给一个Servlet配置多个访问映射，从而可以根据不同请求URL实现不同的功能。

首先，创建一个Servlet：

/** * 演示Servlet的多路径映射 */
    public class ServletDemo7 extends HttpServlet { 
    
        /** * 根据不同的请求URL，做不同的处理规则 * @param req * @param resp * @throws ServletException * @throws IOException */
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            //1.获取当前请求的URI
            String uri = req.getRequestURI();
            uri = uri.substring(uri.lastIndexOf("/"),uri.length());
            //2.判断是1号请求还是2号请求
            if("/servletDemo7".equals(uri)){ 
                System.out.println("ServletDemo7执行1号请求的业务逻辑：商品单价7折显示");
            }else if("/demo7".equals(uri)){ 
                System.out.println("ServletDemo7执行2号请求的业务逻辑：商品单价8折显示");
            }else { 
                System.out.println("ServletDemo7执行基本业务逻辑：商品单价原价显示");
            }
        }
    
        /** * 调用doGet方法 * @param req * @param resp * @throws ServletException * @throws IOException */
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
            doGet(req,resp);
        }
    }

接下来，在web.xml配置Servlet：

<servlet>
        <servlet-name>servletDemo7</servlet-name>
        <servlet-class>com.itheima.web.servlet.ServletDemo7</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>servletDemo7</servlet-name>
        <url-pattern>/demo7</url-pattern>
    </servlet-mapping>
    
    <servlet-mapping>
        <servlet-name>servletDemo7</servlet-name>
        <url-pattern>/servletDemo7</url-pattern>
    </servlet-mapping>
    
    <servlet-mapping>
        <servlet-name>servletDemo7</servlet-name>
        <url-pattern>/servlet/*</url-pattern>
    </servlet-mapping>

最后，启动服务测试运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 19]

### 1.3.3 启动时创建Servlet ###

我们前面讲解了Servlet的生命周期，Servlet的创建默认情况下是请求第一次到达Servlet时创建的。但是我们都知道，Servlet是单例的，也就是说在应用中只有唯一的一个实例，所以在Tomcat启动加载应用的时候就创建也是一个很好的选择。那么两者有什么区别呢？

*  第一种：应用加载时创建Servlet，它的优势是在服务器启动时，就把需要的对象都创建完成了，从而在使用的时候减少了创建对象的时间，提高了首次执行的效率。它的弊端也同样明显，因为在应用加载时就创建了Servlet对象，因此，导致内存中充斥着大量用不上的Servlet对象，造成了内存的浪费。
 *  第二种：请求第一次访问是创建Servlet，它的优势就是减少了对服务器内存的浪费，因为那些一直没有被访问过的Servlet对象都没有创建，因此也提高了服务器的启动时间。而它的弊端就是，如果有一些要在应用加载时就做的初始化操作，它都没法完成，从而要考虑其他技术实现。

#### 方式的选择 ####

通过上面的描述，相信同学们都能分析得出何时采用第一种方式，何时采用第二种方式。

*  就是当需要在应用加载就要完成一些工作时，就需要选择第一种方式。
 *  当有很多Servlet的使用时机并不确定是，就选择第二种方式。

在web.xml中是支持对Servlet的创建时机进行配置的，配置的方式如下：我们就以ServletDemo3为例。

<servlet>
        <servlet-name>servletDemo3</servlet-name>
        <servlet-class>com.itheima.web.servlet.ServletDemo3</servlet-class>
        
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>servletDemo3</servlet-name>
        <url-pattern>/servletDemo3</url-pattern>
    </servlet-mapping>

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 20]

### 1.3.4 默认Servlet ###

默认Servlet是由服务器提供的一个Servlet，它配置在Tomcat的conf目录下的web.xml中。如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 21]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 22]

它的映射路径是**`<url-pattern>/<url-pattern>`**，我们在发送请求时，首先会在我们应用中的web.xml中查找映射配置，找到就执行，这块没有问题。但是当找不到对应的Servlet路径时，就去找默认的Servlet，由默认Servlet处理。所以，一切都是Servlet。

## 1.4 Servlet关系总图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 23]

--------------------

### 哎，事真多，微笑面对吧 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70_pic_center]

# 四、响应 #

## 1.1 响应对象概述 ##

### 1.1.1 关于响应 ###

响应，它表示了服务器端收到请求，同时也已经处理完成，把处理的结果告知用户。简单来说，指的就是服务器把请求的处理结果告知客户端。在B/S架构中，响应就是把结果带回浏览器。

响应对象，顾名思义就是用于在JavaWeb工程中实现上述功能的对象。

### 1.1.2 常用响应对象 ###

响应对象也是是Servlet规范中定义的，它包括了协议无关的和协议相关的。

*  协议无关的对象标准是：ServletResponse接口
 *  协议相关的对象标准是：HttpServletResponse接口

类结构图如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 24]

下面介绍涉及的响应对象都是和HTTP协议相关的。即使用的是HttpServletResponse接口的实现类。

这里有些同学可能会产生疑问，我们在使用Servlet时，需要定义一个类，然后实现Servlet接口（或者继承它的实现类）。现在我们想要实现响应功能，要不要定义一个类，然后实现HttpServletResponse接口呢？

**此问题的答案是否定的，我们无需这么做。**我们只需要在自己写的Servlet中直接使用即可，因为这个对象的实现类是由Tomcat提供的，无须我们自定义。同时它还会帮我们把对象创建出来并传入doGet和doPost方法中。

## 1.2 常用方法介绍 ##

### 1.2.1 API 介绍 ###

在官网中我们可以查看到：[https://javaee.github.io/javaee-spec/javadocs/][API]

在HttpServletResponse接口中提供了很多方法，接下来我们通过API文档，来了解一下这些方法。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 25]

我们对上面函数进行中文解释，如下图。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 26]

### 1.2.2 常用响应状态码 ###

常用状态码：

<table> 
 <thead> 
  <tr> 
   <th align="center">状态码</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">200</td> 
   <td align="center">执行成功</td> 
  </tr> 
  <tr> 
   <td align="center">302</td> 
   <td align="center">它和307一样，都是用于重定向的状态码。只是307目前已不再使用</td> 
  </tr> 
  <tr> 
   <td align="center">304</td> 
   <td align="center">请求资源未改变，使用缓存。</td> 
  </tr> 
  <tr> 
   <td align="center">400</td> 
   <td align="center">请求错误。最常见的就是请求参数有问题</td> 
  </tr> 
  <tr> 
   <td align="center">404</td> 
   <td align="center">请求资源未找到</td> 
  </tr> 
  <tr> 
   <td align="center">405</td> 
   <td align="center">请求方式不被支持</td> 
  </tr> 
  <tr> 
   <td align="center">500</td> 
   <td align="center">服务器运行内部错误</td> 
  </tr> 
 </tbody> 
</table>

状态码首位含义：

<table> 
 <thead> 
  <tr> 
   <th align="center">状态码</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">1xx</td> 
   <td align="center">消息</td> 
  </tr> 
  <tr> 
   <td align="center">2xx</td> 
   <td align="center">成功</td> 
  </tr> 
  <tr> 
   <td align="center">3xx</td> 
   <td align="center">重定向</td> 
  </tr> 
  <tr> 
   <td align="center">4xx</td> 
   <td align="center">客户端错误</td> 
  </tr> 
  <tr> 
   <td align="center">5xx</td> 
   <td align="center">服务器错误</td> 
  </tr> 
 </tbody> 
</table>

## 1.3 响应对象的使用示例 ##

### 1.3.1 响应字节流输出中文乱码问题 ###

内容过多，请移驾我的另一篇博客：  
[https://yangyongli.blog.csdn.net/article/details/117877830][https_yangyongli.blog.csdn.net_article_details_117877830]

### 1.3.3 响应-生成验证码 ###

内容过多，请移驾我的另一篇博客：  
[https://yangyongli.blog.csdn.net/article/details/117878306][https_yangyongli.blog.csdn.net_article_details_117878306]

### 1.3.4 设置响应消息头 —— 控制缓存 ###

/** * 设置缓存时间 * 使用缓存的一般都是静态资源 * 动态资源一般不能缓存。 * 我们现在目前只掌握了Servlet，所以用Servlet做演示 * */
    public class ResponseDemo4 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            String str = "设置缓存时间";
            /* * 设置缓存时间，其实就是设置响应消息头：Expires 但是值是一个毫秒数。 * 使用的是 * response.setDateHeader(); * * 缓存1小时，是在当前时间的毫秒数上加上1小时之后的毫秒值 */
            response.setDateHeader("Expires",System.currentTimeMillis()+1*60*60*1000);
            response.setContentType("text/html;charset=UTF-8");
            response.getOutputStream().write(str.getBytes());
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 27]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 28]

### 1.3.5 设置响应消息头 —— 定时刷新 ###

/** * 设置响应消息头： * 通过定时刷新演示添加消息头 */
    public class ResponseDemo5 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            String str = "用户名和密码不匹配，2秒后转向登录页面...";
            response.setContentType("text/html;charset=UTF-8");
            PrintWriter out = response.getWriter();
            out.write(str);
            //定时刷新，其实就是设置一个响应消息头
            response.setHeader("Refresh", "2;URL=/login.html");//Refresh设置的时间单位是秒，如果刷新到其他地址，需要在时间后面拼接上地址
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 29]

### 1.3.6 请求重定向：注意地址栏发生改变。 ###

/** * 设置响应状态码，实现重定向 * 重定向的特点： * 两次请求，地址栏改变，浏览器行为，xxxx * */
    public class ResponseDemo6 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            //1.设置响应状态码
    // response.setStatus(302);
            //2.定向到哪里去: 其实就是设置响应消息头，Location
    // response.setHeader("Location", "ResponseDemo7");
    
            //使用重定向方法
            response.sendRedirect("ResponseDemo7");//此行做了什么事，请看上面
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

重定向到了这

/** * 重定向的目的地 */
    public class ResponseDemo7 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            response.getWriter().write("welcome to ResponseDemo7");
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 30]

### 1.3.7 响应和消息头组合应用 —— 文件下载 ###

首先，在工程的web目录下新建一个目录uploads，并且拷贝一张图片到目录中，如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 31]

文件下载的Servlet代码如下：

/** * 文件下载 * */
    public class ResponseDemo8 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            /* * 文件下载的思路： * 1.获取文件路径 * 2.把文件读到字节输入流中 * 3.告知浏览器，以下载的方式打开（告知浏览器下载文件的MIME类型） * 4.使用响应对象的字节输出流输出到浏览器上 */
            //1.获取文件路径（绝对路径）
            ServletContext context = this.getServletContext();
            String filePath = context.getRealPath("/uploads/6.jpg");//通过文件的虚拟路径，获取文件的绝对路径
            //2.通过文件路径构建一个字节输入流
            InputStream in  = new FileInputStream(filePath);
            //3.设置响应消息头
            response.setHeader("Content-Type", "application/octet-stream");//注意下载的时候，设置响应正文的MIME类型，用application/octet-stream
            response.setHeader("Content-Disposition", "attachment;filename=1.jpg");//告知浏览器以下载的方式打开
            //4.使用响应对象的字节输出流输出
            OutputStream out = response.getOutputStream();
            int len = 0;
            byte[] by = new byte[1024];
            while((len = in.read(by)) != -1){ 
                out.write(by, 0, len);
            }
            in.close();
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 32]

### 1.3.8 响应对象注意事项 ###

**第一： response得到的字符流和字节流互斥，只能选其一**

**第二：response获取的流不用关闭，由服务器关闭即可**

/** * 使用Response对象获取流时候的注意事项： * 1.我们使用response获取的流，可以不用关闭。服务器会给我们关闭。 * 2.在response对象中，字节流和字符流互斥，输出的时候，只能选择一个 * */
    public class ResponseDemo9 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            String str = "test";
            response.getOutputStream().write(str.getBytes());
            //response.getWriter().write(str);
    // response.getOutputStream().write("haha".getBytes());
    
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 33]

# 五、请求对象 #

## 2.1 请求对象概述 ##

### 2.1.1 关于请求 ###

请求，顾明思议，就是使用者希望从服务器端索取一些资源，向服务器发出询问。在B/S架构中，就是客户浏览器向服务器发出询问。在我们的JavaEE工程中，客户浏览器发出询问，要遵循HTTP协议所规定的。

请求对象，就是在JavaEE工程中，用于发送请求的对象。我们常用的对象就是ServletRequest和HttpServletRequest，它们的区别就是是否和HTTP协议有关。

### 2.1.2 常用请求对象 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 34]

## 2.2 常用方法介绍 ##

官网：[https://javaee.github.io/javaee-spec/javadocs/][API]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 35]  
我们进行中文解释如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 36]

## 2.3 请求对象的使用示例 ##

### 2.3.1 请求对象常用方法1-获取各种路径 ###

/** * 请求对象的各种信息获取 */
    public class RequestDemo1 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
    
            //本机地址：服务器地址
            String localAddr = request.getLocalAddr();
            //本机名称：服务器名称
            String localName = request.getLocalName();
            //本机端口：服务器端口
            int localPort = request.getLocalPort();
            //来访者ip
            String remoteAddr = request.getRemoteAddr();
            //来访者主机
            String remoteHost = request.getRemoteHost();
            //来访者端口
            int remotePort = request.getRemotePort();
            //统一资源标识符
            String URI = request.getRequestURI();
            //统一资源定位符
            String URL = request.getRequestURL().toString();
            //获取查询字符串
            String queryString = request.getQueryString();
            //获取Servlet映射路径
            String servletPath = request.getServletPath();
    
            //输出内容
    		System.out.println("getLocalAddr() is :"+localAddr);
    		System.out.println("getLocalName() is :"+localName);
    		System.out.println("getLocalPort() is :"+localPort);
    		System.out.println("getRemoteAddr() is :"+remoteAddr);
    		System.out.println("getRemoteHost() is :"+remoteHost);
    		System.out.println("getRemotePort() is :"+remotePort);
    		System.out.println("getRequestURI() is :"+URI);
    		System.out.println("getRequestURL() is :"+URL);
            System.out.println("getQueryString() is :"+queryString);
            System.out.println("getServletPath() is :"+servletPath);
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 37]

### 2.3.2 请求对象常用方法2-获取请求头信息 ###

/** * 获取请求消息头 * @author 黑马程序员 * @Company http://www.itheima.com */
    public class RequestDemo2 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            //1.根据名称获取头的值 一个消息头一个值
            String value = request.getHeader("Accept-Encoding");
            System.out.println("getHeader():"+value);
    
            //2.根据名称获取头的值 一个头多个值
            Enumeration<String> values = request.getHeaders("Accept");
            while(values.hasMoreElements()){ 
                System.out.println("getHeaders():"+values.nextElement());
            }
    
            //3.获取请求消息头的名称的枚举
            Enumeration<String> names = request.getHeaderNames();
            while(names.hasMoreElements()){ 
                String name = names.nextElement();
                String value1 = request.getHeader(name);
                System.out.println(name+":"+value1);
            }
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

结果如下图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 38]

### 2.3.3 请求对象常用方法3-获取请求参数（非常重要） ###

内容较多，请移驾另一篇博客：  
[https://yangyongli.blog.csdn.net/article/details/117880162][https_yangyongli.blog.csdn.net_article_details_117880162]

### 2.3.4 用流的形式读取请求信息 ###

我们除了使用2.3.3小节中获取请求参数之外，还可以使用下面代码中的 方式来获取：

/** * 使用流的方式读取请求正文 */
    public class RequestDemo4 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            //1.获取请求正文的字节输入流
            ServletInputStream sis = request.getInputStream();
            //2.读取流中的数据
            int len = 0;
            byte[] by = new byte[1024];
            while((len = sis.read(by)) != -1){ 
                System.out.println(new String(by,0,len));
            }
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

### 2.3.5 请求正文中中文编码问题 ###

内容过多，请移驾另一篇博客：  
[https://yangyongli.blog.csdn.net/article/details/117880598][https_yangyongli.blog.csdn.net_article_details_117880598]

### 2.3.6 请求转发（与重定向的区别） ###

在实际开发中，重定向和请求转发都是我们要用到的响应方式，那么他们有什么区别呢？我们通过下面的示例来看一下：

/** * 重定向特点： * 两次请求，浏览器行为，地址栏改变，请求域中的数据会丢失 * 请求转发： * 一次请求，服务器行为，地址栏不变，请求域中的数据不丢失 * * 请求域的作用范围： * 当前请求（一次请求）,和当前请求的转发之中 * @author 黑马程序员 * @Company http://www.itheima.com */
    public class RequestDemo6 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            //1.拿到请求调度对象
            RequestDispatcher rd = request.getRequestDispatcher("/RequestDemo7");//如果是给浏览器看的，/可写可不写。如果是给服务器看的，一般情况下，/都是必须的。
            //放入数据到请求域中
            request.setAttribute("CityCode", "bj-010");
            //2.实现真正的转发操作
            rd.forward(request, response);//实现真正的转发操作
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

/** * 转发的目的地 * @author 黑马程序员 * @Company http://www.itheima.com */
    public class RequestDemo7 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            //获取请求域中的数据
            String value = (String)request.getAttribute("CityCode");
            response.getWriter().write("welcome to request demo 7 "+value);
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

### 2.3.7 请求包含 ###

在实际开发中，我们可能需要把两个Servlet的内容合并到一起来响应浏览器，而同学们都知道HTTP协议的特点是一请求，一响应的方式。

所以绝对不可能出现有两个Servlet同时响应方式。

那么我们就需要用到请求包含，把两个Servlet的响应内容合并输出。我们看具体使用示例：

/** * 请求包含 * * 它是把两个Servlet的响应内容合并输出。 * 注意： * 这种包含是动态包含。 * * 动态包含的特点： * 各编译各的，只是最后合并输出。 */
    public class RequestDemo8 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            response.getWriter().write("I am request demo8 ");
            //1.拿到请求调度对象
            RequestDispatcher rd = request.getRequestDispatcher("/RequestDemo9");
            //2.实现包含的操作
            rd.include(request, response);
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    }

/** * 被包含者 */
    public class RequestDemo9 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            response.getWriter().write("include request demo 9 ");
        }
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    
    }

### 2.3.8 更细节问题 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 39]

请求转发的注意事项：负责转发的Servlet，转发前后的响应正文丢失，由转发目的地来响应浏览器。

请求包含的注意事项：被包含者的响应消息头丢失。因为它被包含起来了。

# 六、cookie #

[https://yangyongli.blog.csdn.net/article/details/117912761][https_yangyongli.blog.csdn.net_article_details_117912761]

# 七、session #

[https://yangyongli.blog.csdn.net/article/details/117914643][https_yangyongli.blog.csdn.net_article_details_117914643]

# 八、jsp（※） #

## 1 JSP基础 ##

### 1.1 JSP简介 ###

JSP全称是Java Server Page，它和Servlet一样，也是sun公司推出的一套开发动态web资源的技术，称为JSP/Servlet规范。JSP的本质其实就是一个Servlet。

### 1.2 JSP和HTML以及Servlet的适用场景 ###

<table> 
 <thead> 
  <tr> 
   <th>类别</th> 
   <th>适用场景</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>HTML</td> 
   <td>只能开发静态资源，不能包含java代码，无法添加动态数据。</td> 
  </tr> 
  <tr> 
   <td>Servlet</td> 
   <td>写java代码，可以输出页面内容，但是很不方便，开发效率极低。</td> 
  </tr> 
  <tr> 
   <td>JSP</td> 
   <td>它包括了HTML的展示技术，同时具备Servlet输出动态资源的能力。但是不适合作为控制器来用。</td> 
  </tr> 
 </tbody> 
</table>

### 1.3 JSP简单入门 ###

**创建JavaWeb工程**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 40]

**在index.jsp中填写内容**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
      <head>
        <title>JSP的入门</title>
      </head>
      <body>
          这是第一个JSP页面
      </body>
    </html>

**部署项目**

沿用会话管理工程的部署方式即可。

**测试运行**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 41]

### 1.4 JSP说明 ###

写在之前： 明确JSP就是一个Servlet。是一个特殊的Servlet。

> JSP的原理：
> 
>  客户端提交请求
> 
>  ——Tomcat服务器解析请求地址
> 
>  ——找到JSP页面
> 
>  ——Tomcat将JSP页面翻译成Servlet的java文件
> 
>  ——将翻译好的.java文件编译成.class文件
> 
>  ——返回到客户浏览器上。

#### 1）执行过程分析图 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 42]

#### 2）JSP的.java文件内容分析（看不懂跳过，反jsp本质就是servlet） ####

当我们打开index.jsp翻译的java文件看到的就是`public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase`类的声明，然后我们在Tomcat的源码中找到类的声明，如下图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 43]

这张图一出场，就表明我们写的JSP它本质就是一个HttpServlet了。

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QFbZEkVG-1623675513407)(assets/jsp的本质说明.png)\]][img-QFbZEkVG-1623675513407_assets_jsp_.png]

同时，我们在index\_jsp.java文件中找到了输出页面的代码，并且在浏览器端查看源文件，看到的内容是一样的。这也就是说明，我们的浏览器上的内容，在通过jsp展示时，本质都是用out.write()输出出来的。

讲到这里，我们应该清楚的认识到，JSP它是一个特殊的Servlet，主要是用于展示动态数据。它展示的方式是用流把数据输出出来，而我们在使用JSP时，涉及HTML的部分，都与HTML的用法一致，这部分称为jsp中的模板元素，在开发过程中，先写好这些模板元素，因为它们决定了页面的外观。

## 2 JSP应用 ##

### 2.1 JSP语法 ###

#### 1）Java代码块 ####

在jsp中，可以使用java脚本代码。形式为：**<% 此处写java代码 %>**

但是，在实际开发中，极少使用此种形式编写java代码。同时需要注意的是：

<%
        在里面写java程序脚本需要注意：这里面的内容由tomcat负责翻译，翻译之后是service方法的成员变量
    %>

**示例：**

<% out.println("这是Java代码块");%>
    <hr/>

#### 2）JSP表达式 ####

在jsp中，可以使用特定表达式语法，形式为：**<%=表达式%>**

jsp在翻译完后是`out.print(表达式内容);`

所以：`<%out.print("当前时间);%>`和`<%="当前时间"%>`是一样的。

在实际开发中，这种表达式语法用的也很少使用。

**示例：**

<%="这是JSP表达式"%><br/>
    就相当于<br/>
    <%out.println("这是没有JSP表达式输出的");%>

#### 3）JSP声明 ####

在JSP中也可以声明一些变量，方法，静态方法，形式为：**<%! 声明的内容 %>**

使用JSP声明需要注意：

<%! 
        需要注意的是： 写在里面的内容将会被tomcat翻译成全局的属性或者类方法。
    %>

**示例：**

<%! String str = "声明语法格式";%>
    <%=str%>

#### 4）JSP注释 ####

在使用JSP时，它有自己的注释，形式为：**<%–注释–%>**

需要注意的是：

在Jsp中可以使用html的注释，但是只能注释html元素，不能注释java程序片段和表达式。同时，被html注释部分会参与翻译，并且会在浏览器上显示

jsp的注释不仅可以注释java程序片段，也可以注释html元素，并且被jsp注释的部分不会参与翻译成.java文件，也不会在浏览器上显示。

**示例：**

<%--JSP注释--%>

#### 5）语法的示例 ####

**JSP语法完整示例代码**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>JSP语法</title>
    </head>
    <body>
    
    
    <% out.println("这是Java代码块");%>
    <hr/>
    
    
    <%="这是JSP表达式"%><br/>
    就相当于<br/>
    <%out.println("这是没有JSP表达式输出的");%>
    
    <hr/>
    
    <%! String str = "声明语法格式";%>
    <%=str%>
    
    <hr/>
    
    <%--JSP注释--%>
    
    
    </body>
    </html>

**JSP语法运行结果**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 44][]

### 2.2 JSP指令 ###

#### 1）page指令 ####

*  **language**: 告知引擎，脚本使用的是java，默认是java，支持java。不写也行。
 *  **extends**：告知引擎，JSP对应的Servlet的父类是哪个，不需要写，也不需要改。
 *  **import**：告知引擎，导入哪些包（类）。
    
    **注意：**  
    **引擎会自动导入：java.lang.\*,javax.servlet.\*,javax.servlet.http.\*,javax.servlet.jsp.\***
    
    **导入的形式： (用Eclipse：Alt+/ 自动导入)**
    
        <%@page import=”java.util.Date,java.util.UUID”%>
        
        或者：
        
        <%@page import=”java.util.Date”%>
        <%@page import=”java.util.UUID”%>
 *  **session**：告知引擎是否产生HttpSession对象，即是否在代码中调用request.getSession()。默认是true。
 *  **buffer**：JspWriter用于输出JSP内容到页面上。告知引擎，设定他的缓存大小。默认8kb。
 *  **errorPage**：告知引擎，当前页面出现异常后，应该转发到哪个页面上（路径写法：/代表当前应用）
    
    **小贴士：当在errorpage上使用了isErrorPage=true之后，ie8有时候不能正常显示**
    
     **配置全局错误页面：web.xml**
    
        <error-page>    
            <exception-type>java.lang.Exception</exception-type>                
            <location>/error.jsp</location>
        </error-page>
        <error-page>
            <error-code>404</error-code>
            <location>/404.html</location>
        </error-page>
    
    **当使用了全局错误页面，就无须再写errorPage来实现转到错误页面，而是由服务器负责跳转到错误页面。**
 *  **isErrorPage**：告知引擎，是否抓住异常。如果该属性为true，页面中就可以使用exception对象，打印异常的详细信息。默认值是false。
 *  **contentType**：告知引擎，响应正文的MIME类型。`contentType="text/html;charset=UTF-8"`
    
    相当于`response.setContentType("text/html;charset=UTF-8");`
 *  **pageEncoding**：告知引擎，翻译jsp时（从磁盘上读取jsp文件）所用的码表。pageEncoding="UTF-8"相当于告知引擎用UTF-8读取JSP
 *  **isELIgnored**：告知引擎，是否忽略EL表达式，默认值是false，不忽略。

#### 2）include指令 ####

语法格式：`<%@include file="" %>`该指令是包含外部页面。

属性：file，以/开头，就代表当前应用。

**使用示例**

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bNF3bYO5-1623675513409)(assets/静态包含1.png)\]][img-bNF3bYO5-1623675513409_assets_1.png]

在编译成的java servlet文件中是这样的，也就是说，include.jsp 后续 代码可以直接使用 included.jsp 中的 str变量。

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sNEL9jBx-1623675513411)(assets/静态包含2.png)\]][img-sNEL9jBx-1623675513411_assets_2.png]

#### 3）taglib指令 ####

语法格式：`<%taglib uri="" prefix=""%>`

作用：该指令用于引入外部标签库。html标签和jsp标签不用引入。

属性：

*  `uri`：外部标签的URI地址。
 *  `prefix`：使用标签时的前缀。

### 2.3 JSP细节 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 45]

#### 1）九大隐式对象 ####

什么是隐式对象呢？它指的是在jsp中，可以不声明就直接使用的对象。

它只存在于jsp中，因为java类中的变量必须要先声明再使用。

其实jsp中的隐式对象也并非是未声明，只是它是在翻译成.java文件时声明的。所以我们在jsp中可以直接使用。

也就是说下面的对象在jsp中可以直接使用。

<table> 
 <thead> 
  <tr> 
   <th>隐式对象名称</th> 
   <th>类型</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>request</td> 
   <td>javax.servlet.http.HttpServletRequest</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>response</td> 
   <td>javax.servlet.http.HttpServletResponse</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>session</td> 
   <td>javax.servlet.http.HttpSession</td> 
   <td>Page指令可以控制开关</td> 
  </tr> 
  <tr> 
   <td>application</td> 
   <td>javax.servlet.ServletContext</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>page</td> 
   <td>Java.lang.Object</td> 
   <td>当前jsp对应的servlet引用实例</td> 
  </tr> 
  <tr> 
   <td>config</td> 
   <td>javax.servlet.ServletConfig</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>exception</td> 
   <td>java.lang.Throwable</td> 
   <td>page指令有开关</td> 
  </tr> 
  <tr> 
   <td>out</td> 
   <td>javax.servlet.jsp.JspWriter</td> 
   <td>字符输出流，相当于printwriter</td> 
  </tr> 
  <tr> 
   <td>pageContext</td> 
   <td>javax.servlet.jsp.PageContext</td> 
   <td>很重要（下面单独介绍）</td> 
  </tr> 
 </tbody> 
</table>

#### 2）PageContext对象 ####

**简介**

它是JSP独有的对象，Servlet中没有这个对象。本身也是一个域（作用范围）对象，但是它可以操作其他3个域对象中的属性。而且还可以获取其他8个隐式对象。

**生命周期**

它是一个局部变量，所以它的生命周期随着JSP的创建而诞生，随着JSP的结束而消失。每个JSP页面都有一个独立的PageContext。

**常用方法**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 46]

在上图中，同学们发现没有页面域操作的方法，其实是定义在了PageContext的父类JspContext中，如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 47]

#### 3）四大域对象 ####

<table> 
 <thead> 
  <tr> 
   <th>域对象名称</th> 
   <th>范围</th> 
   <th>级别</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PageContext</td> 
   <td>页面范围</td> 
   <td>最小，只能在当前页面用</td> 
   <td>因范围太小，开发中用的很少</td> 
  </tr> 
  <tr> 
   <td>ServletRequest</td> 
   <td>请求范围</td> 
   <td>一次请求或当期请求转发用</td> 
   <td>当请求转发之后，再次转发时请求域丢失</td> 
  </tr> 
  <tr> 
   <td>HttpSession</td> 
   <td>会话范围</td> 
   <td>多次请求数据共享时使用</td> 
   <td>多次请求共享数据，但不同的客户端不能共享</td> 
  </tr> 
  <tr> 
   <td>ServletContext</td> 
   <td>应用范围</td> 
   <td>最大，整个应用都可以使用</td> 
   <td>尽量少用，如果对数据有修改需要做同步处理</td> 
  </tr> 
 </tbody> 
</table>

#### 4）四大域对象作用范围 ####

**pageContext**

作用范围：当前jsp页面；

作用：获取九大内置对象；

常用方法：`getAttribute()、setAttribute()、removeAttribute()、findAttribute()`

**httpServletRequest**

作用范围：一次请求范围内，转发有效重定向失效；

作用：将servlet中的数据通过request对象带到jsp页面；

**httpSession**

作用范围：存活时间内（默认30分钟），一次会话内有效，转发和重定向都有效；

**servletContext**

作用范围：整个web应用；

在jsp的九大内置对象中，`servletContext`对应`application`；

### 2.4 JSP最佳实战效果——MVC模型 ###

*  M：model ，通常用于封装数据，封装的是数据模型。
 *  V：view ，通常用于展示数据。动态展示用jsp页面，静态数据展示用html。
 *  C：controller ，通常用于处理请求和响应。一般指的是Servlet。

**Servlet**：擅长处理业务逻辑，不擅长输出显示界面。在web开发中多用于控制程序逻辑（流程）。所以我们称之为：控制器。

**JSP**：擅长显示界面，不擅长处理程序逻辑。在web开发中多用于展示动态界面。所以我们称之为：视图。

例如:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 48]

# 九、知识补充： #

## JDK、JRE、JVM和SDK是啥啊都？ ##

JDK(Java Development Kit) 是 Java 语言的软件开发工具包(SDK)。

在JDK的安装目录下有一个jre目录，里面有两个文件夹bin和lib，在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和 lib合起来就称为jre。

JRE（Java Runtime Environment，Java运行环境），包含JVM标准实现及Java核心类库。JRE是Java运行环境，并不是一个开发环境，所以没有包含任何开发工具（如编译器和调试器）

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

在安装目录下是这样的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 49]

根据上面我们可以画成下面的关系图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 50]  
SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等（可以效仿API去理解），是给java应用程序开发者使用的。

## Servlet编写三种方式 ##

我们在实现Servlet功能时，可以选择以下三种方式：

### 1. 第一种：实现Servlet接口，接口中的方法必须全部实现。 ###

使用此种方式，表示接口中的所有方法在需求方面都有重写的必要。此种方式支持最大程度的自定义（我理解的就是真的个性化）。

### 2. 第二种：继承GenericServlet， ###

继承GenericServlet，service方法必须重写，其他方可根据需求，选择性重写。

使用此种方式，表示只在接收和响应客户端请求这方面有重写的需求，而其他方法可根据实际需求选择性重写，使我们的开发Servlet变得简单。但是，此种方式是和HTTP协议无关的。

比如说下面重写了 service方法

public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { 
        HttpServletRequest request;
        HttpServletResponse response;
        try { 
            request = (HttpServletRequest)req;
            response = (HttpServletResponse)res;
        } catch (ClassCastException var6) { 
            throw new ServletException("non-HTTP request or response");
        }
    
        this.service(request, response);
    }

service源码

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

### 3. 第三种：继承HttpServle ###

继承HttpServlet，它是javax.servlet.http包下的一个抽象类，是GenericServlet的子类。**如果我们选择继承HttpServlet时，只需要重写doGet和doPost方法，不要覆盖service方法。**

使用第三种方式，表示我们的请求和响应需要和HTTP协议相关。也就是说，我们是通过HTTP协议来访问的。那么每次请求和响应都符合HTTP协议的规范。请求的方式就是HTTP协议所支持的方式（目前我们只知道GET和POST，而实际HTTP协议支持7种请求方式，`GET POST PUT DELETE TRACE OPTIONS HEAD` )。

例如：

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(name = "thirdServlet", urlPatterns = "/servlet")
    //我们还可以进一步简化，因为我们发现其实name属性好像没啥用
    //@WebServlet(urlPatterns = "/servlet")
    //到这一步之后，还可以精简到底，如果括号里面只有一个值，那么默认表示的就是urlPattern
    @WebServlet("/servlet")
    public class ThirdServlet extends HttpServlet { 
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
    
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
    
        }
    }

## request获取请求参数 ##

HttpServletRequest对象获取请求参数的常用方法，以及把获取到的请求参数封装到实体类中的方式。首先，我们先来创建一个Servlet对象

/** * 封装请求正文到javabean（数据模型） */
    public class RequestDemo3 extends HttpServlet { 
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            /* * 把下面 * 1）获取请求参数 * 2）封装请求参数到实体类中 * 中定义的test1到test8逐个添加到此处来运行即可。 */
        }
     
        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException { 
            doGet(request, response);
        }
    }

接下来，我们在来准备一个表单页面：

<html>
    <head>
    	<title>login to request demo 3</title>
    </head>
    <body>
    <form action="/day10_1122_requestresponse/RequestDemo3" method="post">
    	用户名：<input type="text" name="username" /><br/>
    	密码：<input type="password" name="password" /><br/>
    	性别：<input type="radio" name="gender" value="1" checked>男
    	<input type="radio" name="gender" value="0">女
    	<br/>
    	<input type="submit" value="注册" />
    </form>
    </body>
    </html>

现在，我们开始分析HttpServletRequest对象用于获取请求参数的方法：

### 1. 获取请求参数 ###

#### getParameter()方法的示例代码 ####

/** * 获取请求正文，一个名称对应一个值。 没有使用确认密码 * @param request * @param response * @throws ServletException * @throws IOException */
    private void test1(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException { 
        //1.获取请求正文
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        String gender = request.getParameter("gender");
        System.out.println(username+","+password+","+gender);
    }

#### getParameterValues()方法的示例代码 ####

/** * 获取请求正文，一个名称可能对应多个值 使用了确认密码 * @param request * @param response * @throws ServletException * @throws IOException */
    private void test2(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException { 
        //1.获取请求正文
        String username = request.getParameter("username");
        String[] password = request.getParameterValues("password");//当表单中有多个名称是一样时，得到是一个字符串数组
        String gender = request.getParameter("gender");
        System.out.println(username+","+Arrays.toString(password)+","+gender);
    }

<html>
    <head>
    	<title>login to request demo 4</title>
    </head>
    <body>
    <form action="/day10_1122_requestresponse/RequestDemo4" method="post" enctype="multipart/form-data">
    	用户名：<input type="text" name="username" /><br/>
    	密码：<input type="password" name="password" /><br/>
    	确认密码：<input type="password" name="password" /><br/>
    	性别：<input type="radio" name="gender" value="1" checked>男
    	<input type="radio" name="gender" value="0">女
    	<br/>
    	<input type="submit" value="注册" />
    </form>
    </body>
    </html>

#### getParameterNames()方法的示例代码 ####

/** * 获取请求正文，一个名称一个值。但是先要获取正文名称的枚举（key的枚举） 没有使用确认密码 * @param request * @param response * @throws ServletException * @throws IOException */
    private void test3(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException { 
        //1.获取请求正文名称的枚举
        Enumeration<String> names = request.getParameterNames();
        //2.遍历正文名称的枚举
        while(names.hasMoreElements()){ 
            String name = names.nextElement();
            String value = request.getParameter(name);
            System.out.println(name+":"+value);
        }
    }

#### 总结： ####

以上三个方法可以获取表单提交过来的请求参数。

参数的名称是一个字符串，参数的值可能是一个字符串，也可能是一个字符串数组。

### 2. 封装请求参数到实体类中 ###

我们通过上面的方法可以获取到请求参数，但是如果参数过多，在进行传递时，方法的形参定义将会变得非常难看。此时我们应该用一个对象来描述这些参数，它就是实体类。这种类的定义，从基础阶段我们就开始使用了。在基础阶段，我们做过一个学生管理系统，用到了一个Student的类，它就是用于描述一个学生的实体类。

我们现在要做的就是把表单中提交过来的数据填充到实体类中。

#### 第一种：最简单直接的封装方式 ####

/** * 封装请求正文到User对象中 没有使用确认密码 * @param request * @param response * @throws ServletException * @throws IOException */
    private void test4(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException { 
        //1.获取请求正文
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        String gender = request.getParameter("gender");
        //2.创建一个User对象
        User user = new User();
        System.out.println("封装前："+user.toString());
        //3.把请求正文封装到user对象中
        user.setUsername(username);
        user.setPassword(password);
        user.setGender(gender);
        System.out.println("封装后："+user.toString());
    }

#### 第二种：使用反射方式封装 ####

此种封装的使用要求是，表单`<input>`标签的name属性取值，必须和实体类中定义的属性名称一致。

/** * 封装请求正文到javabean中 没有使用确认密码 * 使用反射+内省实现数据模型的封装 * 内省：是sun公司推出的一套简化反射操作的规范。把javabean中的元素都封装成一个属性描述器。 * 属性描述器中会有字段信息，get和set方法（取值或存值） * @param request * @param response * @throws ServletException * @throws IOException */
    private void test5(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException { 
        //1.获取请求正文名称的枚举
        Enumeration<String> names = request.getParameterNames();
        User user = new User();
        System.out.println("封装前："+user.toString());
        //2.遍历正文名称的枚举
        while(names.hasMoreElements()){ 
            String name = names.nextElement();
            String value = request.getParameter(name);
            try{ 
                //1.拿到User对象中的属性描述器。是谁的属性描述器：是由构造函数的第一个参数决定的。第二个参数是指定javabean的字节码
                PropertyDescriptor pd = new PropertyDescriptor(name, User.class);//参数指的就是拿哪个类的哪个属性的描述器
                //2.设置javabean属性的值
                Method method = pd.getWriteMethod();
                //3.执行方法
                method.invoke(user, value);//第一个参数是指的给哪个对象，第二个参数指的是赋什么值
            }catch(Exception e){ 
                e.printStackTrace();
            }
        }
        System.out.println("封装后："+user.toString());
    }

#### 第三种：使用反射封装，同时请求参数的值是一个数组 ####

此种方式其实就是针对请求参数中包含name属性相同的参数，例如：密码和确认密码，还有爱好。

/** * 获取请求正文的关系映射Map<String,String[]> 使用确认密码 * @param request * @param response * @throws ServletException * @throws IOException */
    private void test6(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException { 
        //1.获取请求正文的映射关系
        Map<String,String[]> map = request.getParameterMap();
        //2.遍历集合
        for(Map.Entry<String,String[]> me : map.entrySet()){ 
            String name = me.getKey();
            String[] value = me.getValue();
            System.out.println(name+":"+Arrays.toString(value));
        }
    }

当我们把请求参数获取出来之后，就要考虑如何针对数组的反射了，具体代码如下：

/** * 封装请求正文到javabean。使用的是反射+内省 使用了确认密码 * @param request * @param response * @throws ServletException * @throws IOException */
    private void test7(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException { 
        //1.获取请求正文的映射关系
        Map<String,String[]> map = request.getParameterMap();
        Users user = new Users();
        System.out.println("封装前："+user.toString());
        //2.遍历集合
        for(Map.Entry<String,String[]> me : map.entrySet()){ 
            String name = me.getKey();
            String[] value = me.getValue();
            try{ 
                //1.拿到User对象中的属性描述器。是谁的属性描述器：是由构造函数的第一个参数决定的。第二个参数是指定javabean的字节码
                PropertyDescriptor pd = new PropertyDescriptor(name, Users.class);//参数指的就是拿哪个类的哪个属性的描述器
                //2.设置javabean属性的值
                Method method = pd.getWriteMethod();
                //3.执行方法
                //判断参数到底是几个值
                if(value.length > 1){ //最少有2个元素
                    method.invoke(user, (Object)value);//第一个参数是指的给哪个对象，第二个参数指的是赋什么值
                }else{ 
                    method.invoke(user, value);//第一个参数是指的给哪个对象，第二个参数指的是赋什么值
                }
            }catch(Exception e){ 
                e.printStackTrace();
            }
        }
        System.out.println("封装后："+user.toString());
    }

当我们写完此种封装方式之后，同学们可以发现，我们绝大多数封装都可以使用这段代码来实现。并且，无论是谁来写这段通用的封装代码，其代码内容都是大同小异的。\*\*那么，我们就可以得出一个很有趣的结论：一般遇到这种情况时，肯定有人帮我们写好了，我们只需要用就行了。\*\*我们后面还会遇到类似这样的情况。

此时，帮我们写好这段封装代码的是apache软件基金会，我们前面学习的tomcat也是它提供的。它里面有一个开源工具包集合commons，里面有很多开源工具类，今天我们就来讲解第一个：**commons-beanutils**。

#### 第四种：使用apache的commons-beanutils实现封装 ####

实现代码：

/** * 终极方法：使用beanutils实现请求正文封装到javabean中 使用了确认密码 * 要想使用beanutils，需要先导包 * @param request * @param response * @throws ServletException * @throws IOException */
    private void test8(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException { 
        Users user = new Users();
        System.out.println("封装前："+user.toString());
        try{ 
            BeanUtils.populate(user, request.getParameterMap());//就这一句话
        }catch(Exception e){ 
            e.printStackTrace();
        }
        System.out.println("封装后："+user.toString());
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70]: /images/20221005/d15c2770e5914d2f854193423f2a7de4.png
[Tomcat]: http://tomcat.apache.org/
[https_yangyongli.blog.csdn.net_article_details_117822418]: https://yangyongli.blog.csdn.net/article/details/117822418
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 1]: /images/20221005/fef08cd73a704bb881beb1fffc8eb812.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 2]: /images/20221005/739d0cfd53d244ae87ffe2316e618993.png
[img-kuzFuo6W-1623549085998_assets_1574762703742.png]: /images/20221005/f02760365f854981bbdfcde59725f791.png
[20210613104232730.png]: /images/20221005/a0239b8586a74543b37fdec8107ccdd9.png
[img-RP9XU6bl-1623549086001_assets_1574768107180.png]: /images/20221005/60ea30874b1e4b8a9fb55d4400d5d58f.png
[20210613104818518.png]: /images/20221005/3d8589139fc84274a6fd31f3f9944ceb.png
[img-1R7OJtIz-1623549086003_assets_IDEA_Tomcat1.png]: /images/20221005/2431a62f0dc04ef59f67e7d7ec01f719.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 3]: /images/20221005/887c18c304944696adcb0a5bd82af506.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 4]: /images/20221005/25153c425eee42fcabe78d02b4b325b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 5]: /images/20221005/ecacdc7141ec4d91a79b142e344d1da4.png
[JavaEE8]: https://www.oracle.com/technetwork/java/javaee/documentation/ee8-release-notes-3894362.html
[API]: https://javaee.github.io/javaee-spec/javadocs/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 6]: /images/20221005/24e959138ee94a7482fdd02b46e8f4eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 7]: /images/20221005/9e2871da9ca84a48b1acda6a421fc2c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 8]: /images/20221005/323ebdef8daf4254bf7ba5c0b558a824.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 9]: /images/20221005/0604cc25525a4d6c97757152695c7d57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 10]: /images/20221005/a407e0acb89042308136b5b9b1bf3f63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 11]: /images/20221005/38da819e2425466fb33a55446c31a283.png
[https_yangyongli.blog.csdn.net_article_details_117871787]: https://yangyongli.blog.csdn.net/article/details/117871787
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 12]: /images/20221005/1318ab30b0e947abb9fd70b03d5a2c15.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 13]: /images/20221005/9dcd60fc4642474cb0548ccb02dc78d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 14]: /images/20221005/efe3adcad43341029ad086bb14b5bee7.png
[http_localhost_8585_servlet_demo_servletDemo5]: http://localhost:8585/servlet_demo/servletDemo5
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 15]: /images/20221005/7af1324c4cfa4bef9711999cb16bf389.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 16]: /images/20221005/e0c887e1206945ec9f055580eead28ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 17]: /images/20221005/c3df848f49bc4c988899d8ed9f6be882.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 18]: /images/20221005/ec4b0f3cc9104f7a928cf9c1b8c24275.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 19]: /images/20221005/38997bdab91a478bb0adf0b0021b8c36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 20]: /images/20221005/b5df256057c94f47b593d8a3c98e87c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 21]: /images/20221005/14ae6edd9b6f4f6282ef3eb104e2b23d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 22]: /images/20221005/f19e83d14bb54add8258f65976456c8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 23]: /images/20221005/101fdbe604984d85a7ff67fdf6234f14.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/0941410aed4b4194a6cc7c38d4cdae63.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 24]: /images/20221005/bd41b5327688433e940a638c6bb9c6bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 25]: /images/20221005/ac4123efda5347f58ec32357100f84ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 26]: /images/20221005/a99b8ea9f9b94381b1e784aac6ea1ef1.png
[https_yangyongli.blog.csdn.net_article_details_117877830]: https://yangyongli.blog.csdn.net/article/details/117877830
[https_yangyongli.blog.csdn.net_article_details_117878306]: https://yangyongli.blog.csdn.net/article/details/117878306
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 27]: /images/20221005/94ef99b626024ddab10e66a173b51414.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 28]: /images/20221005/265b30f76a47400b9b4b9da2466d2200.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 29]: /images/20221005/34c58a3bd56f48908558e62d88dc9131.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 30]: /images/20221005/f3f45c9471f744618ffe6d3129c95c82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 31]: /images/20221005/2c875b03606b4d459505417725fcd53b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 32]: /images/20221005/f871bd17d40243fea14c0a29eecf6db3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 33]: /images/20221005/5dc0def6e2d14a0f831c62feee3d16ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 34]: /images/20221005/06ee4dfd92624c659cac0ea51a1de8a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 35]: /images/20221005/81832cadc12042479a14318d2a191f39.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 36]: /images/20221005/05615bcea1ef4bfd860e2595985b9018.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 37]: /images/20221005/28d4e8768a2844e891964826e8d37451.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 38]: /images/20221005/cf34a64aea904398987bcb4894025349.png
[https_yangyongli.blog.csdn.net_article_details_117880162]: https://yangyongli.blog.csdn.net/article/details/117880162
[https_yangyongli.blog.csdn.net_article_details_117880598]: https://yangyongli.blog.csdn.net/article/details/117880598
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 39]: /images/20221005/e05552bea4f54c39a5a4155264b669be.png
[https_yangyongli.blog.csdn.net_article_details_117912761]: https://yangyongli.blog.csdn.net/article/details/117912761
[https_yangyongli.blog.csdn.net_article_details_117914643]: https://yangyongli.blog.csdn.net/article/details/117914643
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 40]: /images/20221005/c1037b10445e42d1a8f498bb46fe0522.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 41]: /images/20221005/c18d018dbda84d5b80cb4922da51e3f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 42]: /images/20221005/63ef5ea7510d490290b7c9503a97df41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 43]: /images/20221005/f9c2de3fcc46497899ccc91262332761.png
[img-QFbZEkVG-1623675513407_assets_jsp_.png]: /images/20221005/4eb0dc16afe749cbae65754a3d06d0e5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 44]: /images/20221005/236d5a7c472543c597ea2a9162e71d15.png
[img-bNF3bYO5-1623675513409_assets_1.png]: /images/20221005/ec1c6df5d6594cfb98d4536725d0b78b.png
[img-sNEL9jBx-1623675513411_assets_2.png]: /images/20221005/faa86d8c7df34b138713f848fb7f42a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 45]: /images/20221005/8b01a95af4144ea5a99a367c427e03d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 46]: /images/20221005/7838dbe77c464db1bd7ec9217d925b2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 47]: /images/20221005/580b78ac8ca645ca864e08061c136470.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 48]: /images/20221005/a704e16b243a46aba35442ebab273923.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 49]: /images/20221005/e593d77d14d74e5e9cb608d85712127a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 50]: /images/20221005/7ab635fccf584b2ba2fee9f47c7145a9.png