11-Request&Response

Posted 2023-05-18 念念念北

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了11-Request&Response相关的知识，希望对你有一定的参考价值。

1，Request 和 Response 的概述

Request 是请求对象，Response 是响应对象。这两个对象在我们使用 Servlet 的时候有看到：

此时，我们就需要思考一个问题 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...");

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

小结

在这节中，我们主要认识了下 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 的继承体系:

从上图中可以看出，ServletRequest 和 HttpServletRequest 都是 Java 提供的，所以我们可以打开 JavaEE 提供的 API 文档[参考: 资料/JavaEE7-api.chm],打开后可以看到:

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

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

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

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

@WebServlet("/demo2")
public class ServletDemo2 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        System.out.println(request);
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException

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

小结

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

2.2 Request 获取请求数据

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

2.2.1 获取请求行数据

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

对于这三部分内容，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()

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

/**
 * request 获取请求数据
 */
@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);//GET
        // String getContextPath()：获取虚拟目录(项目访问路径)：/request-demo
        String contextPath = req.getContextPath();
        System.out.println(contextPath);
        // StringBuffer getRequestURL(): 获取URL(统一资源定位符)：http://localhost:8080/request-demo/req1
        StringBuffer url = req.getRequestURL();
        System.out.println(url.toString());
        // String getRequestURI()：获取URI(统一资源标识符)： /request-demo/req1
        String uri = req.getRequestURI();
        System.out.println(uri);
        // String getQueryString()：获取请求参数（GET方式）： username=zhangsan
        String queryString = req.getQueryString();
        System.out.println(queryString);
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException

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

2.2.2 获取请求头数据

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

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

String getHeader(String name)

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

/**
 * request 获取请求数据
 */
@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 
        //获取请求头: user-agent: 浏览器的版本信息
        String agent = req.getHeader("user-agent");
		System.out.println(agent);
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException

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

2.2.3 获取请求体数据

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

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

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

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

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

BufferedReader getReader()

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

具体实现的步骤如下:

1.准备一个页面，在页面中添加 form 表单,用来发送 post 请求

2.在 Servlet 的 doPost 方法中获取请求体数据

3.在 doPost 方法中使用 request 的 getReader()或者 getInputStream()来获取

4.访问测试

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

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Title</title>
  </head>
  <body>
    <!-- 
    action:form表单提交的请求地址
    method:请求方式，指定为post
-->
    <form action="/request-demo/req1" method="post">
      <input type="text" name="username" />
      <input type="password" name="password" />
      <input type="submit" />
    </form>
  </body>
</html>

在 Servlet 的 doPost 方法中获取数据

/**
 * 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 
        //在此处获取请求体中的数据

调用 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 流就会自动关闭，所以此处就不需要手动关闭流了。

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

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

小结

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 请求接收参数的方式不一样，具体实现的代码如下:

@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 

        String result = req.getQueryString();
        System.out.println(result);

    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 
        BufferedReader br = req.getReader();
        String result = br.readLine();
        System.out.println(result);

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

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

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

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

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

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

解决方案一:

@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 提供的方法实现的功能更强大，以后只需要调用 request 提供的方法即可，在 request 的方法中都实现了哪些操作?

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

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

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

注意:因为参数的值可能是一个，也可能有多个，所以 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="/request-demo/req2" method="get">
      <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 代码中获取页面传递 GET 请求的参数值

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

/**
 * request 通用方式获取请求参数
 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 
        //GET请求逻辑
        System.out.println("get....");
        //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();
        
    

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException

获取的结果为:

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

/**
 * request 通用方式获取请求参数
 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 
        //GET请求逻辑
        //...
        System.out.println("------------");
        String[] hobbies = req.getParameterValues("hobby");
        for (String hobby : hobbies) 
            System.out.println(hobby);
        
    

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException

获取的结果为:

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

/**
 * request 通用方式获取请求参数
 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException 
        //GET请求逻辑
        //...
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println(username);
        System.out.println(password);
    

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException

获取的结果为:

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 的请求方式代码的不同，则代码可以定义如下格式:

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

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

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

2.4 请求参数中文乱码问题

问题展示:

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

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/request-demo/req2" method="get">
    <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 方法中获取参数，并打印

/**
 * 中文乱码问题解决方案
 */
@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
       //1. 获取username
       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）启动服务器，页面上输入中文参数

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

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

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

通过上面的案例，会发现，不管是 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 也可以写成小写

修改后的代码为:

/**
 * 中文乱码问题解决方案
 */
@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        //1. 解决乱码: POST getReader()
        //设置字符输入流的编码，设置的字符集要和页面保持一致
        request.setCharacterEncoding("UTF-8");
       //2. 获取username
       String username = request.getParameter("username");
       System.out.println(username);
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

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

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

2.4.2 GET 请求解决方案

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

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

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

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

(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，输入张三

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

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

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

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

编码:

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

解码:

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

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

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); //打印:%E5%BC%A0%E4%B8%89

       //2. URL解码
       //String decode = URLDecoder.decode(encode, "utf-8");//打印:张三
       String decode = URLDecoder.decode(encode, "ISO-8859-1");//打印:`å¼ ä¸ `
       System.out.println(decode);

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

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

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

从上图可以看住，

在进行编码和解码的时候，不管使用的是哪个字符集，他们对应的%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 编码获取字节数组对应的字符串

实现代码如下:

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);
        //2. URL解码
        String decode = URLDecoder.decode(encode, "ISO-8859-1");

        System.out.println(decode); //此处打印的是对应的乱码数据

        //3. 转换为字节数据,编码
        byte[] bytes = decode.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); //此处打印的是张三

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

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

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

/**
 * 中文乱码问题解决方案
 */
@WebServlet("/req4")
public class RequestDemo4 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        //1. 解决乱码：POST，getReader()
        //request.setCharacterEncoding("UTF-8");//设置字符输入流的编码

        //2. 获取username
        String username = request.getParameter("username");
        System.out.println("解决乱码前："+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);

    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

注意

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

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

小结

中文乱码解决方案

POST 请求和 GET 请求的参数中如果有中文，后台接收数据就会出现中文乱码问题

GET 请求在 Tomcat8.0 以后的版本就不会出现了

POST 请求解决方案是:设置输入流的编码

request.setCharacterEncoding("UTF-8");
注意:设置的字符集要和页面保持一致

通用方式（GET/POST）：需要先解码，再编码
```
new String(username.getBytes("ISO-8859-1"),"UTF-8");
```

URL 编码实现方式:

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

2.5 Request 请求转发

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

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

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

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

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

请求转发的实现方式:

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

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

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

1.创建一个 RequestDemo5 类，接收/req5 的请求，在 doGet 方法中打印demo5

2.创建一个 RequestDemo6 类，接收/req6 的请求，在 doGet 方法中打印demo6

3.在 RequestDemo5 的方法中使用

req.getRequestDispatcher("/req6").forward(req,resp)进行请求转发

4.启动测试

(1)创建 RequestDemo5 类

/**
 * 请求转发
 */
@WebServlet("/req5")
public class RequestDemo5 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        System.out.println("demo5...");
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

(2)创建 RequestDemo6 类

/**
 * 请求转发
 */
@WebServlet("/req6")
public class RequestDemo6 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        System.out.println("demo6...");
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

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

/**
 * 请求转发
 */
@WebServlet("/req5")
public class RequestDemo5 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        System.out.println("demo5...");
        //请求转发
        request.getRequestDispatcher("/req6").forward(request,response);
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

(4)启动测试

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

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

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

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

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

存储数据到 request 域[范围,数据是存储在 request 对象]中

void setAttribute(String name,Object o);

根据 key 获取值

Object getAttribute(String name);

根据 key 删除该键值对

void removeAttribute(String name);

接着上个需求来:

1.在 RequestDemo5 的 doGet 方法中转发请求之前，将数据存入 request 域对象中

2.在 RequestDemo6 的 doGet 方法从 request 域对象中获取数据，并将数据打印到控制台

3.启动访问测试

(1)修改 RequestDemo5 中的方法

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

(2)修改 RequestDemo6 中的方法

/**
 * 请求转发
 */
@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);

(3)启动测试

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

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

请求转发的特点

浏览器地址栏路径不发生变化

虽然后台从/req5转发到/req6,但是浏览器的地址一直是/req5,未发生变化
只能转发到当前服务器的内部资源

不能从一个服务器通过转发访问另一台服务器
一次请求，可以在转发资源间使用 request 共享数据

虽然后台从/req5转发到/req6，但是这个只有一次请求

3，Response 对象

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

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

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

介绍完 Response 的相关体系结构后，接下来对于 Response 我们需要学习如下内容:

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

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

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

响应行

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

void setStatus(int sc);

响应头

设置响应头键值对：

void setHeader(String name,String value);

响应体

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

获取字符输出流:

PrintWriter getWriter();

获取字节输出流

ServletOutputStream getOutputStream();

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

3.2 Respones 请求重定向

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

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

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

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

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

重定向的实现方式:

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

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

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

1.创建一个 ResponseDemo1 类，接收/resp1 的请求，在 doGet 方法中打印resp1....

2.创建一个 ResponseDemo2 类，接收/resp2 的请求，在 doGet 方法中打印resp2....

3.在 ResponseDemo1 的方法中使用

response.setStatus(302);

response.setHeader("Location","/request-demo/resp2") 来给前端响应结果数据

4.启动测试

(1)创建 ResponseDemo1 类

@WebServlet("/resp1")
public class ResponseDemo1 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        System.out.println("resp1....");
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

(2)创建 ResponseDemo2 类

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

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

@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
        response.setHeader("Location","/request-demo/resp2");
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

(4)启动测试

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

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

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

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

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

@WebServlet("/resp1")
public class ResponseDemo1 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        System.out.println("resp1....");
        //重定向
        resposne.sendRedirect("/request-demo/resp2")；
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

重定向的特点

浏览器地址栏路径发送变化

当进行重定向访问的时候，由于是由浏览器发送的两次请求，所以地址会发生变化
可以重定向到任何位置的资源(服务内容、外部均可)

因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。
两次请求，不能在多个资源使用 request 共享数据

因为浏览器发送了两次请求，是两个不同的 request 对象，就无法通过 request 对象进行共享数据

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

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

3.3 路径问题

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

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

浏览器使用:需要加虚拟目录(项目访问路径)
服务端使用:不需要加虚拟目录

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

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

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

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

答案:

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

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

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

@WebServlet("/resp1")
public class ResponseDemo1 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        System.out.println("resp1....");

        //简化方式完成重定向
        //动态获取虚拟目录
        String contextPath = request.getContextPath();
        response.sendRedirect(contextPath+"/resp2");
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

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

3.4 Response 响应字符数据

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

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

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

返回一个简单的字符串aaa

/**
 * 响应字符数据：设置字符数据的响应体
 */
@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("aaa");
    
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

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

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

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

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

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

3.3 Response 响应字节数据

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

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

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

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

/**
 * 响应字节数据：设置字节数据的响应体
 */
@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.jpg");
        //2. 获取response字节输出流
        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);
        
        fis.close();
    

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException 
        this.doGet(request, response);

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

(1)pom.xml 添加依赖

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

(2)调用工具类方法

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

优化后的代码:

/**
 * 响应字节数据：设置字节数据的响应体
 */
@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet 
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException
request&response

HttpServletRequest&HttpServletResponse。
web服务器收到客户端的http请求，会针对每一次请求，分别创建一个用于代表请求的request对象和代表响应的response对象。如果要获取客户机提交的数据，只需要request对象，要想客户机输出数据，只需要response对象。
一、Response
    1.Resonse的继承结构：
            ServletResponse--HttpServletResponse
    2.Response代表响应，于是响应消息中的状态码、响应头、实体内容都可以由它进行操作：
　　    a.利用Response输出数据到客户端
　　 response.setContentTye("text/html;charset=utf-8");
        response.getOUtputStream().write("".getBytes("utf-8"));
        
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().write("");
        response.getOutputStream（）.write("中文".getBytes())输出数据，这是一个字节流，是什么字节输出什么字节，而浏览器默认用平台字节码打开服务器发送的数据，如果服务器端使用了非平台码去输出字符的字节数据就需要明确的指定浏览器编码时所用的码表，以防止乱码问题。response.setHeader("Content-type","text/html;charset=utf-8")
        response.getWriter().write(“中文”);输出数据，这是一个字符流，response会将此字符进行转码操作后输出到浏览器，这个过程默认使用ISO8859-1码表，而ISO8859-1中没有中文，于是转码过程中用?代替了中文，导致乱码问题。可以指定response在转码过程中使用的目标码表，防止乱码。response.setCharcterEncoding("utf-8");
        其实response还提供了setContentType("text/html;charset=gb2312")方法，此方法会设置content-type响应头，通知浏览器打开的码表，同时设置response的转码用码表，从而一行代码解决乱码。
    　　b.利用Response 设置 content-disposition头实现文件下载
            设置响应头content-disposition为“attachment;filename=xxx.xxx”
　　　　　　response.setHeader("context-disposition","attachment;filename=xxx.xxx")
            利用流将文件读取进来，再利用Response获取响应流输出
            如果文件名为中文，一定要进行URL编码，编码所用的码表一定要是utf-8
    　　c.refresh头控制定时刷新
        设置响应头Refresh为一个数值，指定多少秒后刷新当前页面 response.setHeader(refresh","1")
        设置响应头Refresh为 3;url=/Day05/index.jsp,指定多少秒后刷新到哪个页面 response.setHeader("refresh","3；url=/Day05/index.jsp")
        可以用来实现注册后“注册成功，3秒后跳转到主页”的功能
        在HTML可以利用<meta http-equiv= "" content="">标签模拟响应头的功能。
    　　d.利用response设置expires、Cache-Control、Pragma实现浏览器是否缓存资源，这三个头都可以实现，但是由于历史原因，不同浏览器实现不同，所以一般配合这三个头使用
        　　控制浏览器不要缓存（验证码图片不缓存）设置expires为0或-1设置Cache-Control为no-cache、Pragma为no-cache
        　　控制浏览器缓存资源。即使不明确指定浏览器也会缓存资源，这种缓存没有截至日期。当在地址栏重新输入地址时会用缓存，但是当刷新或重新开浏览器访问时会重新获得资源。
            如果明确指定缓存时间，浏览器缓存是，会有一个截至日期，在截至日期到期之前，当在地址栏重新输入地址或重新开浏览器访问时都会用缓存，而当刷新时会重新获得资源。
　　　　response.setIntHeader("Expires",-1)       response.setDateHeader("Expires",System.cuurrentTimeMillis()+10001*3600*24*30)
　　　　response.setHeader("Cache-Control","no-cache")
　　　　response.setHeader("Pragma","no-cache")
    　　e.Response实现请求重定向（地址栏发生改变）
        　　　　古老方法：response.setStatus(302);response.addHeader("Location","URL");
        　　　　快捷方式：response.sendRedirect("URL");
    　　f.输出验证码图片
    
    3.Response注意的内容：
        3.1对于一次请求，Response的getOutputStream方法和getWriter方法是互斥，只能调用其一，特别注意forward后也不要违反这一规则。
        3.2利用Response输出数据的时候，并不是直接将数据写给浏览器，而是写到了Response的缓冲区中，等到整个service方法返回后，由服务器拿出response中的信息组成HTTP响应消息返回给浏览器。
        3.3service方法返回后，服务器会自己检查Response获取的OutputStream或者Writer是否关闭，如果没有关闭，服务器自动帮你关闭，一般情况下不要自己关闭这两个流。
        

二、Request：ServletRequest--HttpServletRequest
　　Request代表请求对象，其中封装了对请求中具有请求行、请求头、实体内容的操作的方法
    1.获取客户机信息
        getRequestURL方法返回客户端发出请求完整URL
        getRequestURI方法返回请求行中的资源名部分,在权限控制中常用
        getQueryString 方法返回请求行中的参数部分
        getRemoteAddr方法返回发出请求的客户机的IP地址
        getMethod得到客户机请求方式
        getContextPath 获得当前web应用虚拟目录名称，特别重要！！！，工程中所有的路径请不要写死，其中的web应用名要以此方法去获得。

    2.获取请求头信息
        getHeader(name)方法 --- String ，获取指定名称的请求头的值
        getHeaders(String name)方法 --- Enumeration<String> ，获取指定名称的请求头的值的集合，因为可能出现多个重名的请求头
        getHeaderNames方法 --- Enumeration<String> ，获取所有请求头名称组成的集合
        getIntHeader(name)方法  --- int ，获取int类型的请求头的值
        getDateHeader(name)方法 --- long(日期对应毫秒) ，获取一个日期型的请求头的值，返回的是一个long值，从1970年1月1日0时开始的毫秒值
        
        *实验：通过referer信息防盗链
            String ref = request.getHeader("Referer");
            if (ref == null || ref == "" || !ref.startsWith("http://localhost")) {
                response.sendRedirect(request.getContextPath() + "/homePage.html");
            } else {
                this.getServletContext().getRequestDispatcher("/WEB-INF/ethan0603.html").forward(request, response);
            }
    3.获取请求参数
        getParameter(name) --- String 通过name获得值
        getParameterValues（name）  --- String[ ] 通过name获得多值 checkbox
        getParameterNames  --- Enumeration<String> 获得所有请求参数名称组成的枚举
        getParameterMap  --- Map<String,String[ ]> 获取所有请求参数的组成的Map集合，注意，其中的键为String，值为String[]
        
        获取请求参数时乱码问题：
            浏览器发送的请求参数使用什么编码呢？当初浏览器打开网页时使用什么编码，发送就用什么编码。
            服务器端获取到发过来的请求参数默认使用ISO8859-1进行解码操作，中文一定有乱码问题
            对于Post方式提交的数据，可以设置request.setCharacterEncoding("gb2312");来明确指定获取请求参数时使用编码。但是此种方式只对Post方式提交有效。
            对于Get方式提交的数据，就只能手动解决乱码：String newName = new String(name.getBytes("ISO8859-1"),"gb2312");此种方法对Post方式同样有效。
            在tomcat的server.xml中可以配置http连接器的URIEncoding可以指定服务器在获取请求参数时默认使用的编码，从而一劳永逸的决绝获取请求参数时的乱码问题。也可以指定useBodyEncodingForURI参数，令request.setCharacterEncoding也对GET方式的请求起作用，但是这俩属性都不推荐使用，因为发布环境往往不允许修改此属性。
            
            
    4.利用请求域传递对象
        生命周期：在service方法调用之前由服务器创建，传入service方法。整个请求结束，request生命结束。
        作用范围：整个请求链。
        作用：在整个请求链中共享数据，最常用的：在Servlet中处理好的数据要交给Jsp显示，此时参数就可以放置在Request域中带过去。
　　setAttribute、getAttribute、removeAttribute
        
    5.request实现请求转发
        ServletContext可以实现请求转发，request也可以。
　　　　this.getServletConttext().getRequestDispatcher("").forward(request,response);
　　　　request.getRequestDispatcher("").forward(request,response);
        在forward之前输入到response缓冲区中的数据，如果已经被发送到了客户端，forward将失败，抛出异常,即进行了response.getWriter().flush()刷新
        在forward之前输入到response缓冲区中的数据，但是还没有发送到客户端，forward可以执行，但是缓冲区将被清空，之前的数据丢失。注意丢失的只是请求体中的内容，头内容仍然有效。
        在一个Servlet中进行多次forward也是不行的，因为第一次forward结束，response已经被提交了，没有机会再forward了
        总之，一条原则,一次请求只能有一次响应，响应提交走后，就再没有机会输出数据给浏览器了。
        
    6.RequestDispatcher进行include操作
        forward没有办法将多个servlet的输出组成一个输出，因此RequestDispatcher提供了include方法，可以将多个Servlet的输出组成一个输出返回个浏览器
            request.getRequestDispatcher("/servlet/Demo17Servlet").include(request, response);
            response.getWriter().write("from Demo16");
            request.getRequestDispatcher("/servlet/Demo18Servlet").include(request, response);
        常用在页面的固定部分单独写入一个文件，在多个页面中include进来简化代码量。
　　
        
        
    
四、URL编码
    1.由于HTTP协议规定URL路径中只能存在ASCII码中的字符，所以如果URL中存在中文或特殊字符需要进行URL编码。
    2.编码原理：
        将空格转换为加号（+） 
        对0-9,a-z,A-Z之间的字符保持不变 
        对于所有其他的字符，用这个字符的当前字符集编码在内存中的十六进制格式表示，并在每个字节前加上一个百分号（%）。如字符“+”用%2B表示，字符“=”用%3D表示，字符“&”用%26表示，每个中文字符在内存中占两个字节，字符“中”用%D6%D0表示，字符“国”用%B9%FA表示调对于空格也可以直接使用其十六进制编码方式，即用%20表示，而不是将它转换成加号（+） 
        说明：
        如果确信URL串的特殊字符没有引起使用上的岐义或冲突你也可以对这些字符不进行编码，而是直接传递给服务器。例如，http://www.it315.org/dealregister.html?name=中国&password=123 
        如果URL串中的特殊字符可能会产生岐义或冲突，则必须对这些特殊字符进行URL编码。例如，服务器会将不编码的“中+国”当作“中国”处理。还例如，当name参数值为“中&国”时，如果不对其中的“&”编码，URL字符串将有如下形式：http://www.it315.org/dealregister.html?name=中&国&password=123，应编码为：http://www.it315.org/dealregister.html?name=中%26国&password=123 
        http://www.it315.org/example/index.html#section2可改写成http://www.it315.org/example%2Findex.html%23section2 
    3.在java中进行URL编码和解码
        URLencoder.encode("xxxx","utf-8");
        URLDecoder.decode(str,"utf-8");


五、请求重定向和请求转发的区别 
    1.区别
            RequestDispatcher.forward方法只能将请求转发给同一个WEB应用中的组件；而HttpServletResponse.sendRedirect 方法还可以重定向到同一个站点上的其他应用程序中的资源，甚至是使用绝对URL重定向到其他站点的资源。 
            如果传递给HttpServletResponse.sendRedirect 方法的相对URL以“/”开头，它是相对于服务器的根目录；如果创建RequestDispatcher对象时指定的相对URL以“/”开头，它是相对于当前WEB应用程序的根目录。 
            调用HttpServletResponse.sendRedirect方法重定向的访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL地址变成重定向的目标URL；调用RequestDispatcher.forward 方法的请求转发过程结束后，浏览器地址栏保持初始的URL地址不变。
            HttpServletResponse.sendRedirect方法对浏览器的请求直接作出响应，响应的结果就是告诉浏览器去重新发出对另外一个URL的访问请求；RequestDispatcher.forward方法在服务器端内部将请求转发给另外一个资源，浏览器只知道发出了请求并得到了响应结果，并不知道在服务器程序内部发生了转发行为。 
            RequestDispatcher.forward方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程；而HttpServletResponse.sendRedirect方法调用者与被调用者使用各自的request对象和response对象，它们属于两个独立的访问请求和响应过程。 
    2.应用场景（参照图想）
        通常情况下都用请求转发，减少服务器压力
        当需要更新地址栏时用请求重定向，如注册成功后跳转到主页。
        当需要刷新更新操作时用请求重定向，如购物车付款的操作。
六、常用地址的写法:      
    绝对路径:以/开头的路径就叫做绝对路径,绝对路径在相对于的路径上直接拼接得到最终的路径
    相对路径:不以/开头的路径就叫做相对路径,相对路径基于当前所在的路径计算的到最终的路径
    硬盘路径:以盘符开头的路径就叫做硬盘路径.是哪个路径就是哪个路径.没有相对于谁的问题

    虚拟路径: --写虚拟路径时都使用绝对路径
        如果路径是给浏览器用的,这个路径相对于虚拟主机,所以需要写上web应用的名称
        如果路径是个服务器用的,这个路径相对于web应用,所以可以省写web应用的名称
      <a href="/Day04/.....">
      <form action="/Day04/...">
      <img src="/Day04/....">
      response.setHeader("Location","/Day04/....");
      response.setHeader("refresh","3;url=/Day04/...");
      response.sendRedirect("/Day04/...");
      request.getRequestDispathce("/index.jsp").forward();
      request.getRequestDispathce("/index.jsp").include();

    真实路径: --写真实路径时都使用相对路径
        根据原理,具体问题具体分析
        
        servletContext.getRealPath("config.properties");//--给一个相对于web应用目录的路径
        classLoader.getResource("../../config.properties");//--给一个相对于类加载目录的路径
        
        File file = new File("config.properties");//--相对于程序的启动目录
        new InputStream("config.properties");//--相对于程序的启动目录
以上是关于11-Request&Response的主要内容，如果未能解决你的问题，请参考以下文章 
 JAVA request&response
 request&response
 request&response笔记
 Request & Response
 Request & response
 Request&Response