web-5-深入理解Servlet中的请求与响应对象

springboot葵花宝典 2023-07-30

596

请求(Request)和响应(Response)

今日目标

掌握Request对象的概念与使用
掌握Response对象的概念与使用

1. 请求(Request)和响应(Response)概述

Request是请求对象，Response是响应对象。==个对象在我们使用Servlet的时候有看到：思考:request和response这两个参数的作用是什么?

request:获取请求数据

浏览器会发送HTTP请求到后台服务器[Tomcat]
HTTP的请求中会包含很多请求数据[请求行+请求头+请求体]
后台服务器[Tomcat]会对HTTP请求中的数据进行解析并把解析结果存入到一个对象中
所存入的对象即为request对象，所以我们可以从request对象中获取请求的相关参数
获取到数据后就可以继续后续的业务，比如获取用户名和密码就可以实现登录操作的相关业务

response:设置响应数据

业务处理完后，后台就需要给前端返回业务处理的结果即响应数据
把响应数据封装到response对象中
后台服务器[Tomcat]会解析response对象,按照[响应行+响应头+响应体]格式拼接结果
浏览器最终解析结果，把内容展示在浏览器给用户浏览

现在通过一个案例来初步感受一下request和response对象的使用。

先创建一个web项目
在pom.xml中添加依赖

    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
<!--            因为tomcat存在servlet所以，我们只是在开发阶段使用，索引scope选择为provided-->
            <scope>provided</scope>
        </dependency>
    </dependencies>

创建一个Demo1Servlet

package com.zbbmeta.servlet.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;

@WebServlet("/demo1")
public class Demo1Servlet extends HttpServlet {

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

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Post...");
    }
}

启动成功后就可以通过浏览器来访问，并且根据传入参数的不同就可以在页面上展示不同的内容: 浏览器地址:http://localhost:8080/request-demo/demo1?name=lisi

注意: ?后面 name=lisi是我们传递参数

总结:

request对象和reponse对象作用:

request对象:用于封装请求数据
response对象:用于封装响应数据接下来我们分别具体介绍Request和Response对象。

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提供的，所以我们IDEA中查看,打开后可以看到:

所以ServletRequest和HttpServletRequest是继承关系，并且两个都是接口。思考:接口是无法创建对象，请求和响应参数由谁创建?

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

该类实现了HttpServletRequest接口，也间接实现了ServletRequest接口。
Servlet类中的service方法、doGet方法或者是doPost方法最终都是由Web服务器(Tomcat) 来调用的，所以Tomcat提供了方法参数接口的具体实现类，并完成了对象的创建

因为我们学习的Web服务器是Tomcat,所以实现类是RequestFacade，不同的Web服务器，实现类不同，不需要过多关注。

思考:如何验证RequestFacade是ServletRequest和HttpServletRequest的实现类?

实现:只需要在方法中把request对象打印下，就能看到最终的对象是不是RequestFacade,代码如下:

package com.zbbmeta.servlet.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;

/**
 * 查了HttpServletRequest接口的实现类
 */
@WebServlet("/demo2")
public class Demo2Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //将实现类输出的控制台
        System.out.println(req);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Post...");
    }
}

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

总结:

Request的继承体系为ServletRequest-->HttpServletRequest-->RequestFacade
Tomcat需要解析请求数据，封装为request对象,并且创建request对象传递到service方法

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方式): name=lisi&password=444

String getQueryString()

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

package com.zbbmeta.servlet.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;

@WebServlet("/req1")
public class Req1Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        String getMethod()：获取请求方式： GET
        System.out.println("请求方式: "+req.getMethod()); //GET
        
//        String getContextPath()：获取虚拟目录(项目访问路径)： /request-demo
        System.out.println("项目访问路径: "+req.getContextPath()); //request-demo
        
//        String getRequestURI()：获取URI(统一资源标识符)： /request-demo/req1
        System.out.println("URI: "+req.getRequestURI()); // /request-demo/req1
        
//        StringBuffer getRequestURL(): 获取URL(统一资源定位符)：http://localhost:8080/request-demo/req1
        System.out.println("URL: "+req.getRequestURL()); // http://localhost:8080/request-demo/req1
        
//        String getQueryString()：获取请求参数（GET方式）： username=zhangsan&password=123
        System.out.println("请求参数: "+req.getQueryString()); //name=lisi&password=4444

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Post...");
    }
}

启动服务器，访问http://localhost:8080/request-demo/req1?name=lisi&password=4444
，获取的结果如下:

2.2.2 获取请求头数据

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

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

String getHeader(String name)

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

package com.zbbmeta.servlet.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;

/**
 * 获取请求头数据
 */
@WebServlet("/req2")
public class Req2Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /**
         * 2.获取请求头数据
         */
        System.out.println(req.getHeader("user-agent"));
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Post...");
    }
}

重新启动服务器后，http://localhost:8080/request-demo/req2
，获取的结果如下:

2.2.3 获取请求体数据

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

name=lisi&password=4444

对于请求体中的数据，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>
</head>
<body>
  <!--
    action:form表单提交的请求地址
    method:请求方式，指定为post
  -->
  <form action="req3" method="post">
    <input type="text" name="name" placeholder="请输入用户名"> <br>
    <input type="password" name="password" placeholder="请输入密码"> <br>
    <input type="submit">
  </form>
</body>
</html>

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

package com.zbbmeta.servlet.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.BufferedReader;
import java.io.IOException;

/**
 * 获取请求体数据
 */
@WebServlet("/req3")
public class Req3Servlet extends HttpServlet {

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

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /**
         * 3.获取请求体，POST请求发送数据使用，GET请求没有请求体
         */
        //获取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请求接收参数的方式不一样，具体实现的代码如下:

package com.zbbmeta.servlet.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.BufferedReader;
import java.io.IOException;

/**
 * 获取请求参数通用方式
 */
@WebServlet("/req4")
public class Req4Servlet 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 {
        /**
         * 3.获取请求体，POST请求发送数据使用，GET请求没有请求体
         */
        //获取post 请求体：请求参数
        //1. 获取字符输入流
        BufferedReader br = req.getReader();
        //2. 读取数据
        String line = br.readLine();
        System.out.println(line);
    }
}

思考:上面代码会存在什么问题呢?

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

/**
 * 获取请求参数通用方式
 */
@WebServlet("/req4")
public class Req4Servlet 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);
    }
}

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

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

解决方案一:

package com.zbbmeta.servlet.request;
/**
 * 获取请求参数通用方式
 */
@WebServlet("/req4")
public class Req4Servlet 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)根据不同的请求方式获取请求参数，获取的内容如下:

name=lisi&hobby=1&hobby=2

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

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

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

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

获取所有参数Map集合

Map<String,String[]> getParameterMap()

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

String[] getParameterValues(String name)

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

String getParameter(String name)

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

1.创建req5.html页面，添加爱好选项，爱好可以同时选多个

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>请求提数据获取</title>
</head>
<body>
  <!--
    action:form表单提交的请求地址
    method:请求方式，指定为post
  -->
  <form action="req5" method="post">
    <input type="text" name="name" placeholder="请输入用户名"> <br>
    <input type="password" name="password" placeholder="请输入密码"> <br>
      <input type="checkbox" name="hobby" value="1"> 游泳
      <input type="checkbox" name="hobby" value="2"> 爬山 <br>
    <input type="submit">
  </form>
</body>
</html>

2.创建Req5Servlet类

package com.zbbmeta.servlet.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.BufferedReader;
import java.io.IOException;
import java.util.Map;

/**
 * 方式二:获取请求参数通用方式
 */
@WebServlet("/req5")
public class Req5Servlet 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 {
        System.out.println("post请求...");
        this.doGet(req,resp);
    }
}

3.在浏览器中输入地址http://localhost:8080/request-demo/req5?name=lisi&password&hobby=1&hobby=2

获取GET请求的结果为:

4. 访问http://localhost:8080/request-demo/req5.html
，输入用户名密码和爱好等信息，控制台结果如下
获取POST请求的结果为:

5 获取数组值

        //3.获取数组
        String[] hobbies = req.getParameterValues("hobby");
        for (String hobby : hobbies) {
            System.out.println(hobby);
        }

获取的GET请求结果为:

5 获取单个值

//        4.获取单个值
        String name = req.getParameter("name");
        System.out.println(name);

获取的结果为:

完整代码:

package com.zbbmeta.servlet.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.BufferedReader;
import java.io.IOException;
import java.util.Map;

/**
 * 方式二:获取请求参数通用方式
 */
@WebServlet("/req5")
public class Req5Servlet 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();
        }

        //3.获取数组
        String[] hobbies = req.getParameterValues("hobby");
        for (String hobby : hobbies) {
            System.out.println(hobby);
        }
//        4.获取单个值
        String name = req.getParameter("name");
        System.out.println(name);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("post请求...");
        this.doGet(req,resp);
    }
}

总结

req.getParameter()方法使用的频率会比较高

2.3 IDEA快速创建Servlet

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

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

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

#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( value = "/${Entity_Name}")
public class ${Class_Name} extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get请求
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post请求
        doGet(request,response);
    }
}

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

注意:使用模板创建的时候，需要在pom.xml中添加好servlet依赖

2.4 请求参数中文乱码问题

问题展示:

(1)创建req6.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>解决中文乱码</title>
</head>
<body>
<!--
  action:form表单提交的请求地址
  method:请求方式，指定为post
-->
<form action="req6" method="post">
  用户名: <input type="text" name="name" placeholder="请输入用户名"> <br>
  密码:<input type="password" name="password" placeholder="请输入密码"> <br>
  爱好:<input type="checkbox" name="hobby" value="1"> 游泳
  <input type="checkbox" name="hobby" value="2"> 爬山 <br>
  <input type="submit">
</form>
</body>
</html>

(2)创建Req6Servlet，并打印

package com.zbbmeta.servlet.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;

/**
 * 解决中文乱码
 */
@WebServlet("/req6")
public class Req6Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       //使用通用方式获取请求参数
       // 将结果输出到控制台
        //1. 获取username
        String username = req.getParameter("name");
        System.out.println(username);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("post请求...");
        this.doGet(req,resp);
    }
}

（3）启动服务器，访问地址:http://localhost:8080/request-demo/req6.html
，并提交，查看控制台打印内容

（5）上面发送的是POST请求，现在再打开一个浏览器窗口，发送请求http://localhost:8080/request-demo/req6?name=%E6%9D%8E%E5%9B%9B&password=4444&hobby=1&hobby=2
，发现结果，没有出现乱码:

发送GET和POST请求，在发送的请求参数中如果有中文，结果如下:

GET请求中文参数，不会乱码
POST请求中文参数，会乱码

思考: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也可以写成小写

修改后的代码为:

package com.zbbmeta.servlet.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;

/**
 * POST请求解决中文乱码
 */
@WebServlet("/req6")
public class Req6Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       //使用通用方式获取请求参数
       // 将结果输出到控制台
        //0.获取请求方式
        String method = req.getMethod();
        if("POST".equals(method)){
            //1. 解决乱码: POST getReader()
            //设置字符输入流的编码，设置的字符集要和页面保持一致
            req.setCharacterEncoding("UTF-8");
        }
        //1. 获取username
        String username = req.getParameter("name");
        System.out.println(username);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("post请求...");
        this.doGet(req,resp);
    }
}

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

总结

中文乱码解决方案

POST请求和GET请求的参数中如果有中文，后台接收数据就会出现中文乱码问题
GET请求在Tomcat8.0以后的版本就不会出现了
POST请求解决方案是:设置输入流的编码

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

2.5 Request请求转发

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

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

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

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

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

请求转发的实现方式:

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

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

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

(1)创建Req7Servlet类

package com.zbbmeta.servlet.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;
/**
 * 请求转发
 */
@WebServlet("/req7")
public class Req7Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("req7...");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

(2)创建Req8Servlet类

package com.zbbmeta.servlet.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;
/**
 * 请求转发
 */
@WebServlet("/req8")
public class Req8Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("req8...");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

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

package com.zbbmeta.servlet.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;
/**
 * 请求转发
 */
@WebServlet("/req7")
public class Req7Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("req7...");
        //请求转发
        req.getRequestDispatcher("/req8").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

(4)启动测试

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

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

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

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

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

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

void setAttribute(String name,Object o);

根据key获取值

Object getAttribute(String name);

根据key删除该键值对

void removeAttribute(String name);

接着上个需求来:

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

(1)修改Req7Servlet中的方法

package com.zbbmeta.servlet.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;
/**
 * 请求转发
 */
@WebServlet("/req7")
public class Req7Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("req7...");
        //存储数据,记住数据存储要在请求转发之前
        req.setAttribute("name","张三");

        //请求转发
        req.getRequestDispatcher("/req8").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

(2)修改Req8Servlet中的方法

package com.zbbmeta.servlet.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;

/**
 * 请求转发
 */
@WebServlet("/req8")
public class Req8Servlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("req8...");
        //获取数据
        Object msg = req.getAttribute("name");
        System.out.println(msg);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doGet(req,resp);
    }
}

(3)启动测试

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

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

请求转发的特点

浏览器地址栏路径不发生变化
虽然后台从/req7
转发到/req8
,但是浏览器的地址一直是/req7
,未发生变化

只能转发到当前服务器的内部资源
不能从一个服务器通过转发访问另一台服务器
一次请求，可以在转发资源间使用request共享数据
虽然后台从/req7
转发到/req8
，但是这个只是一次请求

3. Response对象

Request对象以及学习完，接下来回顾请求响应图:

Request:获取请求数据
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的访问路径");

或者

resp.sendRedirect("资源B的路径");

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

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

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

(1)创建Resp1Servlet类

package com.zbbmeta.servlet.response;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
/**
 * 重定向
 */
@WebServlet(value = "/resp1")
public class Resp1Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get请求
        System.out.println("resp1....");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post请求
        doGet(request, response);
    }
}

(2)创建ResponseDemo2类

package com.zbbmeta.servlet.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;
/**
 * 重定向
 */
@WebServlet(value = "/resp2")
public class Resp2Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get请求
        System.out.println("resp2....");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post请求
        doGet(request, response);
    }
}

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

package com.zbbmeta.servlet.response;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
/**
 * 重定向
 */
@WebServlet(value = "/resp1")
public class Resp1Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get请求
        System.out.println("resp1....");
        //重定向
        //1.设置响应状态码 302
        response.setStatus(302);
        //2. 设置响应头 Location
        response.setHeader("Location","resp2");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post请求
        doGet(request, response);
    }
}

(4)启动测试

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

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

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

response.sendRedirect("resp2");

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

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

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

重定向的特点

浏览器地址栏路径发送变化
当进行重定向访问的时候，由于是由浏览器发送的两次请求，所以地址会发生变化

可以重定向到任何位置的资源(服务内容、外部均可)
因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。
两次请求，不能在多个资源使用request共享数据
因为浏览器发送了两次请求，是两个不同的request对象，就无法通过request对象进行共享数据

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

重定向特点:	请求转发特点:
浏览器地址栏发送变化	浏览器地址栏不发生变化
重定向可以定向到任务位置资源	只可以定向到服务器内部资源
两次请求，不能在多个资源间使用request数据共享	一次请求，可以在转发的时候资源间使用request进行数据共享

3.3 Response响应体数据

在前面我们以及学习获取响应数据的响应行，响应头,还差响应体数据获取没有学习，现在我们就开始学习。响应体数据学习分为两部分:

响应字符数据
响应字节数据

3.3.1 Response响应字符数据

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

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

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

返回一个简单的字符串aaa

package com.zbbmeta.servlet.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;

/**
 * 设置响应字符数据
 */
@WebServlet(value = "/resp3")
public class Resp3Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get请求
        //1.解析响应数据中文乱码
        response.setContentType("text/html;charset=utf-8");
        //2. 获取字符输出流
        PrintWriter writer = response.getWriter();
        writer.write("你好 响应字符数据");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post请求
        doGet(request, response);
    }
}

注意:

response.setContentType("text/html;charset=utf-8");

保证响应数据说是中文的时候不会出现乱码

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

writer.write("<h1>你好 响应字符数据</h1>");

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

package com.zbbmeta.servlet.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;
/**
 * 设置响应字符数据
 */
@WebServlet(value = "/resp3")
public class Resp3Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get请求
        //1.解析响应数据中文乱码
        response.setContentType("text/html;charset=utf-8");
        //2. 获取字符输出流
        PrintWriter writer = response.getWriter();
        writer.write("你好 响应字符数据");
        writer.write("<h1>你好 响应字符数据</h1>");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post请求
        doGet(request, response);
    }
}

3.3.2 Response响应字节数据

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

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

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

2.创建Resp4Servlet类

package com.zbbmeta.servlet.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;
/*
 * 设置响应字节数据
 */
@WebServlet(value = "/resp4")
public class Resp4Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get请求
        //1.读取文件
        //1.1获取文件
        try {
            String file = this.getClass().getClassLoader().getResource("star.png").getFile();
            //1. 读取文件
            FileInputStream fis = new FileInputStream(file);
            //2. 获取response字节输出流
            ServletOutputStream os = response.getOutputStream();
            //3. 完成流的copy
            byte[] buff = new byte[1024*8];
            int len = 0;
            while ((len = fis.read(buff))!= -1){
                os.write(buff,0,len);
            }
            fis.close();
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post请求
        doGet(request, response);
    }
}

上述代码中，对于流的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.zbbmeta.servlet.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;
/*
 * 设置响应字节数据
 */
@WebServlet(value = "/resp4")
public class Resp4Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //get请求
        //1.读取文件
        //1.1获取文件
        try {
            String file = this.getClass().getClassLoader().getResource("star.png").getFile();
            //1. 读取文件
            FileInputStream fis = new FileInputStream(file);
            //2. 获取response字节输出流
            ServletOutputStream os = response.getOutputStream();
            //fis:输入流
            //os:输出流
            IOUtils.copy(fis,os);
            fis.close();
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //post请求
        doGet(request, response);
    }
}

文章转载自springboot葵花宝典，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

web-5-深入理解Servlet中的请求与响应对象

请求(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.5 Request请求转发

3. Response对象

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

3.2 Respones请求重定向

3.3 Response响应体数据

3.3.1 Response响应字符数据

3.3.2 Response响应字节数据

评论