15天深度复习JavaWeb的详细笔记(七)——Request、Response

àì夳堔傛蜴生んèń 2023-10-02 21:16 23阅读 0赞

#### 文章目录 ####

*  demo07-Request、Response
 *   *  1，Request和Response的概述
     *  2，Request对象
     *   *  2.1 Request继承体系
         *  2.2 Request获取请求数据
         *   *  2.2.1 获取请求行数据
             *  2.2.2 获取请求头数据
             *  2.2.3 获取请求体数据
             *  2.2.4 获取请求参数的通用方式
         *  2.3 IDEA快速创建Servlet
         *  2.4 请求参数中文乱码问题
         *   *  2.4.1 POST请求解决方案
             *  2.4.2 GET请求解决方案
         *  2.5 Request请求转发
     *  3，Response对象
     *   *  3.1 Response设置响应数据功能介绍
         *  3.2 Respones请求重定向
         *  3.3 路径问题
         *  3.4 Response响应字符数据
         *  3.3 Response响应字节数据

## demo07-Request、Response ##

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

Request是请求对象，Response是响应对象。

request和response这两个参数的作用:

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

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

@WebServlet("/demo3")
    public class ServletDemo3 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            //使用request对象 获取请求数据
            String name = request.getParameter("name");//url?name=zhangsan
    
            //使用response对象 设置响应数据
            response.setHeader("content-type","text/html;charset=utf-8");
            response.getWriter().write("<h1>"+name+",欢迎您！</h1>");
        }
    
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            System.out.println("Post...");
        }
    }

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

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

**小结**

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

### 2，Request对象 ###

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

Request的继承体系:

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

从上图中可以看出，ServletRequest和HttpServletRequest都是Java提供的,并且两个都是接口，接口是无法创建对象，这个时候就引发了下面这个问题:

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

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

*  该类实现了HttpServletRequest接口，也间接实现了ServletRequest接口。
 *  Servlet类中的service方法、doGet方法或者是doPost方法最终都是由Web服务器\[Tomcat\]来调用的，所以Tomcat提供了方法参数接口的具体实现类`RequestFacade`，并完成了对象的创建和封装
    
     *  封装就是Tomcat解析请求数据,然后将请求行,请求头请求体封装到实例对象中
     *  因为RequestFacade实现了HttpServletRequest接口,那么这个实现类就有HttpServletRequest接口的所有api,所以将来我们有不懂的api时查阅javaee提供的HttpServletRequest接口方法即可

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

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

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

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

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

*  获取请求方式: `GET`

String getMethod()

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

String getContextPath()

什么叫虚拟目录(项目访问路径):在pom.xml配置Tomcat坐标时如果在`plugins`标签中加了`<configuration> <path>/hello</path> </configuration>`，那么调用该方法返回就是`/hello`

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

StringBuffer getRequestURL()

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

String getRequestURI()

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

String getQueryString()

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

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

对于请求头的数据，格式为`key: value`,所以根据请求头名称获取对应值的方法为:

String getHeader(String name)
    //如String agent = req.getHeader("user-agent");

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

请求体中的数据格式如下:

username=superbaby&password=123

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

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

ServletInputStream getInputStream()

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

BufferedReader getReader()

*  ServletInputStream流和BufferedReader流是通过request对象来获取的，**当这一次请求完成后request对象就会被销毁**，request对象被销毁后，流就会自动关闭，所以不需要手动关闭流了

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

目前我们知道的请求参数的两种获取方式:

*  POST请求的请求参数通过请求体获得
    
     *  getInputStream()或getReader()
 *  GET请求没有请求头,是从请求行中获取请求参数
    
     *  getQueryString()

但实际开发中对于GET请求和POST请求对应方法中的业务逻辑,除了获取请求参数的方式不同,其它代码都是一模一样的,那我们没必要在doGet和doPost方法写重复的代码了呀,我们可以只在doGet中处理业务逻辑,然后在doPost方法中通过this.doGet(req, resp)调用doGet方法,从而实现简化开发,如下所示:

@WebServlet("/req1")
    public class RequestDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
          //doGet方法的业务处理逻辑
        }
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req,resp);
        }
    }

但这一切有一个前提:我们前面说了GET和POST请求方式获取请求参数的方式不同,那我们想实现上面说的简化开发,就必须有一个通用的获取参数的方法:

解决方案一:

@WebServlet("/req1")
    public class RequestDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            //获取请求方式
            String method = req.getMethod();
            //获取请求参数
            String params = "";
            if("GET".equals(method)){
        
                params = req.getQueryString();
            }else if("POST".equals(method)){
        
                BufferedReader reader = req.getReader();
                params = reader.readLine();
            }
            //将请求参数进行打印控制台
            System.out.println(params);
        }
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req,resp);
        }
    }

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

解决方案二:

request对象提供了已经将上述获取请求参数的方法进行了封装(和我们方案一做的差不多,不过人家里面还多了很多细节)，在request提供的这个方法中都实现了哪些操作:

1.根据不同的请求方式获取请求参数，获取的内容如下:

username=zhangsan&hobby=1&hobby=2

2.把获取到的内容进行分割，内容如下:

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

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

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

**注意**:在map集合添加键值对`hobby` `1`后如果再添加键值对`hobby` `2`就会覆盖掉上次存入的`1`,但这显然不是我们想要的,所以tomcat做了一些逻辑处理,使其不是用`2`覆盖掉`1`而是存一个数组`[1,2]`,也正是因为这样,所以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 action="/demo06-request/req2" method="post">
            <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代码中获取页面传递POST请求的参数值

@WebServlet("/req2")
    public class RequestDemo2 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            //1. 获取所有参数的Map集合
            Map<String, String[]> map = req.getParameterMap();
            for (String key : map.keySet()) {
        
                // username:zhangsan lisi
                System.out.print(key+":");
                //获取值
                String[] values = map.get(key);
                for (String value : values) {
        
                    System.out.print(value + " ");
                }
                System.out.println();
            }
    
            System.out.println("-----分割线------");
            //2. 根据key获取参数值，数组
            String[] hobbies = req.getParameterValues("hobby");
            for (String hobby : hobbies) {
        
                System.out.println(hobby);
            }
    
            System.out.println("-----分割线------");
            //3. 根据key 获取单个参数值
            String username = req.getParameter("username");
            System.out.println(username);
        }
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            this.doGet(req,resp);
        }
    }

3.启动服务,进入req.html页面将表单中的数据进行填写,点击提交可以看到控制台输出如下数据:

username:lisi 
    password:123 
    hobby:1 2 
    -----分割线------
    1
    2
    -----分割线------
    lisi

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

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

@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 {
        
            this.doGet(req,resp);
        }
    }

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

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

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

#if (${
        PACKAGE_NAME} && ${
        PACKAGE_NAME} != "")package ${
        PACKAGE_NAME};#end
    #parse("File Header.java")
    
    #if ($JAVAEE_TYPE == "jakarta")
    import jakarta.servlet.*;
    import jakarta.servlet.http.*;
    import jakarta.servlet.annotation.*;
    #else
    import javax.servlet.*;
    import javax.servlet.http.*;
    import javax.servlet.annotation.*;
    #end
    import java.io.IOException;
    
    @WebServlet("/${Entity_Name}")
    public class ${
        Class_Name} extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            
        }
    
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request,response);
        }
    }

（2）在Project Structure的Facets菜单中选中当前的项目或模块,并在`Sources Roots`中将两个路径打钩

（3）使用servlet模板创建Servlet类

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

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

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

1.前端页面用的是2.2.4案例中的req.html,只是将action的属性值改为"/demo06-request/req3"

2.编写RequestDemo3类:

@WebServlet("/req3")
    public class RequestDemo3 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            String username = request.getParameter("username");
            System.out.println(username);
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }

3.启动服务,访问req.html页面,在输入框输入中文,会发现控制台输出乱码

*  分析出现中文乱码的原因：
    
     *  POST的请求参数是通过request的getReader()来获取流中请求体的数据,并返回一个BufferedReader字符缓冲输入流对象
     *  TOMCAT在获取流的时候采用的编码是ISO-8859-1
     *  ISO-8859-1编码是不支持中文的，所以会出现乱码
 *  解决方案：
    
     *  因为req.html页面设置的编码格式为UTF-8,所以要把TOMCAT在获取流数据之前的编码设置为UTF-8
        
         *  通过request.setCharacterEncoding(“UTF-8”)设置编码,UTF-8也可以写成小写

4.修改后的代码为:

@WebServlet("/req3")
    public class RequestDemo3 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            request.setCharacterEncoding("UTF-8");//设置字符输入流的编码
            String username = request.getParameter("username");
            System.out.println(username);
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }

5.启动服务,访问req.html页面,在输入框输入中文,会发现控制台输出不再乱码

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

POST请求的中文乱码解决方案不适用GET请求:

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

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

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

![在这里插入图片描述][793866cfa2b840c196eb4a3480f6dde1.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`，输入`张三`

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

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

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

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

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

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

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

编码:

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

解码:

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

了解了URL编码和URL解码,就知道GET请求中文参数出现乱码的原因了:

*  浏览器对数据进行URL编码时字符集是req.html页面中标签设置的`utf-8`
 *  Tomcat对数据进行URL解码时字符集是默认的`ISO-8859-1`
 *  URL编码和URL解码的字符集不同,故乱码

2.知道了乱码原因,那怎么解决乱码呢

*  首先,Tomcat在进行URL解码时将代码写死了,并没有预留供外部修改解码时字符集的API,所以我们不能通过修改解码时字符集来解决问题

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

从上图可知道,URL编码和URL解码时的二进制数据是一样的,那么造成字符串乱码的核心流程就可简化为下图:

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

所以乱码原因就是字符集1和字符集2不同,我们可以这样做:

*  以字符集2的方式将乱码字符转为二进制数据
 *  以字符集1的方式再将二进制数据转为字符串

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

*  此时得到的字符串就不再是乱码了

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

1.前端页面用的是2.2.4案例中的req.html,只是将action的属性值改为"/demo06-request/req4"并将提交方式改为了get

2.编写RequestDemo4类:

@WebServlet("/req4")
    public class RequestDemo4 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            String username = request.getParameter("username");
            System.out.println("解决乱码前："+username);
    
            //先对将乱码数据转为字节数组,字符集选择Tomcat进行URL解码时的默认字符集ISO_8859_1
            byte[] bytes = username.getBytes(StandardCharsets.ISO_8859_1);
            //将字节数组转为字符串,这里的字符集必须和html页面中设置的字符集一样
            username = new String(bytes, StandardCharsets.UTF_8);
    
            System.out.println("解决乱码后："+username);
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }

**注意**

*  如果将req.html页面的提交方式改为post,会发现GET请求参数乱码解决方案同时也可也把POST请求参数乱码的问题也解决了
 *  只不过对于POST请求参数一般都会比较多，采用这种方式解决乱码起来比较麻烦，所以对于POST请求还是建议使用设置编码的方式进行。
 *  另外需要说明一点的是Tomcat8.0之后，已将GET请求乱码问题解决，设置默认的解码方式为UTF-8

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

1.  请求转发(forward):一种在服务器内部的资源跳转方式。

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

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

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

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

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

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

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

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

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

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

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void setAttribute(String name,Object o);</td> 
   <td>存储数据到request域[范围,<strong>数据是存储在request对象中</strong></td> 
  </tr> 
  <tr> 
   <td>Object getAttribute(String name);</td> 
   <td>根据key获取值</td> 
  </tr> 
  <tr> 
   <td>void removeAttribute(String name);</td> 
   <td>根据key删除该键值对</td> 
  </tr> 
 </tbody> 
</table>

案例展示:

@WebServlet("/req5")
    public class RequestDemo5 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            System.out.println("demo5...");
            //存储数据
            request.setAttribute("msg","hello");
            //请求转发
            request.getRequestDispatcher("/req6").forward(request,response);
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }
    
    @WebServlet("/req6")
    public class RequestDemo6 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            System.out.println("demo6...");
            //获取数据
            Object msg = request.getAttribute("msg");
            System.out.println(msg);
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }

启动服务,在地址栏输入`http://localhost:8080/demo06-request_response/req5`可以看到控制台如下输出打印:

> demo5…  
> demo6…  
> hello

1.  请求转发的特点

*  浏览器地址栏路径不发生变化
    
     *  虽然后台从`/req5`转发到`/req6`,但是浏览器的地址一直是`/req5`,未发生变化
 *  只能转发到当前服务器的内部资源
    
     *  不能从一个服务器通过转发访问另一台服务器,比如转发到百度的服务器是不可以的
 *  一次请求，可以在转发资源间使用request共享数据

### 3，Response对象 ###

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

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

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

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

1.  响应行

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

void setStatus(int sc);

1.  响应头

设置响应头键值对：

void setHeader(String name,String value);

1.  响应体

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

获取字符输出流:

PrintWriter getWriter();

获取字节输出流

ServletOutputStream getOutputStream();

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

1.  Response重定向(redirect):一种资源跳转方式。

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

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

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

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

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

1.  重定向的实现方式:

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

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

resposne.sendRedirect("资源B的访问路径")

案例实现:

@WebServlet("/resp1")
    public class ResponseDemo1 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            System.out.println("resp1....");
            //1.设置响应状态码 302
    //        response.setStatus(302);
            //2. 设置响应头 Location
            //2.1 路径需要带上虚拟目录的名称,即/demo06-request-response
            //2.2location中的任意字母大小写都可以,比如写成LocaTion
    //        response.setHeader("LocaTion","/demo06-request_response/resp2");
    
    	    //简化写法
            //动态获取虚拟目录
            String contextPath = request.getContextPath();
            System.out.println(contextPath);//输出:/demo06-request_response
            response.sendRedirect(contextPath+"/resp2");
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }
    
    @WebServlet("/resp2")
    public class ResponseDemo2 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            System.out.println("resp2....");
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }

启动服务,在地址栏输入`http://localhost:8080/demo06-request_response/resp1`进行测试

注意:案例中为什么要动态获取项目的虚拟目录呢:

*  前面我们说过,在pom.xml配置tomcat时我们可以通过`path`标签设置项目的虚拟目录,那么如果日后更改了虚拟目录,代码中所有关于虚拟目录的地方都要随之更改,代码耦合性太高了,所以要动态获取项目的虚拟目录来降低代码的耦合度

1.  重定向的特点

*  浏览器地址栏路径发送变化
    
     *  当进行重定向访问的时候，由于是由浏览器发送的两次请求，所以地址会发生变化
 *  可以重定向到任何位置的资源(服务内容、外部均可)
    
     *  因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。如:
        
            response.sendRedirect("https://www.baidu.com");
 *  两次请求，不能在多个资源使用request共享数据
    
     *  因为浏览器发送了两次请求，是两个不同的request对象，就无法通过request对象进行共享数据

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

<table> 
 <thead> 
  <tr> 
   <th>重定向特点</th> 
   <th>请求转发特点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>浏览器地址栏路径发生变化</td> 
   <td>浏览器地址栏路径不发生变化</td> 
  </tr> 
  <tr> 
   <td>可以重定向到任意位置的资源(服务器内部,外部均可)</td> 
   <td>只能转发到当前服务器的内部资源</td> 
  </tr> 
  <tr> 
   <td>两次请求,不能在多个资源使用request共享数据</td> 
   <td>一次请求,可以在转发的资源间使用request共享数据</td> 
  </tr> 
 </tbody> 
</table>

#### 3.3 路径问题 ####

转发的时候路径上没有加`/demo06-request_response`而重定向加了，那么到底什么时候需要加，什么时候不需要加呢:

*  其实判断的依据很简单，只需要记住下面的规则即可:
    
     *  浏览器使用:需要加虚拟目录(项目访问路径)
    
     *  服务端使用:不需要加虚拟目录

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

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

掌握了这个规则，接下来就通过一些练习来强化下知识的学习:

*  `<a href='路劲'>`超链接，从浏览器发送，需要加
 *  `<form action='路径'>`提交表单，从浏览器发送，需要加
 *  `req.getRequestDispatcher("路径")`转发，是从服务器内部跳转，不需要加
 *  `resp.sendRedirect("路径")`重定向，是由浏览器进行跳转，需要加。

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

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

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

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

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

@WebServlet("/resp3")
    public class ResponseDemo3 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            //告诉浏览器用html的引擎来解析响应体
            response.setHeader("content-type","text/html");
            PrintWriter writer = response.getWriter();
            writer.write("<h1>aaa</h1>");
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }

注意:

*  一次请求响应结束后，response对象就会被销毁掉，随之流也会被销毁,所以不要手动关闭流
 *  java对第6行的`response.setHeader("content-type","text/html");`进行了封装:
    
        response.setContentType("text/html");
 *  如果写出中文就会乱码,因为tomcat获**取字符输出流时**默认使用ISO-8859-1,所以需要设置流的编码为utf-8:
    
        response.setContentType("text/html;charset=utf-8");
    
    且**这行代码要写在获取字符输出流之前**

修改后的代码为:

@WebServlet("/resp3")
    public class ResponseDemo3 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
    
            response.setContentType("text/html;charset=utf-8");
    
            //1. 获取字符输出流
            PrintWriter writer = response.getWriter();
            writer.write("<h1>你好</h1>");
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }

#### 3.3 Response响应字节数据 ####

1.导入commons-io的依赖坐标:

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

2.编写代码:

@WebServlet("/resp4")
    public class ResponseDemo4 extends HttpServlet {
        
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            //1. 读取文件
            FileInputStream fis = new FileInputStream("d://a.png");
            //2. 获取字节输出流
            ServletOutputStream os = response.getOutputStream();
    
    //        //3. 完成流的copy
    //        byte[] buff = new byte[1024];
    //        int len = 0;
    //        while ((len = fis.read(buff))!= -1){
        
    //            os.write(buff,0,len);
    //        }
    
            //3. 完成流的copy(使用别人的框架)
            IOUtils.copy(fis,os);
    
            fis.close();//os不能手动关,这个说过很多次了(我认为fis也不需手动关,人家这个io框架应该会内部实现关fis吧?)
        }
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
            this.doGet(request, response);
        }
    }

[85a50ff10eff41249eace898e17e5637.png_pic_center]: https://img-blog.csdnimg.cn/85a50ff10eff41249eace898e17e5637.png#pic_center
[5b919eb7dd194d10b26cb5d149142d1f.png_pic_center]: https://img-blog.csdnimg.cn/5b919eb7dd194d10b26cb5d149142d1f.png#pic_center
[8697be80985b43cbbc4fbcbc4394d5cf.png_pic_center]: https://img-blog.csdnimg.cn/8697be80985b43cbbc4fbcbc4394d5cf.png#pic_center
[b363019f7a7545ee83465ad055b93aba.png_pic_center]: https://img-blog.csdnimg.cn/b363019f7a7545ee83465ad055b93aba.png#pic_center
[913ca2628a8c4d9b99ac916f1f9a9079.png_pic_center]: https://img-blog.csdnimg.cn/913ca2628a8c4d9b99ac916f1f9a9079.png#pic_center
[a12ad813dc0a4402bd16b3222c0e1f9b.png_pic_center]: https://img-blog.csdnimg.cn/a12ad813dc0a4402bd16b3222c0e1f9b.png#pic_center
[b769e29bd9c04b84aae8cd790d2f9b06.png_pic_center]: https://img-blog.csdnimg.cn/b769e29bd9c04b84aae8cd790d2f9b06.png#pic_center
[ead7ff5f162c4b9c982d61f7598ffd2f.png_pic_center]: https://img-blog.csdnimg.cn/ead7ff5f162c4b9c982d61f7598ffd2f.png#pic_center
[793866cfa2b840c196eb4a3480f6dde1.png_pic_center]: https://img-blog.csdnimg.cn/793866cfa2b840c196eb4a3480f6dde1.png#pic_center
[a0fb7201bd9949d8acbcf4e9995e4814.png_pic_center]: https://img-blog.csdnimg.cn/a0fb7201bd9949d8acbcf4e9995e4814.png#pic_center
[e9b0af839aae4df8899cd1bdbb44a446.png_pic_center]: https://img-blog.csdnimg.cn/e9b0af839aae4df8899cd1bdbb44a446.png#pic_center
[82a2761aecd74f4d8bf599092b59b165.png_pic_center]: https://img-blog.csdnimg.cn/82a2761aecd74f4d8bf599092b59b165.png#pic_center
[ce408b4bf0984ec5b3c6a21782cd3a6c.png_pic_center]: https://img-blog.csdnimg.cn/ce408b4bf0984ec5b3c6a21782cd3a6c.png#pic_center
[952e1d888a5e4440ba31d35ad2cde256.png_pic_center]: https://img-blog.csdnimg.cn/952e1d888a5e4440ba31d35ad2cde256.png#pic_center
[d66a23458edd446eae8d21ac1617ee91.png_pic_center]: https://img-blog.csdnimg.cn/d66a23458edd446eae8d21ac1617ee91.png#pic_center
[9341a5ed70314c6e86f25737c2fa2928.png_pic_center]: https://img-blog.csdnimg.cn/9341a5ed70314c6e86f25737c2fa2928.png#pic_center
[7bd937be5f1f4e539610911b2cd80c35.png_pic_center]: https://img-blog.csdnimg.cn/7bd937be5f1f4e539610911b2cd80c35.png#pic_center
[ea4b6bd7cc674961af7e89bcf4e38736.png_pic_center]: https://img-blog.csdnimg.cn/ea4b6bd7cc674961af7e89bcf4e38736.png#pic_center