JavaWeb：Request&Response的概述

素颜马尾好姑娘i 2024-03-30 13:36 68阅读 0赞

## 1，`Request`和`Response`的概述 ##

`Request`是请求对象，`Response`是响应对象。 这两个对象在我们使用`Servlet`的时候有看到：![在这里插入图片描述][89c674ff62604686bfb478ba7b32c08e.png_pic_center]

此时，我们就需要思考一个问题`request`和`response`这两个参数的作用是什么？

![在这里插入图片描述][7d7f949fd85044bca167bb8aac06fe3d.png_pic_center]

*  `request`：获取请求数据
    
     *  浏览器会发送`HTTP`请求到后台服务器`Tomcat`；
     *  `HTTP`的请求中会包含很多请求数据\[请求行+请求头+请求体\]；
     *  后台服务器`Tomcat`会对`HTTP`请求中的数据进行解析并把解析结果存入到一个对象中；
     *  所存入的对象即为`request`对象，所以我们可以从`request`对象中获取请求的相关参数；
     *  获取到数据后就可以继续后续的业务，比如获取用户名和密码就可以实现登录操作的相关业务。
 *  `response`：设置响应数据
    
     *  业务处理完后，后台就需要给前端返回业务处理的结果即响应数据；
     *  把响应数据封装到`response`对象中；
     *  后台服务器`Tomcat`会解析`response`对象，按照\[响应行+响应头+响应体\]格式拼接结果；
     *  浏览器最终解析结果，把内容展示在浏览器给用户浏览。

对于上述所讲的内容，我们通过一个案例来初步体验下`request`和`response`对象的使用。

启动成功后就可以通过浏览器来访问，并且根据传入参数的不同就可以在页面上展示不同的内容：

![在这里插入图片描述][5673f2abaaaf492082b6e1d5f2c45551.png_pic_center]

**小结**

在这节中，我们主要认识了下`request`对象和`reponse`对象：

*  `request`对象是用来封装请求数据的对象
 *  `response`对象是用来封装响应数据的对象

目前我们只知道这两个对象是用来干什么的，那么它们具体是如何实现的，就需要我们继续深入的介绍。接下来，就先从`Request`对象来介绍，主要介绍下面这些内容：

*  `request`继承体系
 *  `request`获取请求参数
 *  `request`请求转发

## 2，`Request`对象 ##

### 2.1 `Request`继承体系 ###

在介绍内容之前，我们先思考一个问题，前面在介绍`Request`和`Reponse`对象的时候，可能已经发现：

*  当我们的`Servlet`类实现的是`Servlet`接口的时候，`service`方法中的参数是`ServletRequest`和`ServletResponse`；
 *  当我们的`Servlet`类继承的是`HttpServlet`类的时候，`doGet`和`doPost`方法中的参数就变成`HttpServletRequest`和`HttpServletReponse`。

那么，

*  `ServletRequest`和`HttpServletRequest`的关系是什么？
 *  `request`对象是有谁来创建的？
 *  `request`提供了哪些`API`，这些`API`从哪里查？

首先，我们先来看下`Request`的继承体系：

![在这里插入图片描述][f01b2c5eeff44cb890230c1357b907f2.png_pic_center]

从上图中可以看出，`ServletRequest`和`HttpServletRequest`都是`Java`提供的，所以我们可以打开`JavaEE`提供的`API`文档，打开后可以看到：

![在这里插入图片描述][7331dd0a314944f781c1ab371a6ac9bb.png_pic_center]

所以`ServletRequest`和`HttpServletRequest`是继承关系，并且两个都是接口，接口是无法创建对象，这个时候就引发了下面这个问题：

![在这里插入图片描述][14252975f34c4765b5aed6130f13b058.png_pic_center]

这个时候，我们就需要用到`Request`继承体系中的`RequestFacade`：

*  该类实现了`HttpServletRequest`接口，也间接实现了`ServletRequest`接口。
 *  `Servlet`类中的`service`方法、`doGet`方法或者是`doPost`方法最终都是由`Web`服务器`Tomcat`来调用的，所以`Tomcat`提供了方法参数接口的具体实现类，并完成了对象的创建。
 *  要想了解`RequestFacade`中都提供了哪些方法，我们可以直接查看`JavaEE`的`API`文档中关于`ServletRequest`和`HttpServletRequest`的接口文档，因为`RequestFacade`实现了其接口就需要重写接口中的方法。

对于上述结论，要想验证，可以编写一个`Servlet`，在方法中把`request`对象打印下，就能看到最终的对象是不是`RequestFacade`，代码如下：

启动服务器，运行访问`http://localhost:8080/request-demo/demo2`,得到运行结果：

![在这里插入图片描述][6eb0967adf554c6a8d0143376785102d.png_pic_center]

**小结**

*  `Request`的继承体系为`ServletRequest-->HttpServletRequest-->RequestFacade`
 *  `Tomcat`需要解析请求数据，封装为`request`对象,并且创建`request`对象传递到`service`方法
 *  使用`request`对象，可以查阅`JavaEE API`文档的`HttpServletRequest`接口中方法说明

### 2.2 `Request`获取请求数据 ###

`HTTP`请求数据总共分为三部分内容，分别是 请求行、请求头、请求体 ，对于这三部分内容的数据，分别该如何获取，首先我们先来学习请求行数据如何获取？

#### 2.2.1 获取请求行数据 ####

请求行包含三块内容，分别是`请求方式`、`请求资源路径`、`HTTP协议及版本`

![在这里插入图片描述][67f63e4c9a704692b4100dd9f5f0781e.png_pic_center]

对于这三部分内容，`request`对象都提供了对应的`API`方法来获取，具体如下：

*  获取请求方式： `GET`

String getMethod()

*  获取虚拟目录(项目访问路径)： `/request-demo`

String getContextPath()

*  获取URL(统一资源定位符)： `http://localhost:8080/request-demo/req1`

StringBuffer getRequestURL()

*  获取URI(统一资源标识符)： `/request-demo/req1`

String getRequestURI()

*  获取请求参数(GET方式)： `username=zhangsan&password=123`

String getQueryString()

介绍完上述方法后，咱们通过代码把上述方法都使用下：

package com.dcxuexi.web.request;
    
    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;
    
    /***
     * @Title RequestDemo1
     * @Description TOTD request 获取请求数据
     * @Auter DongChuang
     * @Date 2022/12/31 17:25
     * @Version 1.0.0
     */
    @WebServlet("/req1")
    public class RequestDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            // String getMethod()：获取请求方式： GET
            String method = req.getMethod();
            System.out.println("method = " + method);
            // String getContextPath()：获取虚拟目录(项目访问路径)：/request-demo
            String contextPath = req.getContextPath();
            System.out.println("contextPath = " + contextPath);
            // StringBuffer getRequestURL(): 获取URL(统一资源定位符)：http://localhost:8080/request-demo/req1
            StringBuffer requestURL = req.getRequestURL();
            System.out.println("requestURL = " + requestURL.toString());
            // String getRequestURI()：获取URI(统一资源标识符)： /request-demo/req1
            String requestURI = req.getRequestURI();
            System.out.println("requestURI = " + requestURI);
            // String getQueryString()：获取请求参数（GET方式）： username=zhangsan
            String queryString = req.getQueryString();
            System.out.println("queryString = " + queryString);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            System.out.println("RequestDemo1 doPost ...... ");
            this.doGet(req,resp);
        }
    }

启动服务器，访问`http://localhost:8080/request-demo/req1?username=zhangsan&passwrod=123`，获取的结果如下：

![在这里插入图片描述][59b3eeb3e078467aabb4f19f02f550d1.png_pic_center]

#### 2.2.2 获取请求头数据 ####

对于请求头的数据，格式为`key: value`如下：

![在这里插入图片描述][7a267ca6912541239469773e4115165f.png_pic_center]

所以根据请求头名称获取对应值的方法为：

String getHeader(String name)

接下来，在代码中如果想要获取客户端浏览器的版本信息，则可以使用

package com.dcxuexi.web.request;
    
    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;
    
    /***
     * @Title RequestDemo1
     * @Description TOTD request 获取请求数据
     * @Auter DongChuang
     * @Date 2022/12/31 17:25
     * @Version 1.0.0
     */
    @WebServlet("/req1")
    public class RequestDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            // String getMethod()：获取请求方式： GET
            String method = req.getMethod();
            System.out.println("method = " + method);
            // String getContextPath()：获取虚拟目录(项目访问路径)：/request-demo
            String contextPath = req.getContextPath();
            System.out.println("contextPath = " + contextPath);
            // StringBuffer getRequestURL(): 获取URL(统一资源定位符)：http://localhost:8080/request-demo/req1
            StringBuffer requestURL = req.getRequestURL();
            System.out.println("requestURL = " + requestURL.toString());
            // String getRequestURI()：获取URI(统一资源标识符)： /request-demo/req1
            String requestURI = req.getRequestURI();
            System.out.println("requestURI = " + requestURI);
            // String getQueryString()：获取请求参数（GET方式）： username=zhangsan
            String queryString = req.getQueryString();
            System.out.println("queryString = " + queryString);
    
            //获取请求头: user-agent: 浏览器的版本信息
            String header = req.getHeader("user-agent");
            System.out.println("header = " + header);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            System.out.println("RequestDemo1 doPost ...... ");
            this.doGet(req,resp);
        }
    }

重新启动服务器后，`http://localhost:8080/request-demo/req1?username=zhangsan&passwrod=123`，获取的结果如下：

![在这里插入图片描述][49e04998ff1340e58e3806b57265fc5e.png_pic_center]

#### 2.2.3 获取请求体数据 ####

浏览器在发送`GET`请求的时候是没有请求体的，所以需要把请求方式变更为`POST`，请求体中的数据格式如下：

![在这里插入图片描述][c44d1d441f294f6f9f8cd6c45ebeba69.png_pic_center]

对于请求体中的数据，`Request`对象提供了如下两种方式来获取其中的数据，分别是：

*  获取字节输入流，如果前端发送的是字节数据，比如传递的是文件数据，则使用该方法

ServletInputStream getInputStream()
    该方法可以获取字节

*  获取字符输入流，如果前端发送的是纯文本数据，则使用该方法

BufferedReader getReader()

接下来，大家需要思考，要想获取到请求体的内容该如何实现？

> 具体实现的步骤如下：
> 
> 1.准备一个页面，在页面中添加`form`表单，用来发送`post`请求
> 
> 2.在`Servlet`的`doPost`方法中获取请求体数据
> 
> 3.在`doPost`方法中使用`request`的`getReader()`或者`getInputStream()`来获取
> 
> 4.访问测试

1.  在项目的`webapp`目录下添加一个`html`页面，名称为：`req.html`

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

1.  在`Servlet`的`doPost`方法中获取数据

1.  调用`getReader()`或者`getInputStream()`方法，因为目前前端传递的是纯文本数据，所以我们采用`getReader()`方法来获取

/**
     * request 获取请求数据
     */
    @WebServlet("/req1")
    public class RequestDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
        }
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
             //获取post 请求体：请求参数
            //1. 获取字符输入流
            BufferedReader br = req.getReader();
            //2. 读取数据
            String line = br.readLine();
            System.out.println(line);
        }
    }

注意

`BufferedReader`流是通过`request`对象来获取的，当请求完成后`request`对象就会被销毁，`request`对象被销毁后，`BufferedReader`流就会自动关闭，所以此处就不需要手动关闭流了。

1.  启动服务器，通过浏览器访问`http://localhost:8080/request-demo/req.html`

![在这里插入图片描述][91f4899a6f7640189085df3f09002458.png_pic_center]

点击`提交`按钮后，就可以在控制台看到前端所发送的请求数据

![在这里插入图片描述][d0e0ed5243134106bea66cfa6b55ba32.png_pic_center]

**小结**

`HTTP`请求数据中包含了`请求行`、`请求头`和`请求体`，针对这三部分内容，`Request`对象都提供了对应的`API`方法来获取对应的值：

*  请求行
    
     *  `getMethod()`获取请求方式
     *  `getContextPath()`获取项目访问路径
     *  `getRequestURL()`获取请求`URL`
     *  `getRequestURI()`获取请求`URI`
     *  `getQueryString()`获取`GET`请求方式的请求参数
 *  请求头
    
     *  `getHeader(String name)`根据请求头名称获取其对应的值
 *  请求体
    
     *  注意： 浏览器发送的`POST`请求才有请求体
     *  如果是纯文本数据：`getReader()`
     *  如果是字节数据如文件数据：`getInputStream()`

#### 2.2.4 获取请求参数的通用方式 ####

在介绍下面内容之前，我们先提出两个问题：

*  什么是请求参数？
 *  请求参数和请求数据的关系是什么？

1.什么是请求参数？

为了能更好的回答上述两个问题，我们拿用户登录的例子来说明

1.1 想要登录网址，需要进入登录页面

1.2 在登录页面输入用户名和密码

1.3 将用户名和密码提交到后台

1.4 后台校验用户名和密码是否正确

1.5 如果正确，则正常登录，如果不正确，则提示用户名或密码错误

上述例子中，用户名和密码其实就是我们所说的请求参数。

2.什么是请求数据？

请求数据则是包含请求行、请求头和请求体的所有数据

3.请求参数和请求数据的关系是什么？

3.1 请求参数是请求数据中的部分内容

3.2 如果是`GET`请求，请求参数在请求行中

3.3 如果是`POST`请求，请求参数一般在请求体中

对于请求参数的获取，常用的有以下两种：

*  `GET`方式：

String getQueryString()

*  `POST`方式：

BufferedReader getReader();

有了上述的知识储备，我们来实现一个案例需求：

（1）发送一个`GET`请求并携带用户名，后台接收后打印到控制台

（2）发送一个`POST`请求并携带用户名，后台接收后打印到控制台

此处大家需要注意的是`GET`请求和`POST`请求接收参数的方式不一样，具体实现的代码如下：

*  对于上述的代码，会存在什么问题呢？

![在这里插入图片描述][cccf8a93ae1e4a8fbed4730c2f5a1f84.png_pic_center]

*  如何解决上述重复代码的问题呢？

![在这里插入图片描述][51ea729d3f5d488c9d28f82ae89654ae.png_pic_center]

当然，也可以在`doGet`中调用`oPost`，在`doPost`中完成参数的获取和打印,另外需要注意的是，`doGet`和`doPost`方法都必须存在，不能删除任意一个。

`GET`请求和`POST`请求获取请求参数的方式不一样，在获取请求参数这块该如何实现呢？

要想实现，我们就需要思考 ：

`GET`请求方式和`POST`请求方式区别主要在于获取请求参数的方式不一样，是否可以提供一种 统一 获取请求参数的方式，从而 统一 `doGet`和`doPost`方法内的代码？

##### 解决方案一： #####

使用`request`的`getMethod()`来获取请求方式，根据请求方式的不同分别获取请求参数值，这样就可以解决上述问题，但是以后每个`Servlet`都需要这样写代码，实现起来比较麻烦，这种方案我们不采用

##### 解决方案二： #####

`request`对象已经将上述获取请求参数的方法进行了封装，并且`request`提供的方法实现的功能更强大，以后只需要调用`request`提供的方法即可，在`request`的方法中都实现了哪些操作？

(1)根据不同的请求方式获取请求参数，获取的内容如下：

![在这里插入图片描述][a6f0b1c6dcac47a29e19165286e4634b.png_pic_center]

(2)把获取到的内容进行分割，内容如下：

![在这里插入图片描述][c287852700384eeea3b1e20a8f0f6c13.png_pic_center]

(3)把分割后端数据，存入到一个`Map`集合中：

![在这里插入图片描述][25a9a647cd644798959ffb4931737764.png_pic_center]

**注意**：因为参数的值可能是一个，也可能有多个，所以`Map`的值的类型为`String`数组。

基于上述理论，`request`对象为我们提供了如下方法：

*  获取所有参数`Map`集合

Map<String,String[]> getParameterMap()

*  根据名称获取参数值（数组）

String[] getParameterValues(String name)

*  根据名称获取参数值(单个值)

String getParameter(String name)

接下来，我们通过案例来把上述的三个方法进行实例演示：

1.修改`req.html`页面，添加爱好选项，爱好可以同时选多个

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    
    <form method="get" action="/request_demo/req2">
        <input type="text" name="username" /> <br>
        <input type="password" name="password" /> <br>
        <input type="checkbox" name="hobby" value="1"> 游泳
        <input type="checkbox" name="hobby" value="2"> 爬山 <br>
        <input type="submit">
    </form>
    
    </body>
    </html>

![在这里插入图片描述][b70e3b2bdf57474b8a9bfacf3205e1a8.png_pic_center]

2.在`Servlet`代码中获取页面传递`GET`请求的参数值

2.1获取`GET`方式的所有请求参数

package com.dcxuexi.web.request;
    
    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;
    import java.util.Map;
    
    /***
     * @Title RequestDemo2
     * @Description TOTD request 通用方式获取请求参数
     * @Auter DongChuang
     * @Date 2022/12/31 18:12
     * @Version 1.0.0
     */
    @WebServlet("/req2")
    public class RequestDemo2 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            //GET请求逻辑
            System.out.println("RequestDemo2 doGet ...... ");
            //1. 获取所有参数的Map集合
            Map<String, String[]> parameterMap = req.getParameterMap();
            for (String key: parameterMap.keySet()
                 ) {
        
                // username:zhangsan
                System.out.print(key+":");
    
                //获取值
                String[] str = parameterMap.get(key);
                for (String value: str
                     ) {
        
                    System.out.print(value + " ");
                }
                System.out.println();
            }
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            System.out.println("RequestDemo2 doPost ...... ");
        }
    }

获取的结果为：

![在这里插入图片描述][64cb3493eb7a4bfeb66985fd2224aa29.png_pic_center]

2.2获取`GET`请求参数中的爱好，结果是数组值

获取的结果为：

![在这里插入图片描述][07f33dcde46a46d0b60e85c9d1b6a8a9.png_pic_center]

2.3获取`GET`请求参数中的用户名和密码，结果是单个值

获取的结果为：

![在这里插入图片描述][ff53ae0e7a984c9983ce9896da7b3f50.png_pic_center]

3.在`Servlet`代码中获取页面传递`POST`请求的参数值

3.1将`req.html`页面`form`表单的提交方式改成`post`

3.2将`doGet`方法中的内容复制到`doPost`方法中即可

**小结**

*  `req.getParameter()`方法使用的频率会比较高
 *  以后我们再写代码的时候，就只需要按照如下格式来编写：

public class RequestDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
           //采用request提供的获取请求参数的通用方式来获取请求参数
           //编写其他的业务代码...
        }
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req,resp);
        }
    }

### 2.3 `IDEA`快速创建`Servlet` ###

使用通用方式获取请求参数后，屏蔽了`GET`和`POST`的请求方式代码的不同，则代码可以定义如下格式：

![在这里插入图片描述][33f60bfd938e480a860bf2a7f976ef93.png_pic_center]

由于格式固定，所以我们可以使用`IDEA`提供的模板来制作一个`Servlet`的模板，这样我们后期在创建`Servlet`的时候就会更高效，具体如何实现：

(1)按照自己的需求，修改`Servlet`创建的模板内容

![在这里插入图片描述][9bf2cb0f92fa41ab91b14ee3fa0d7078.png_pic_center]

（2）使用`servlet`模板创建`Servlet`类

![在这里插入图片描述][cd92c8ff77a24af69102df65f2e47e9a.png_pic_center]

![在这里插入图片描述][1e1f6cc84fea4aea8744ff0e28ddebbc.png_pic_center]

### 2.4 请求参数中文乱码问题 ###

问题展示：

(1)将`req.html`页面的请求方式修改为`get`

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    
    <form method="get" action="/request_demo/req4">
        <input type="text" name="username" /> <br>
        <input type="password" name="password" /> <br>
        <input type="checkbox" name="hobby" value="1"> 游泳
        <input type="checkbox" name="hobby" value="2"> 爬山 <br>
        <input type="submit">
    </form>
    
    </body>
    </html>

(2)在`Servlet`方法中获取参数，并打印

（3）启动服务器，页面上输入中文参数

![在这里插入图片描述][f5d2addbe3964b6cb4580f231bb704bf.png_pic_center]

（4）查看控制台打印内容

![在这里插入图片描述][47c207d2b2d9430d8cb022a6a6614d75.png_pic_center]

（5）把`req.html`页面的请求方式改成`post`，再次发送请求和中文参数

![在这里插入图片描述][f45405f7d7674f3697ea96cf4bfbe972.png_pic_center]

（6）查看控制台打印内容，依然为乱码

![在这里插入图片描述][0b233fb1efb34c5c9a8cdc08e98162d3.png_pic_center]

通过上面的案例，会发现，不管是`GET`还是`POST`请求，在发送的请求参数中如果有中文，在后台接收的时候，都会出现中文乱码的问题。具体该如何解决呢？

#### 2.4.1 POST请求解决方案 ####

*  分析出现中文乱码的原因：
    
     *  `POST`的请求参数是通过`request`的`getReader()`来获取流中的数据
     *  `TOMCAT`在获取流的时候采用的编码是`ISO-8859-1`
     *  `ISO-8859-1`编码是不支持中文的，所以会出现乱码
 *  解决方案：
    
     *  页面设置的编码格式为`UTF-8`
     *  把`TOMCAT`在获取流数据之前的编码设置为`UTF-8`
     *  通过`request.setCharacterEncoding("UTF-8")`设置编码，`UTF-8`也可以写成小写

修改后的代码为：

重新发送`POST`请求，就会在控制台看到正常展示的中文结果。

至此`POST`请求中文乱码的问题就已经解决，但是这种方案不适用于`GET`请求，这个原因是什么呢，咱们下面再分析。

#### 2.4.2 GET请求解决方案 ####

刚才提到一个问题是`POST请求的中文乱码解决方案为什么不适用GET请求？`

*  `GET`请求获取请求参数的方式是`request.getQueryString()`
 *  `POST`请求获取请求参数的方式是`request.getReader()`
 *  `request.setCharacterEncoding("utf-8")`是设置`request`处理流的编码
 *  `getQueryString`方法并没有通过流的方式获取数据

所以`GET`请求不能用设置编码的方式来解决中文乱码问题，那问题又来了，如何解决`GET`请求的中文乱码呢？

1.  首先我们需要先分析下`GET`请求出现乱码的原因：

![在这里插入图片描述][05c6e464737d4375a97edf84c6fbbcc1.png_pic_center]

(1)浏览器通过`HTTP`协议发送请求和数据给后台服务器（`Tomcat`）

(2)浏览器在发送`HTTP`的过程中会对中文数据进行`URL` 编码

(3)在进行`URL`编码的时候会采用页面`<meta>`标签指定的`UTF-8`的方式进行编码，`张三`编码后的结果为`%E5%BC%A0%E4%B8%89`

(4)后台服务器（`Tomcat`）接收到`%E5%BC%A0%E4%B8%89`后会默认按照`ISO-8859-1`进行`URL` 解码

(5)由于前后编码与解码采用的格式不一样，就会导致后台获取到的数据为乱码。

思考：如果把`req.html`页面的`<meta>`标签的`charset`属性改成`ISO-8859-1`,后台不做操作，能解决中文乱码问题么？

答案是否定的，因为`ISO-8859-1`本身是不支持中文展示的，所以改了标签的`charset`属性后，会导致页面上的中文内容都无法正常展示。

分析完上面的问题后，我们会发现，其中有两个我们不熟悉的内容就是 `URL`编码 和 `URL`解码 ，什么是`URL`编码，什么又是`URL`解码呢？

##### **`URL`编码** #####

这块知识我们只需要了解下即可，具体编码过程分两步，分别是：

(1)将字符串按照编码方式转为二进制

(2)每个字节转为2个16进制数并在前边加上`%`

`张三`按照`UTF-8`的方式转换成二进制的结果为：

1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001

这个结果是如何计算的？

使用`http://www.mytju.com/classcode/tools/encode_utf8.asp`，输入`张三`

![在这里插入图片描述][5ac691c20f2b4077814c3eae753c0f82.png_pic_center]

就可以获取张和三分别对应的10进制，然后在使用计算器，选择程序员模式，计算出对应的二进制数据结果：

![在这里插入图片描述][c82ab83360b14d5598cf86200ebbeeb5.png_pic_center]

在计算的十六进制结果中，每两位前面加一个%,就可以获取到`%E5%BC%A0%E4%B8%89`。

当然你从上面所提供的网站中就已经能看到编码16进制的结果了：

![在这里插入图片描述][3d3b43917cc5460cb8fdc8cdacb13801.png_pic_center]

但是对于上面的计算过程，如果没有工具，纯手工计算的话，相对来说还是比较复杂的，我们也不需要进行手动计算，在`Java`中已经为我们提供了编码和解码的`API`工具类可以让我们更快速的进行编码和解码：

编码：

java.net.URLEncoder.encode("需要被编码的内容","字符集(UTF-8)")

解码：

java.net.URLDecoder.decode("需要被解码的内容","字符集(UTF-8)")

接下来咱们对`张三`来进行编码和解码

![在这里插入图片描述][a38d995a56054a948532a3ffecb4ed18.png_pic_center]

到这，我们就可以分析出`GET`请求中文参数出现乱码的原因了，

*  浏览器把中文参数按照`UTF-8`进行`URL`编码
 *  `Tomcat`对获取到的内容进行了`ISO-8859-1`的URL解码
 *  在控制台就会出现类上`å¼ ä¸‰`的乱码，最后一位是个空格

1.  清楚了出现乱码的原因，接下来我们就需要想办法进行解决

![在这里插入图片描述][787dfcafd95d4608bd15e6bdf8d73dfa.png_pic_center]

从上图可以看住，

*  在进行编码和解码的时候，不管使用的是哪个字符集，他们对应的`%E5%BC%A0%E4%B8%89`是一致的
 *  那他们对应的二进制值也是一样的，为：
    
     *      1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001
 *  为所以我们可以考虑把`å¼ ä¸‰`转换成字节，在把字节转换成`张三`，在转换的过程中是它们的编码一致，就可以解决中文乱码问题。

具体的实现步骤为：

> 1.按照`ISO-8859-1`编码获取乱码`å¼ ä¸‰`对应的字节数组
> 
> 2.按照`UTF-8`编码获取字节数组对应的字符串

实现代码如下：

package com.dcxuexi.web.request;
    
    import java.io.UnsupportedEncodingException;
    import java.net.URLDecoder;
    import java.net.URLEncoder;
    
    /***
     * @Title URLDemo
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2023/1/1 11:44
     * @Version 1.0.0
     */
    public class URLDemo {
        
        public static void main(String[] args) throws UnsupportedEncodingException {
        
            String username = "张三";
            //1. URL编码
            String encode = URLEncoder.encode(username, "utf-8");
            System.out.println("encode = " + encode); // 打印:%E5%BC%A0%E4%B8%89
    
            //2. URL解码
            String decode = URLDecoder.decode(encode, "utf-8"); // 打印: 张三
            String decode2 = URLDecoder.decode(encode, "ISO-8859-1"); // 打印: å¼ ä¸‰
            System.out.println("decode = " + decode);
            System.out.println("decode2 = " + decode2);
    
            //3. 转换为字节数据,编码
            byte[] bytes = decode2.getBytes("ISO-8859-1");
            for (byte b : bytes) {
        
                System.out.print(b + " ");
            }
            //此处打印的是:-27 -68 -96 -28 -72 -119
            //4. 将字节数组转为字符串，解码
            String s = new String(bytes, "utf-8");
            System.out.println("s = " + s);
        }
    }

![在这里插入图片描述][c96b837d0b444980ac864d248ce5919a.png_pic_center]

**说明**：在第18行中打印的数据是`-27 -68 -96 -28 -72 -119`和`张三`转换成的二进制数据`1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001`为什么不一样呢？

其实打印出来的是十进制数据，我们只需要使用计算机换算下就能得到他们的对应关系，如下图：

![在这里插入图片描述][849429f9170a4fd7995cc1b05c951fa9.png_pic_center]

至此对于`GET`请求中文乱码的解决方案，我们就已经分析完了，最后在代码中去实现下：

package com.dcxuexi.web.request;
    
    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;
    import java.nio.charset.StandardCharsets;
    
    /***
     * @Title RequestDemo4
     * @Description TOTD 中文乱码问题解决方案
     * @Auter DongChuang
     * @Date 2023/1/1 11:07
     * @Version 1.0.0
     */
    @WebServlet(urlPatterns = "/req4")
    public class RequestDemo4  extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            //1. 解决乱码: POST getReader()
            //设置字符输入流的编码，设置的字符集要和页面保持一致
            //req.setCharacterEncoding("UTF-8");
            //2. 获取username
            String username = req.getParameter("username");
            System.out.println("解决乱码前 username = " + username);
    
            //3. GET,获取参数的方式：getQueryString
            // 乱码原因：tomcat进行URL解码，默认的字符集ISO-8859-1
            //3.1 先对乱码数据进行编码：转为字节数组
            //byte[] bytes = username.getBytes(StandardCharsets.ISO_8859_1);
            //3.2 字节数组解码
            //username = new String(bytes, StandardCharsets.UTF_8);
    
            username  = new String(username.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8);
            System.out.println("解决乱码后 username = "+username);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

**注意**

*  把`request.setCharacterEncoding("UTF-8")`代码注释掉后，会发现GET请求参数乱码解决方案同时也可也把`POST`请求参数乱码的问题也解决了
 *  只不过对于`POST`请求参数一般都会比较多，采用这种方式解决乱码起来比较麻烦，所以对于`POST`请求还是建议使用设置编码的方式进行。

另外需要说明一点的是==`Tomcat8.0`之后，已将`GET`请求乱码问题解决，设置默认的解码方式为`UTF-8`==

**小结**

1.  中文乱码解决方案

*  `POST`请求和`GET`请求的参数中如果有中文，后台接收数据就会出现中文乱码问题
    
    `GET`请求在`Tomcat8.0`以后的版本就不会出现了
 *  `POST`请求解决方案是：设置输入流的编码
    
        request.setCharacterEncoding("UTF-8");
        注意:设置的字符集要和页面保持一致
 *  通用方式（`GET/POST`）：需要先解码，再编码
    
        new String(username.getBytes("ISO-8859-1"),"UTF-8");

1.  `URL`编码实现方式：

*  编码：
    
        URLEncoder.encode(str,"UTF-8");
 *  解码：
    
        URLDecoder.decode(s,"ISO-8859-1");

### 2.5 `Request`请求转发 ###

1.  请求转发（`forward`）：一种在服务器内部的资源跳转方式。

![在这里插入图片描述][9e0a71c604944d0cb8a95928a76c5b3f.png_pic_center]

(1)浏览器发送请求给服务器，服务器中对应的资源A接收到请求

(2)资源A处理完请求后将请求发给资源B

(3)资源B处理完后将结果响应给浏览器

(4)请求从资源A到资源B的过程就叫 请求转发

1.  请求转发的实现方式：

req.getRequestDispatcher("资源B路径").forward(req,resp);

具体如何来使用，我们先来看下需求：

![在这里插入图片描述][75cea7756e604e55b08bd59d05c2eaaa.png_pic_center]

针对上述需求，具体的实现步骤为：

> 1.创建一个`RequestDemo5`类，接收`/req5`的请求，在`doGet`方法中打印`demo5`
> 
> 2.创建一个`RequestDemo6`类，接收`/req6`的请求，在`doGet`方法中打印`demo6`
> 
> 3.在`RequestDemo5`的方法中使用
> 
> `req.getRequestDispatcher("/req6").forward(req,resp)`进行请求转发
> 
> 4.启动测试

(1)创建`RequestDemo5`类

(2)创建`RequestDemo6`类

(3)在`RequestDemo5`的`doGet`方法中进行请求转发

(4)启动测试

访问`http://localhost:8080/request-demo/req5`，就可以在控制台看到如下内容：

![在这里插入图片描述][1b8fbdfaeb0443eeb71ae0b24231cb35.png_pic_center]

说明请求已经转发到了`/req6`

1.  请求转发资源间共享数据：使用`Request`对象

此处主要解决的问题是把请求从`/req5`转发到`/req6`的时候，如何传递数据给`/req6`。

需要使用`request`对象提供的三个方法：

*  存储数据到`request`域\[范围，数据是存储在`request`对象\]中

void setAttribute(String name,Object o);

*  根据`key`获取值

Object getAttribute(String name);

*  根据`key`删除该键值对

void removeAttribute(String name);

接着上个需求来：

![在这里插入图片描述][b7ccc5fea4d34b1f8b12ec104963665b.png_pic_center]

> 1.在`RequestDemo5`的`doGet`方法中转发请求之前，将数据存入`request`域对象中
> 
> 2.在`RequestDemo6`的`doGet`方法从`request`域对象中获取数据，并将数据打印到控制台
> 
> 3.启动访问测试

(1)修改`RequestDemo5`中的方法

(2)修改`RequestDemo6`中的方法

(3)启动测试

访问`http://localhost:8080/request-demo/req5`，就可以在控制台看到如下内容：

![在这里插入图片描述][d4559c634333435690836fcfbe893e13.png_pic_center]

此时就可以实现在转发多个资源之间共享数据。

1.  请求转发的特点

*  浏览器地址栏路径不发生变化
    
    虽然后台从`/req5`转发到`/req6`，但是浏览器的地址一直是`/req5`，未发生变化
    
    ![在这里插入图片描述][a9e09e185f8d40c18a1f1c8b12c47703.png_pic_center]
 *  只能转发到当前服务器的内部资源
    
    不能从一个服务器通过转发访问另一台服务器
 *  一次请求，可以在转发资源间使用`request`共享数据
    
    虽然后台从`/req5`转发到`/req6`，但是这个 只有一次请求

## 3，Response对象 ##

前面讲解完`Request`对象，接下来我们回到刚开始的那张图：

![在这里插入图片描述][e0984e00b8cd402195bb898b4e7550c8.png_pic_center]

*  `Request`：使用`request`对象来 获取 请求数据
 *  `Response`：使用`response`对象来 设置 响应数据

`Reponse`的继承体系和`Request`的继承体系也非常相似：

![在这里插入图片描述][fd5e0759da8449c38b10f4327ad64ac2.png_pic_center]

介绍完`Response`的相关体系结构后，接下来对于`Response`介绍如下内容：

*  `Response`设置响应数据的功能介绍
 *  `Response`完成重定向
 *  `Response`响应字符数据
 *  `Response`响应字节数据

### 3.1 `Response`设置响应数据功能介绍 ###

`HTTP`响应数据总共分为三部分内容，分别是 响应行、响应头、响应体 ，对于这三部分内容的数据，`respone`对象都提供了哪些方法来进行设置？

1.  响应行

![在这里插入图片描述][c61138e8d8be4ba2b293844cafa3c523.png_pic_center]

对于响应头，比较常用的就是设置响应状态码:

void setStatus(int sc);

1.  响应头

![在这里插入图片描述][f9a955198a8b45beb849b7f913b4ee06.png_pic_center]

设置响应头键值对：

void setHeader(String name,String value);

1.  响应体

![在这里插入图片描述][38359f9d5e9d45af89f7cd390ba169e5.png_pic_center]

对于响应体，是通过字符、字节输出流的方式往浏览器写，

获取字符输出流：

PrintWriter getWriter();

获取字节输出流：

ServletOutputStream getOutputStream();

介绍完这些方法后，后面我们会通过案例把这些方法都用一用，首先先来完成下重定向的功能开发。

### 3.2 `Respones`请求重定向 ###

1.  `Response`重定向（`redirect`）：一种资源跳转方式。

![在这里插入图片描述][e8bad1947774499aad2c6c727973048e.png_pic_center]

(1)浏览器发送请求给服务器，服务器中对应的资源A接收到请求

(2)资源A现在无法处理该请求，就会给浏览器响应一个302的状态码+`location`的一个访问资源B的路径

(3)浏览器接收到响应状态码为302就会重新发送请求到`location`对应的访问地址去访问资源B

(4)资源B接收到请求后进行处理并最终给浏览器响应结果，这整个过程就叫 重定向

1.  重定向的实现方式：

resp.setStatus(302);
    resp.setHeader("location","资源B的访问路径");

具体如何来使用，我们先来看下需求：

![在这里插入图片描述][1c9acb70ba744ee294d5049a747591d9.png_pic_center]

针对上述需求，具体的实现步骤为:

> 1.创建一个`ResponseDemo1`类，接收`/resp1`的请求，在`doGet`方法中打印`resp1....`
> 
> 2.创建一个`ResponseDemo2`类，接收`/resp2`的请求，在`doGet`方法中打印`resp2....`
> 
> 3.在`ResponseDemo1`的方法中使用
> 
> `response.setStatus(302);`
> 
> `response.setHeader("Location","/request-demo/resp2")`来给前端响应结果数据
> 
> 4.启动测试

(1)创建`ResponseDemo1`类

package com.dcxuexi.web.response;
    
    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;
    
    /***
     * @Title ResponseDemo1
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2023/1/1 13:54
     * @Version 1.0.0
     */
    @WebServlet("/resp1")
    public class ResponseDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            System.out.println("resp1....");
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

(2)创建`ResponseDemo2`类

package com.dcxuexi.web.response;
    
    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;
    
    /***
     * @Title ResponseDemo2
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2023/1/1 13:55
     * @Version 1.0.0
     */
    @WebServlet("/resp2")
    public class ResponseDemo2  extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            System.out.println("resp2....");
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

(3)在`ResponseDemo1`的`doGet`方法中给前端响应数据

package com.dcxuexi.web.response;
    
    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;
    
    /***
     * @Title ResponseDemo1
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2023/1/1 13:54
     * @Version 1.0.0
     */
    @WebServlet("/resp1")
    public class ResponseDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            System.out.println("resp1....");
            //重定向
            //1.设置响应状态码 302
            resp.setStatus(302);
            //2. 设置响应头 Location
            resp.setHeader("Location","/request_demo/resp2");
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

(4)启动测试

访问`http://localhost:8080/request-demo/resp1`，就可以在控制台看到如下内容：

![在这里插入图片描述][bcbe3ae6034149d291329f2fdb302773.png_pic_center]

说明`/resp1`和`/resp2`都被访问到了。到这重定向就已经完成了。

虽然功能已经实现，但是从设置重定向的两行代码来看，会发现除了重定向的地址不一样，其他的内容都是一模一样，所以`request`对象给我们提供了简化的编写方式为：

resposne.sendRedirect("/request-demo/resp2")

所以第3步中的代码就可以简化为：

package com.dcxuexi.web.response;
    
    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;
    
    /***
     * @Title ResponseDemo1
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2023/1/1 13:54
     * @Version 1.0.0
     */
    @WebServlet("/resp1")
    public class ResponseDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            System.out.println("resp1....");
            //重定向
            //1.设置响应状态码 302
            //resp.setStatus(302);
            //2. 设置响应头 Location
            //resp.setHeader("Location","/request_demo/resp2");
            
            //重定向
            resp.sendRedirect("/request_demo/resp2");
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

1.  重定向的特点

*  浏览器地址栏路径发送变化
    
    当进行重定向访问的时候，由于是由浏览器发送的两次请求，所以地址会发生变化
    
    ![在这里插入图片描述][bbb769f972df45ba9dc05cdc71ee34fc.png_pic_center]
 *  可以重定向到任何位置的资源（服务内容、外部均可）
    
    因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。
 *  两次请求，不能在多个资源使用`request`共享数据
    
    因为浏览器发送了两次请求，是两个不同的`request`对象，就无法通过`request`对象进行共享数据

介绍完 请求重定向 和 请求转发 以后，接下来需要把这两个放在一块对比下：

![在这里插入图片描述][c858d5d2e760427bb4efa27ceed8abeb.png_pic_center]

以后到底用哪个，还是需要根据具体的业务来决定。

### 3.3 路径问题 ###

1.  问题1：转发的时候路径上没有加`/request-demo`而重定向加了，那么到底什么时候需要加，什么时候不需要加呢？

![在这里插入图片描述][93ac4072cab644bda6fa223897c9c548.png_pic_center]

其实判断的依据很简单，只需要记住下面的规则即可：

*  浏览器使用：需要加虚拟目录（项目访问路径）
 *  服务端使用：不需要加虚拟目录

对于转发来说，因为是在服务端进行的，所以不需要加虚拟目录

对于重定向来说，路径最终是由浏览器来发送请求，就需要添加虚拟目录。

掌握了这个规则，接下来就通过一些练习来强化下：

*  `<a href='路劲'>`
 *  `<form action='路径'>`
 *  `req.getRequestDispatcher("路径")`
 *  `resp.sendRedirect("路径")`

答案:

1.超链接，从浏览器发送，需要加
    2.表单，从浏览器发送，需要加
    3.转发，是从服务器内部跳转，不需要加
    4.重定向，是由浏览器进行跳转，需要加。

1.  问题2：在重定向的代码中，`/request-demo`是固定编码的，如果后期通过`Tomcat`插件配置了项目的访问路径，那么所有需要重定向的地方都需要重新修改，该如何优化？

![在这里插入图片描述][6f5266b79a4249f786be25a176a07c50.png_pic_center]

答案也比较简单，我们可以在代码中动态去获取项目访问的虚拟目录，具体如何获取，我们可以借助前面咱们所介绍的`request`对象中的`getContextPath()`方法，修改后的代码如下：

package com.dcxuexi.web.response;
    
    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;
    
    /***
     * @Title ResponseDemo1
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2023/1/1 13:54
     * @Version 1.0.0
     */
    @WebServlet("/resp1")
    public class ResponseDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            System.out.println("resp1....");
            //重定向
            //1.设置响应状态码 302
            //resp.setStatus(302);
            //2. 设置响应头 Location
            //resp.setHeader("Location","/request_demo/resp2");
    
            //重定向
            //简化方式完成重定向
            String contextPath = req.getContextPath();
            resp.sendRedirect(contextPath + "/resp2");
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

重新启动访问测试，功能依然能够实现，此时就可以动态获取项目访问的虚拟路径，从而降低代码的耦合度。

### 3.4 `Response`响应字符数据 ###

要想将字符数据写回到浏览器，我们需要两个步骤：

*  通过`Response`对象获取字符输出流： `PrintWriter writer = resp.getWriter();`
 *  通过字符输出流写数据： `writer.write("aaa");`

接下来，我们实现通过些案例把响应字符数据给实际应用下：

1.  返回一个简单的字符串`aaa`

package com.dcxuexi.web.response;
    
    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;
    import java.io.PrintWriter;
    
    /***
     * @Title ResponseDemo3
     * @Description TOTD 响应字符数据：设置字符数据的响应体
     * @Auter DongChuang
     * @Date 2023/1/1 14:20
     * @Version 1.0.0
     */
    @WebServlet("/resp3")
    public class ResponseDemo3 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            resp.setContentType("text/html;charset=utf-8");
            //1. 获取字符输出流
            PrintWriter writer = resp.getWriter();
            writer.write("aaa");
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

![在这里插入图片描述][1a79a8d01e24415bb2e0fe9486498178.png_pic_center]

1.  返回一串`html`字符串，并且能被浏览器解析

PrintWriter writer = resp.getWriter();
    //content-type，告诉浏览器返回的数据类型是HTML类型数据，这样浏览器才会解析HTML标签
    resp.setHeader("content-type","text/html");
    writer.write("<h1>aaa</h1>");

![在这里插入图片描述][deaa4264b50b411b9f11406a4e9407b2.png_pic_center]

注意： 一次请求响应结束后，`response`对象就会被销毁掉，所以不要手动关闭流。

1.  返回一个中文的字符串`你好`，需要注意设置响应数据的编码为`utf-8`

//设置响应的数据格式及数据的编码
    resp.setContentType("text/html;charset=utf-8");
    writer.write("你好");

![在这里插入图片描述][716175103dd7435c94166889d08290fd.png_pic_center]

### 3.5 `Response`响应字节数据 ###

要想将字节数据写回到浏览器，我们需要两个步骤：

*  通过`Response`对象获取字节输出流：`ServletOutputStream outputStream = resp.getOutputStream();`
 *  通过字节输出流写数据：`outputStream.write(字节数据);`

接下来，我们实现通过些案例把响应字符数据给实际应用下：

1.  返回一个图片文件到浏览器

package com.dcxuexi.web.response;
    
    import javax.servlet.ServletException;
    import javax.servlet.ServletOutputStream;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /***
     * @Title ResponseDemo4
     * @Description TOTD 响应字节数据：设置字节数据的响应体
     * @Auter DongChuang
     * @Date 2023/1/1 14:33
     * @Version 1.0.0
     */
    @WebServlet("/resp4")
    public class ResponseDemo4 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            //1. 读取文件
            FileInputStream fis = new FileInputStream("D:\\java\\javaCode\\Java.jpeg");
            //2. 获取response字节输出流
            ServletOutputStream outputStream = resp.getOutputStream();
            //3. 完成流的copy
            byte[] buff = new byte[1024];
            int len = 0;
            while ((len=fis.read(buff))!= -1){
        
                outputStream.write(buff,0,len);
            }
            fis.close();
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

![在这里插入图片描述][39c73b0e25954bd8bc39e0d0f088de74.png_pic_center]

上述代码中，对于流的`copy`的代码还是比较复杂的，所以我们可以使用别人提供好的方法来简化代码的开发，具体的步骤是：

(1)`pom.xml`添加依赖

<dependency>
          <groupId>commons-io</groupId>
          <artifactId>commons-io</artifactId>
          <version>2.11.0</version>
        </dependency>

(2)调用工具类方法

//fis:输入流
    //os:输出流
    IOUtils.copy(fis,os);

优化后的代码：

package com.dcxuexi.web.response;
    
    import org.apache.commons.io.IOUtils;
    
    import javax.servlet.ServletException;
    import javax.servlet.ServletOutputStream;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /***
     * @Title ResponseDemo4
     * @Description TOTD 响应字节数据：设置字节数据的响应体
     * @Auter DongChuang
     * @Date 2023/1/1 14:33
     * @Version 1.0.0
     */
    @WebServlet("/resp4")
    public class ResponseDemo4 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            //1. 读取文件
            FileInputStream fis = new FileInputStream("D:\\java\\javaCode\\Java.jpeg");
            //2. 获取response字节输出流
            ServletOutputStream outputStream = resp.getOutputStream();
            //3. 完成流的copy
    //        byte[] buff = new byte[1024];
    //        int len = 0;
    //        while ((len=fis.read(buff))!= -1){
        
    //            outputStream.write(buff,0,len);
    //        }
    //        fis.close();
            IOUtils.copy(fis,outputStream);
            fis.close();
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req, resp);
        }
    }

[89c674ff62604686bfb478ba7b32c08e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/cd3b4a870cfc4475a4fc81f49739f389.png
[7d7f949fd85044bca167bb8aac06fe3d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3beef1aae63c4532a74478a633dc7390.png
[5673f2abaaaf492082b6e1d5f2c45551.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ef6d92c0a65f4738a0b2800cb114da3a.png
[f01b2c5eeff44cb890230c1357b907f2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4c95fdbda0f44db1950270ad8531a917.png
[7331dd0a314944f781c1ab371a6ac9bb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2f8e4ad58aec44629d41ea295d107aa8.png
[14252975f34c4765b5aed6130f13b058.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d837e15af0414358bbceaf3ce603c7c5.png
[6eb0967adf554c6a8d0143376785102d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/465769c82c0c4fc5ae581643083db7fc.png
[67f63e4c9a704692b4100dd9f5f0781e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5ce33c7153d74ab6a93b5e5c75dd7878.png
[59b3eeb3e078467aabb4f19f02f550d1.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/21785bd3528340ebb045aa7e781ad552.png
[7a267ca6912541239469773e4115165f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f648754e33c741bbae49d893084a30c5.png
[49e04998ff1340e58e3806b57265fc5e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/bd522d7c8d47452188af44f77bc2cdb3.png
[c44d1d441f294f6f9f8cd6c45ebeba69.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b3cb255987ec455e8c88ca6bc5b67862.png
[91f4899a6f7640189085df3f09002458.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ae8ea2e809fa4915a501c6f30e992ab7.png
[d0e0ed5243134106bea66cfa6b55ba32.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a76e1fa00f194e9f85ae4db61c18f0f3.png
[cccf8a93ae1e4a8fbed4730c2f5a1f84.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4e5f64a4011d4733b07a9cf69a395bb1.png
[51ea729d3f5d488c9d28f82ae89654ae.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/183cd1852e684b2db46c506398da6513.png
[a6f0b1c6dcac47a29e19165286e4634b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6c53301ad507427d91dc4744fc0a74eb.png
[c287852700384eeea3b1e20a8f0f6c13.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2e60ab4d25cf45209689a05fb71708f8.png
[25a9a647cd644798959ffb4931737764.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a7df8452f172416fbd5550acb6e80473.png
[b70e3b2bdf57474b8a9bfacf3205e1a8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/94d52b6e28b3410ead7e5169944d46ef.png
[64cb3493eb7a4bfeb66985fd2224aa29.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0882678384a549d9933cad5bbbed727c.png
[07f33dcde46a46d0b60e85c9d1b6a8a9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/92768de4cd974bb0a53cb994cc0fc473.png
[ff53ae0e7a984c9983ce9896da7b3f50.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3baf650f89454a1c93e64139b9731f9a.png
[33f60bfd938e480a860bf2a7f976ef93.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/85b49cd3a22647fe837cea936f2a0f2f.png
[9bf2cb0f92fa41ab91b14ee3fa0d7078.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/79daced3ec974f14ad987bfa560947ec.png
[cd92c8ff77a24af69102df65f2e47e9a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ad0d1ad22c9542e19d2dc9a9664887eb.png
[1e1f6cc84fea4aea8744ff0e28ddebbc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2dcebac3046e43cab8f2eba7ed7f40e3.png
[f5d2addbe3964b6cb4580f231bb704bf.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8db7e47b690448b7a83076f6fae1c4c4.png
[47c207d2b2d9430d8cb022a6a6614d75.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a2f5a8edf36a4089924ae01a11229831.png
[f45405f7d7674f3697ea96cf4bfbe972.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/599e862b9cdc42b2b738070b2518bffa.png
[0b233fb1efb34c5c9a8cdc08e98162d3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5c118eb133504c2ba2ce9a0a86960f0b.png
[05c6e464737d4375a97edf84c6fbbcc1.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/e5acbc1dc3d741b6b6be0ed725a81722.png
[5ac691c20f2b4077814c3eae753c0f82.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/55e45d4882aa428196e919241260c0c4.png
[c82ab83360b14d5598cf86200ebbeeb5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/14add7f6049d4e5ba8187a08fccdbe3f.png
[3d3b43917cc5460cb8fdc8cdacb13801.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b57347efa0d8442590c358a97413f7b0.png
[a38d995a56054a948532a3ffecb4ed18.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/fc48cb198959481aaab93b79b7c148b5.png
[787dfcafd95d4608bd15e6bdf8d73dfa.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f880b0060d2d4210a173623762816864.png
[c96b837d0b444980ac864d248ce5919a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/303e1daffe7b4a3fbf3b04094f9c2f47.png
[849429f9170a4fd7995cc1b05c951fa9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/26730c5cc36f461ba301921eded20bc9.png
[9e0a71c604944d0cb8a95928a76c5b3f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7fa6d9c0212d486a85b5f7fbff6fc190.png
[75cea7756e604e55b08bd59d05c2eaaa.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ed335c67a7ff4748a90f00480c094c66.png
[1b8fbdfaeb0443eeb71ae0b24231cb35.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/fd363bac19ac43328a27c4ef5bb33b71.png
[b7ccc5fea4d34b1f8b12ec104963665b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b6173f69bc6d463782ad08b9efaa13d2.png
[d4559c634333435690836fcfbe893e13.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9b53f18b74424fb899c80b9734615fce.png
[a9e09e185f8d40c18a1f1c8b12c47703.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/35fb9e65e0394eb29a6959706e099eed.png
[e0984e00b8cd402195bb898b4e7550c8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ac0d7e190c9c48deb765b23bce8a0cd7.png
[fd5e0759da8449c38b10f4327ad64ac2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9d66272b7b1e44b5a4b2d042d59a16b7.png
[c61138e8d8be4ba2b293844cafa3c523.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/35df64af589a48808b1bff520e7e5202.png
[f9a955198a8b45beb849b7f913b4ee06.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/fd22db178ed04aa5a5ec87097f27fc8b.png
[38359f9d5e9d45af89f7cd390ba169e5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/32ebf282735e4d8db154c74adaa2fcb7.png
[e8bad1947774499aad2c6c727973048e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/adaaaba89c0d4dbda1a93552dc07d54d.png
[1c9acb70ba744ee294d5049a747591d9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4d0fcde0e55e40f6a49e765c8af4a8fc.png
[bcbe3ae6034149d291329f2fdb302773.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/71655a886b2442f2bdfe225a9769295b.png
[bbb769f972df45ba9dc05cdc71ee34fc.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b8e81ff72c2f41bfa336bcdc40ae3ea0.png
[c858d5d2e760427bb4efa27ceed8abeb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/07c6b70b93d641c9940f496110061a1f.png
[93ac4072cab644bda6fa223897c9c548.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/103b270bf95446f988cf032e220d38b2.png
[6f5266b79a4249f786be25a176a07c50.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/16c9cff2988e408ba27fedb90277da9f.png
[1a79a8d01e24415bb2e0fe9486498178.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9bd75d06f386455d91f5c25372da2777.png
[deaa4264b50b411b9f11406a4e9407b2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/689bd0ffcd774565989c7c4380f4ff53.png
[716175103dd7435c94166889d08290fd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/267d1d49acab47bebd674f1ed5646c8c.png
[39c73b0e25954bd8bc39e0d0f088de74.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1f40fcb645964e2ab01ee0c05ca0a839.png