【JavaWeb】--05.Request和Response、JSP、会话技术

学习视频： 黑马程序员JavaWeb学习视频

Request和Response

1.概述

• 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("
"+name+",欢迎您！
");
    }

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

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

小结

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

2.Request对象

2.1 Request继承体系

• 当我们的Servlet类实现的是Servlet接口的时候，service方法中的参数是ServletRequest和ServletResponse

• 当我们的Servlet类继承的是HttpServlet类的时候，doGet和doPost方法中的参数就变成HttpServletRequest和HttpServletReponse

• ServletRequest和HttpServletRequest的关系是什么?

• request对象是有谁来创建的?

首先，先来看下Request的继承体系:

从上图中可以看出，ServletRequest和HttpServletRequest都是Java提供的

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

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

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

Tomcat需要解析请求数据，封装为request对象，并且创建request对象传递到service方法中

对于上述结论，要想验证，可以编写一个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.2Request获取请求数据

HTTP请求数据总共分为三部分内容，分别是请求行、请求头、请求体

获取请求行数据

请求行包含三块内容，分别是请求方式、请求资源路径、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，获取的结果如下:

获取请求头数据

对于请求头的数据，格式为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，获取的结果如下:

获取请求体数据

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

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

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

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

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

BufferedReader getReader()

具体实现的步骤如下:

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

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

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

4.访问测试

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

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>

<form action="/request-demo/req1" method="post">
    <input type="text" name="username">
    <input type="password" name="password">
    <input type="submit">
form>
body>
html>

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

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

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

小结

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

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

获取请求参数的通用方式

• 什么是请求参数?
• 请求参数和请求数据的关系是什么?

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

需要注意的是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 getParameterMap()

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

String[] getParameterValues(String name)

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

String getParameter(String name)

对上述三个方法进行演示：

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

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
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

    
    



    

    

     游泳
     爬山 

    

(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请求，在发送的请求参数中如果有中文，在后台接收的时候，都会出现中文乱码的问题。具体该如何解决呢？

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请求

GET请求解决方案

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

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

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

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

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

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

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

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

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

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

介绍一下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解码
• 在控制台就会出现类上å¼ ä¸‰的乱码，最后一位是个空格

2. 清楚了出现乱码的原因，解决方法如下：

从上图可以看住，

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

小结

1. 中文乱码解决方案

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

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

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

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

• 通用方式（GET/POST）：需要先解码，再编码

  new String(username.getBytes("ISO-8859-1"),"UTF-8");
  

2. URL编码实现方式:

• 编码:

  URLEncoder.encode(str,"UTF-8");
  

• 解码:

  URLDecoder.decode(s,"ISO-8859-1");
  

2.5 Request请求转发

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

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

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

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

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

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

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

3. 请求转发资源间共享数据：使用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,就可以在控制台看到如下内容:

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

4. 请求转发的特点

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

  虽然后台从/req5转发到/req6,但是浏览器的地址一直是/req5,未发生变化

  

• 只能转发到当前服务器的内部资源

  不能从一个服务器通过转发访问另一台服务器

• 一次请求，可以在转发资源间使用request共享数据

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

3.Response对象

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

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

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

HTTP响应数据总共分为三部分内容，分别是响应行、响应头、响应体

1. 响应行

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

void setStatus(int sc);

2. 响应头

设置响应头键值对：

void setHeader(String name,String value);

3. 响应体

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

获取字符输出流:

PrintWriter getWriter();

获取字节输出流

ServletOutputStream getOutputStream();

3.2 Response请求重定向

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

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

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

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

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

2. 重定向的实现方式:

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

3. 重定向的特点

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

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

  

• 可以重定向到任何位置的资源(服务内容、外部均可)

  因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。

• 两次请求，不能在多个资源使用request共享数据

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

介绍完请求重定向和请求转发以后，两者对比：

3.3 路径问题

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

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

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

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

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

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

• req.getRequestDispatcher(“路径”)
• resp.sendRedirect(“路径”)

答案:

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

2. 问题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”);

具体实现：

1. 返回一个简单的字符串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);
    }
}

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

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

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

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

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

3.5 Response响应字节数据

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

• 通过Response对象获取字节输出流：ServletOutputStream outputStream = resp.getOutputStream();

• 通过字节输出流写数据: outputStream.write(字节数据);

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

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

/**
 * 响应字节数据：设置字节数据的响应体
 */
@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-iogroupId>
    <artifactId>commons-ioartifactId>
    <version>2.6version>
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, IOException {
        //1. 读取文件
        FileInputStream fis = new FileInputStream("d://a.jpg");
        //2. 获取response字节输出流
        ServletOutputStream os = response.getOutputStream();
        //3. 完成流的copy
      	IOUtils.copy(fis,os);
        fis.close();
    }

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

4.用户注册登录案例

4.1 用户登录

4.1.1 需求分析

1. 用户在登录页面输入用户名和密码，提交请求给LoginServlet
2. 在LoginServlet中接收请求和数据[用户名和密码]
3. 在LoginServlt中通过Mybatis实现调用UserMapper来根据用户名和密码查询数据库表
4. 将查询的结果封装到User对象中进行返回
5. 在LoginServlet中判断返回的User对象是否为null
6. 如果为nul，说明根据用户名和密码没有查询到用户，则登录失败，返回"登录失败"数据给前端
7. 如果不为null,则说明用户存在并且密码正确，则登录成功，返回"登录成功"数据给前端

4.1.2 环境准备

1.复制资料中的静态页面到项目的webapp目录下

2.创建db1数据库，创建tb_user表，创建User实体类

3.在项目的pom.xml导入Mybatis和Mysql驱动坐标

<dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>3.5.5version>
dependency>

<dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.32version>
dependency>

4.创建mybatis-config.xml核心配置文件，UserMapper.xml映射文件,UserMapper接口

在com.itheima.mapper包下创建UserMapper接口

public interface UserMapper {

}

4.1.3 代码实现

1. 在UserMapper接口中提供一个根据用户名和密码查询用户对象的方法

/**
     * 根据用户名和密码查询用户对象
     * @param username
     * @param password
     * @return
     */
    @Select("select * from tb_user where username = #{username} and password = #{password}")
    User select(@Param("username") String username,@Param("password")  String password);

说明

@Param注解的作用:用于传递参数,是方法的参数可以与SQL中的字段名相对应。

2. 修改loign.html

DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>logintitle>
    <link href="css/login.css" rel="stylesheet">
head>

<body>
<div id="loginDiv">
    <form action="/request-demo/loginServlet" method="post" id="form">
        <h1 id="loginMsg">LOGIN INh1>
        <p>Username:<input id="username" name="username" type="text">p>

        <p>Password:<input id="password" name="password" type="password">p>

        <div id="subDiv">
            <input type="submit" class="button" value="login up">
            <input type="reset" class="button" value="reset">   
            <a href="register.html">没有账号？点击注册a>
        div>
    form>
div>

body>
html>

3. 编写LoginServlet

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 接收用户名和密码
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        //2. 调用MyBatis完成查询
        //2.1 获取SqlSessionFactory对象
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //2.2 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //2.3 获取Mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //2.4 调用方法
        User user = userMapper.select(username, password);
        //2.5 释放资源
        sqlSession.close();


        //获取字符输出流，并设置content type
        response.setContentType("text/html;charset=utf-8");
        PrintWriter writer = response.getWriter();
        //3. 判断user释放为null
        if(user != null){
            // 登陆成功
            writer.write("登陆成功");
        }else {
            // 登陆失败
            writer.write("登陆失败");
        }
    }

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

4. 启动服务器测试

4.1 如果用户名和密码输入错误，则

4.2 如果用户名和密码输入正确，则

至此用户的登录功能就已经完成了~

4.2 用户注册

4.2.1 需求分析

1. 用户在注册页面输入用户名和密码，提交请求给RegisterServlet
2. 在RegisterServlet中接收请求和数据[用户名和密码]
3. 在RegisterServlet中通过Mybatis实现调用UserMapper来根据用户名查询数据库表
4. 将查询的结果封装到User对象中进行返回
5. 在RegisterServlet中判断返回的User对象是否为null
6. 如果为nul，说明根据用户名可用，则调用UserMapper来实现添加用户
7. 如果不为null,则说明用户不可以，返回"用户名已存在"数据给前端

4.2.2 代码编写

1. 编写UserMapper提供根据用户名查询用户数据方法和添加用户方法

/**
* 根据用户名查询用户对象
* @param username
* @return
*/
@Select("select * from tb_user where username = #{username}")
User selectByUsername(String username);

/**
* 添加用户
* @param user
*/
@Insert("insert into tb_user values(null,#{username},#{password})")
void add(User user);

2. 修改register.html

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>欢迎注册title>
    <link href="css/register.css" rel="stylesheet">
head>
<body>

<div class="form-div">
    <div class="reg-content">
        <h1>欢迎注册h1>
        <span>已有帐号？span> <a href="login.html">登录a>
    div>
    <form id="reg-form" action="/request-demo/registerServlet" method="post">

        <table>

            <tr>
                <td>用户名td>
                <td class="inputs">
                    <input name="username" type="text" id="username">
                    <br>
                    <span id="username_err" class="err_msg" style="display: none">用户名不太受欢迎span>
                td>

            tr>

            <tr>
                <td>密码td>
                <td class="inputs">
                    <input name="password" type="password" id="password">
                    <br>
                    <span id="password_err" class="err_msg" style="display: none">密码格式有误span>
                td>
            tr>

        table>

        <div class="buttons">
            <input value="注 册" type="submit" id="reg_btn">
        div>
        <br class="clear">
    form>

div>
body>
html>

3. 创建RegisterServlet类

@WebServlet("/registerServlet")
public class RegisterServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 接收用户数据
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        //封装用户对象
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);

        //2. 调用mapper 根据用户名查询用户对象
        //2.1 获取SqlSessionFactory对象
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //2.2 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //2.3 获取Mapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //2.4 调用方法
        User u = userMapper.selectByUsername(username);

        //3. 判断用户对象释放为null
        if( u == null){
            // 用户名不存在，添加用户
            userMapper.add(user);

            // 提交事务
            sqlSession.commit();
            // 释放资源
            sqlSession.close();
        }else {
            // 用户名存在，给出提示信息
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("用户名已存在");
        }

    }

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

4. 启动服务器进行测试

4.1 如果测试成功，则在数据库中就能查看到新注册的数据

4.2 如果用户已经存在，则在页面上展示 用户名已存在 的提示信息

4.3 SqlSessionFactory工具类抽取

上面两个功能已经实现，但是在写Servlet的时候，因为需要使用Mybatis来完成数据库的操作，所以对于Mybatis的基础操作就出现了些重复代码，如下

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new 
	SqlSessionFactoryBuilder().build(inputStream);

有了这些重复代码就会造成一些问题:

• 重复代码不利于后期的维护
• SqlSessionFactory工厂类进行重复创建
  • 就相当于每次买手机都需要重新创建一个手机生产工厂来给你制造一个手机一样，资源消耗非常大但性能却非常低。所以这么做是不允许的。

那如何来优化呢？

• 代码重复可以抽取工具类
• 对指定代码只需要执行一次可以使用静态代码块

代码编写：

public class SqlSessionFactoryUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        //静态代码块会随着类的加载而自动执行，且只执行一次
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static SqlSessionFactory getSqlSessionFactory(){
        return sqlSessionFactory;
    }
}

工具类抽取以后，以后在对Mybatis的SqlSession进行操作的时候，就可以直接使用

SqlSessionFactory sqlSessionFactory =SqlSessionFactoryUtils.getSqlSessionFactory();

这样就可以很好的解决上面所说的代码重复和重复创建工厂导致性能低的问题了。

JSP

1.概述

==JSP（全称：Java Server Pages）：Java 服务端页面。==是一种动态的网页技术，其中既可以定义 HTML、JS、CSS等静态内容，还可以定义 Java代码的动态内容，也就是 JSP = HTML + Java。如下就是jsp代码

    
        
    
    
        
JSP,Hello World
        <%
        	System.out.println("hello,jsp~");
        %>
    

上面代码 h1 标签内容是展示在页面上，而 Java 的输出语句是输出在 idea 的控制台。

那么，JSP 能做什么呢？现在我们只用 servlet 实现功能，看存在什么问题。如下图所示，当我们登陆成功后，需要在页面上展示用户名

上图的用户名是动态展示，也就是谁登陆就展示谁的用户名。只用 servlet 如何实现呢？提供了一个 LoginServlet ，该 servlet 就是实现这个功能的

输入了 zhangsan 用户的登陆信息后点击 登陆 按钮，就能看到如下图效果

当然如果是 lisi 登陆的，在该页面展示的就是 lisi,欢迎您，动态的展示效果就实现了。那么 LoginServlet 到底是如何实现的，我们看看它里面的内容

上面的代码有大量使用到 writer 对象向页面写标签内容，这样代码就显得很麻烦；将来如果展示的效果出现了问题，排错也显得有点力不从心。而 JSP 是如何解决这个问题的呢？在资料中也提供了一个 login.jsp 页面，该页面也能实现该功能，现将该页面拷贝到项目的 webapp下，需要修改 login.html 中表单数据提交的路径为下图

重新启动服务器并进行测试，发现也可以实现同样的功能。那么 login.jsp 又是如何实现的呢？那我们来看看 login.jsp 的代码

上面代码可以看到里面基本都是 HTML 标签，而动态数据使用 Java 代码进行展示；这样操作看起来要比用 servlet 实现要舒服很多。

JSP 作用：简化开发，避免了在Servlet中直接输出HTML标签。

2.JSP快速入门

2.1 搭建环境

创建一个maven的 web 项目，项目结构如下：

pom.xml 文件内容如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>org.examplegroupId>
    <artifactId>jsp-demoartifactId>
    <version>1.0-SNAPSHOTversion>
    <packaging>warpackaging>

    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>

    <dependencies>
      <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>javax.servlet-apiartifactId>
            <version>3.1.0version>
            <scope>providedscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.mavengroupId>
                <artifactId>tomcat7-maven-pluginartifactId>
                <version>2.2version>
            plugin>
        plugins>
    build>
project>

2.2导入 JSP 依赖

在 dependencies 标签中导入 JSP 的依赖，如下

<dependency>
    <groupId>javax.servlet.jspgroupId>
    <artifactId>jsp-apiartifactId>
    <version>2.2version>
    <scope>providedscope>
dependency>

该依赖的 scope 必须设置为 provided，因为 tomcat 中有这个jar包了，所以在打包时是不希望将该依赖打进到我们工程的war包中。

2.3创建 jsp 页面

在项目的 webapp 下创建jsp页面

通过上面方式创建一个名为 hello.jsp 的页面

2.4编写代码

在 hello.jsp 页面中书写 HTML 标签和 Java 代码，如下

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


    
hello jsp

    <%
        System.out.println("hello,jsp~");
    %>

2.5测试

启动服务器并在浏览器地址栏输入 http://localhost:8080/jsp-demo/hello.jsp，我们可以在页面上看到如下内容

同时也可以看到在 idea 的控制台看到输出的 hello,jsp~ 内容。

3.JSP原理

JSP 本质上就是一个 Servlet。

1. 浏览器第一次访问 hello.jsp 页面
2. tomcat 会将 hello.jsp 转换为名为 hello_jsp.java 的一个 Servlet
3. tomcat 再将转换的 servlet 编译成字节码文件 hello_jsp.class
4. tomcat 会执行该字节码文件，向外提供服务

可以到项目所在磁盘目录下找 target\tomcat\work\Tomcat\localhost\jsp-demo\org\apache\jsp 目录，而这个目录下就能看到转换后的 servlet

打开 hello_jsp.java 文件，来查看里面的代码

由上面的类的继承关系可以看到继承了名为 HttpJspBase 这个类，那我们在看该类的继承关系。到资料中的找如下目录： 资料\tomcat源码\apache-tomcat-8.5.68-src\java\org\apache\jasper\runtime ，该目录下就有 HttpJspBase 类，查看该类的继承关系

可以看到该类继承了 HttpServlet ；那么 hello_jsp 这个类就间接的继承了 HttpServlet ，也就说明 hello_jsp 是一个 servlet。

继续阅读 hello_jsp 类的代码，可以看到有一个名为 _jspService() 的方法，该方法就是每次访问 jsp 时自动执行的方法，和 servlet 中的 service 方法一样 。

而在 _jspService() 方法中可以看到往浏览器写标签的代码：

以前我们自己写 servlet 时，这部分代码是由我们自己来写，现在有了 jsp 后，由tomcat完成这部分功能。

4.JSP脚本

JSP脚本用于在 JSP页面内定义 Java代码。

4.1JSP 脚本分类

JSP 脚本有如下三个分类：

• <%…%>：内容会直接放到_jspService()方法之中
• <%=…%>：内容会放到out.print()中，作为out.print()的参数
• <%!…%>：内容会放到_jspService()方法之外，被类直接包含

代码演示：

在 hello.jsp 中书写

<%
    System.out.println("hello,jsp~");
    int i = 3;
%>

通过浏览器访问 hello.jsp 后，查看转换的 hello_jsp.java 文件，i 变量定义在了 _jspService() 方法中

在 hello.jsp 中书写

<%="hello"%>
<%=i%>

通过浏览器访问 hello.jsp 后，查看转换的 hello_jsp.java 文件，该脚本的内容被放在了 out.print() 中，作为参数

在 hello.jsp 中书写

<%!
    void  show(){}
	String name = "zhangsan";
%>

通过浏览器访问 hello.jsp 后，查看转换的 hello_jsp.java 文件，该脚本的内容被放在了成员位置

4.2 案例

4.2.1 需求

使用JSP脚本展示品牌数据

说明：

• 在资料 资料\1. JSP案例素材 中提供了 brand.html 静态页面
• 在该案例中数据不从数据库中查询，而是在 JSP 页面上写死

4.2.2实现

• 将资料 资料\1. JSP案例素材 中的 Brand.java 文件放置到项目的 com.itheima.pojo 包下

• 在项目的 webapp 中创建 brand.jsp ，并将 brand.html页面中的内容拷贝过来。brand.jsp 内容如下

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  
  
  
      
      
  
  
  
  
  
      
  
          
  
              
  序号
              
  品牌名称
              
  企业名称
              
  排序
              
  品牌介绍
              
  状态
              
  操作
  
          
          
  
              
  1
              
  三只松鼠
              
  三只松鼠
              
  100
              
  三只松鼠，好吃不上火
              
  启用
              
  修改 删除
          
  
          
  
              
  2
              
  优衣库
              
  优衣库
              
  10
              
  优衣库，服适人生
              
  禁用
  
              
  修改 删除
          
  
          
  
              
  3
              
  小米
              
  小米科技有限公司
              
  1000
              
  为发烧而生
              
  启用
  
              
  修改 删除
          
      
  
  
  

  现在页面中的数据都是假数据。

• 在 brand.jsp 中准备一些数据

  <%
      // 查询数据库
      List brands = new ArrayList();
      brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
      brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
      brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));
  %>
  

• 将 brand.jsp 页面中的 table 标签中的数据改为动态的

  
      
      <%
       for (int i = 0; i < brands.size(); i++) {
           //获取集合中的 每一个 Brand 对象
           Brand brand = brands.get(i);
       }
      %>
      
  
      
  
          
  序号
          
  品牌名称
          
  企业名称
          
  排序
          
  品牌介绍
          
  状态
          
  操作
  
      
  
          
  1
          
  三只松鼠
          
  三只松鼠
          
  100
          
  三只松鼠，好吃不上火
          
  启用
          
  修改 删除
      
  
  

  上面的for循环需要将 tr 标签包裹起来，这样才能实现循环的效果，代码改进为

  
      
      <%
       for (int i = 0; i < brands.size(); i++) {
           //获取集合中的 每一个 Brand 对象
           Brand brand = brands.get(i);
      %>
      	 
      <%
       }
      %>
     
  
      
  
          
  序号
          
  品牌名称
          
  企业名称
          
  排序
          
  品牌介绍
          
  状态
          
  操作
  
      
  
              
  1
              
  三只松鼠
              
  三只松鼠
              
  100
              
  三只松鼠，好吃不上火
              
  启用
              
  修改 删除
          
  

  注意：<%%> 里面写的是 Java 代码，而外边写的是 HTML 标签

  上面代码中的 td 标签中的数据都需要是动态的，所以还需要改进

  
      
      <%
       for (int i = 0; i < brands.size(); i++) {
           //获取集合中的 每一个 Brand 对象
           Brand brand = brands.get(i);
      %>
      	 
      <%
       }
      %>
     
  
      
  
          
  序号
          
  品牌名称
          
  企业名称
          
  排序
          
  品牌介绍
          
  状态
          
  操作
  
      
  
              
  <%=brand.getId()%>
              
  <%=brand.getBrandName()%>
              
  <%=brand.getCompanyName()%>
              
  <%=brand.getOrdered()%>
              
  <%=brand.getDescription()%>
              
  <%=brand.getStatus() == 1 ? "启用":"禁用"%>
              
  修改 删除
          
  

4.2.3成品代码

<%@ page import="com.itheima.pojo.Brand" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%
    // 查询数据库
    List brands = new ArrayList();
    brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
    brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
    brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));

%>





    
    






    <%
        for (int i = 0; i < brands.size(); i++) {
            Brand brand = brands.get(i);
    %>

    

    <%
        }
    %>

    

        
序号
        
品牌名称
        
企业名称
        
排序
        
品牌介绍
        
状态
        
操作
    

        
<%=brand.getId()%>
        
<%=brand.getBrandName()%>
        
<%=brand.getCompanyName()%>
        
<%=brand.getOrdered()%>
        
<%=brand.getDescription()%>
		
<%=brand.getStatus() == 1 ? "启用":"禁用"%>
        
修改 删除
    

4.2.4测试

在浏览器地址栏输入 http://localhost:8080/jsp-demo/brand.jsp ，页面展示效果如下

4.3JSP缺点

由于 JSP页面内，既可以定义 HTML 标签，又可以定义 Java代码，造成了以下问题：

• 书写麻烦：特别是复杂的页面

  既要写 HTML 标签，还要写 Java 代码

• 阅读麻烦

• 复杂度高：运行需要依赖于各种环境，JRE，JSP容器，JavaEE…

• 占内存和磁盘：JSP会自动生成.java和.class文件占磁盘，运行的是.class文件占内存

• 调试困难：出错后，需要找到自动生成的.java文件进行调试

• 不利于团队协作：前端人员不会 Java，后端人员不精 HTML

  如果页面布局发生变化，前端工程师对静态页面进行修改，然后再交给后端工程师，由后端工程师再将该页面改为 JSP 页面

由于上述的问题， ==JSP 已逐渐退出历史舞台，==以后开发更多的是使用 HTML + Ajax 来替代，有个这个技术后，前端工程师负责前端页面开发，而后端工程师只负责前端代码开发。下来对技术的发展进行简单的说明

1. 第一阶段：使用 servlet 即实现逻辑代码编写，也对页面进行拼接。这种模式我们之前也接触过

2. 第二阶段：随着技术的发展，出现了 JSP ，人们发现 JSP 使用起来比 Servlet 方便很多，但是还是要在 JSP 中嵌套 Java 代码，也不利于后期的维护

3. 第三阶段：使用 Servlet 进行逻辑代码开发，而使用 JSP 进行数据展示

   

4. 第四阶段：使用 servlet 进行后端逻辑代码开发，而使用 HTML 进行数据展示。而这里面就存在问题，HTML 是静态页面，怎么进行动态数据展示呢？这就是 ajax 的作用了。

那既然 JSP 已经逐渐的退出历史舞台，那我们为什么还要学习 JSP 呢？原因有两点：

• 一些公司可能有些老项目还在用 JSP ，所以要求我们必须懂JSP
• 我们如果不经历这些复杂的过程，就不能体现后面阶段开发的简单

使用 EL表达式 和 JSTL 标签库替换 JSP 中的 Java 代码。

5.EL表达式

5.1 概述

EL（全称Expression Language ）表达式语言，用于简化 JSP 页面内的 Java 代码。

EL 表达式的主要作用是 获取数据。其实就是从域对象中获取数据，然后将数据展示在页面上。

而 EL 表达式的语法也比较简单，==$expression==。例如：${brands} 就是获取域中存储的 key 为 brands 的数据。

5.2代码演示

• 定义servlet，在 servlet 中封装一些数据并存储到 request 域对象中并转发到 el-demo.jsp 页面。

  @WebServlet("/demo1")
  public class ServletDemo1 extends HttpServlet {
      @Override
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          //1. 准备数据
          List<Brand> brands = new ArrayList<Brand>();
          brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
          brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
          brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));
  
          //2. 存储到request域中
          request.setAttribute("brands",brands);
  
          //3. 转发到 el-demo.jsp
          request.getRequestDispatcher("/el-demo.jsp").forward(request,response);
      }
  
      @Override
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          this.doGet(request, response);
      }
  }
  

  注意： 此处需要用转发，因为转发才可以使用 request 对象作为域对象进行数据共享

• 在 el-demo.jsp 中通过 EL表达式 获取数据

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  
  
      
  
  
      ${brands}
  
  
  

• 在浏览器的地址栏输入 http://localhost:8080/jsp-demo/demo1 ，页面效果如下：

  

5.3 域对象

JavaWeb中有四大域对象，分别是：

• page：当前页面有效
• request：当前请求有效
• session：当前会话有效
• application：当前应用有效

el 表达式获取数据，会依次从这4个域中寻找，直到找到为止。而这四个域对象的作用范围如下图所示

例如： ${brands}，el 表达式获取数据，会先从page域对象中获取数据，如果没有再到 requet 域对象中获取数据，如果再没有再到 session 域对象中获取，如果还没有才会到 application 中获取数据。

6.JSTL标签

6.1概述

JSP标准标签库(Jsp Standarded Tag Library) ，使用标签取代JSP页面上的Java代码。如下代码就是JSTL标签

    男


    女

上述代码比JSP中嵌套Java代码看起来更舒服。而且前端工程师对标签是特别敏感的，他们看到这段代码是能看懂的。

JSTL 提供了很多标签，如下图

介绍两个常用标签 标签和 标签。

JSTL 使用也是比较简单的，分为如下步骤：

• 导入坐标

  <dependency>
      <groupId>jstlgroupId>
      <artifactId>jstlartifactId>
      <version>1.2version>
  dependency>
  <dependency>
      <groupId>taglibsgroupId>
      <artifactId>standardartifactId>
      <version>1.1.2version>
  dependency>
  

• 在JSP页面上引入JSTL标签库

  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
  

• 使用标签

6.2 if标签

：相当于 if 判断

• 属性：test，用于定义条件表达式

    男


    女

代码演示：

• 定义一个 servlet ，在该 servlet 中向 request 域对象中添加 键是 status ，值为 1 的数据

  @WebServlet("/demo2")
  public class ServletDemo2 extends HttpServlet {
      @Override
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          //1. 存储数据到request域中
          request.setAttribute("status",1);
  
          //2. 转发到 jstl-if.jsp
          数据request.getRequestDispatcher("/jstl-if.jsp").forward(request,response);
      }
  
      @Override
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          this.doGet(request, response);
      }
  }
  

• 定义 jstl-if.jsp 页面，在该页面使用 标签

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  
  
      
  
  
      <%--
          c:if：来完成逻辑判断，替换java  if else
      --%>
      
          启用
      
  
      
          禁用
      
  
  
  

  注意： 在该页面已经要引入 JSTL核心标签库

  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

6.3 forEach标签

：相当于 for 循环。java中有增强for循环和普通for循环，JSTL 中的 也有两种用法

用法一：

类似于 Java 中的增强for循环。涉及到的 中的属性如下

• items：被遍历的容器

• var：遍历产生的临时变量

• varStatus：遍历状态对象

如下代码，是从域对象中获取名为 brands 数据，该数据是一个集合；遍历遍历，并给该集合中的每一个元素起名为 brand，是 Brand对象。在循环里面使用 EL表达式获取每一个Brand对象的属性值

    
        ${brand.id}
        ${brand.brandName}
        ${brand.companyName}
        ${brand.description}
    

代码演示：

• servlet 还是使用之前的名为 ServletDemo1 。

• 定义名为 jstl-foreach.jsp 页面，内容如下：

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  
  
  
  
      
      
  
  
  
  
  
  
          
              <%----%>
              
                  
                  
  
      
  
          
  序号
          
  品牌名称
          
  企业名称
          
  排序
          
  品牌介绍
          
  状态
          
  操作
      
  
      
  ${brand.id}
  ${status.count}
              
  ${brand.brandName}
              
  ${brand.companyName}
              
  ${brand.ordered}
              
  ${brand.description}
              
  启用
              
              
  禁用
              
              
  修改 删除
          
      
  
  
  
  

用法二：

类似于 Java 中的普通for循环。涉及到的 中的属性如下

• begin：开始数

• end：结束数

• step：步长

实例代码：

从0循环到10，变量名是 i ，每次自增1

    ${i}

7.MVC模式和三层架构

7.1 MVC模式

MVC 是一种分层开发的模式，其中：

• M：Model，业务模型，处理业务

• V：View，视图，界面展示

• C：Controller，控制器，处理请求，调用模型和视图

控制器（serlvlet）用来接收浏览器发送过来的请求，控制器调用模型（JavaBean）来获取数据，比如从数据库查询数据；控制器获取到数据后再交由视图（JSP）进行数据展示。

MVC 好处：

• 职责单一，互不影响。每个角色做它自己的事，各司其职。

• 有利于分工协作。

• 有利于组件重用

7.2三层架构

三层架构是将我们的项目分成了三个层面，分别是 表现层、业务逻辑层、数据访问层。

• 数据访问层：对数据库的CRUD基本操作
• 业务逻辑层：对业务逻辑进行封装，组合数据访问层层中基本功能，形成复杂的业务逻辑功能。例如 注册业务功能 ，我们会先调用 数据访问层 的 selectByName() 方法判断该用户名是否存在，如果不存在再调用 数据访问层 的 insert() 方法进行数据的添加操作
• 表现层：接收请求，封装数据，调用业务逻辑层，响应数据

而整个流程是，浏览器发送请求，表现层的Servlet接收请求并调用业务逻辑层的方法进行业务逻辑处理，而业务逻辑层方法调用数据访问层方法进行数据的操作，依次返回到serlvet，然后servlet将数据交由 JSP 进行展示。

三层架构的每一层都有特有的包名称：

• 表现层： com.itheima.controller 或者 com.itheima.web
• 业务逻辑层：com.itheima.service
• 数据访问层：com.itheima.dao 或者 com.itheima.mapper

不同的框架是对不同层进行封装的

7.3 MVC和三层架构

MVC和三层架构的联系：

如上图上半部分是 MVC 模式，上图下半部分是三层架构。 MVC 模式 中的 C（控制器）和 V（视图）就是 三层架构 中的表现层，而 MVC 模式 中的 M（模型）就是 三层架构 中的 业务逻辑层 和 数据访问层。

可以将 MVC 模式 理解成是一个大的概念，而 三层架构 是对 MVC 模式 实现架构的思想。

会话技术

1.概述

首先要理解什么是会话，然后再去理解什么是会话跟踪:

• 会话:用户打开浏览器，访问web服务器的资源，会话建立，直到有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应。

  • 从浏览器发出请求到服务端响应数据给前端之后，一次会话(在浏览器和服务器之间)就被建立了
  • 会话被建立后，如果浏览器或服务端都没有被关闭，则会话就会持续建立着
  • 浏览器和服务器就可以继续使用该会话进行请求发送和响应，上述的整个过程就被称之为会话。

  用实际场景来理解下会话，比如在我们访问京东的时候，当打开浏览器进入京东首页后，浏览器和京东的服务器之间就建立了一次会话，后面的搜索商品,查看商品的详情,加入购物车等都是在这一次会话中完成。

  思考:下图中总共建立了几个会话?

  

  每个浏览器都会与服务端建立了一个会话，加起来总共是3个会话。

• 会话跟踪:一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。

  • 服务器会收到多个请求，这多个请求可能来自多个浏览器，如上图中的6个请求来自3个浏览器
  • 服务器需要用来识别请求是否来自同一个浏览器
  • 服务器用来识别浏览器的过程，这个过程就是会话跟踪
  • 服务器识别浏览器后就可以在同一个会话中多次请求之间来共享数据

  但是一个会话中的多次请求为什么要共享数据呢?有了这个数据共享功能后能实现哪些功能呢?

  • 购物车: 加入购物车和去购物车结算是两次请求，但是后面这次请求要想展示前一次请求所添加的商品，就需要用到数据共享。

    

  • 页面展示用户登录信息:很多网站，登录后访问多个功能发送多次请求后，浏览器上都会有当前登录用户的信息[用户名]，比如百度、京东、码云等。

    

  • 网站登录页面的记住我功能:当用户登录成功后，勾选记住我按钮后下次再登录的时候，网站就会自动填充用户名和密码，简化用户的登录操作，多次登录就会有多次请求，他们之间也涉及到共享数据

    

  • 登录页面的验证码功能:生成验证码和输入验证码点击注册这也是两次请求，这两次请求的数据之间要进行对比，相同则允许注册，不同则拒绝注册，该功能的实现也需要在同一次会话中共享数据。

    

在学习会话跟踪技术之前，需要思考:为什么现在浏览器和服务器不支持数据共享呢?

• 浏览器和服务器之间使用的是HTTP请求来进行数据传输
• HTTP协议是无状态的，每次浏览器向服务器请求时，服务器都会将该请求视为新的请求
• HTTP协议设计成无状态的目的是让每次请求之间相互独立，互不影响
• 请求与请求之间独立后，就无法实现多次请求之间的数据共享

分析完具体的原因后，那么该如何实现会话跟踪技术呢? 具体的实现方式有:

(1)客户端会话跟踪技术：Cookie

(2)服务端会话跟踪技术：Session

这两个技术都可以实现会话跟踪，它们之间最大的区别:Cookie是存储在浏览器端而Session是存储在服务器端

具体的学习思路为:

• CooKie的基本使用、原理、使用细节
• Session的基本使用、原理、使用细节
• Cookie和Session的综合案例

小结

• HTTP协议是无状态的，靠HTTP协议是无法实现会话跟踪
• 想要实现会话跟踪，就需要用到Cookie和Session

2.Cookie

2.1 Cookie基本使用

1.概念

Cookie：客户端会话技术，将数据保存到客户端，以后每次请求都携带Cookie数据进行访问。

2.Cookie的工作流程

• 服务端提供了两个Servlet，分别是ServletA和ServletB
• 浏览器发送HTTP请求1给服务端，服务端ServletA接收请求并进行业务处理
• 服务端ServletA在处理的过程中可以创建一个Cookie对象并将name=zs的数据存入Cookie
• 服务端ServletA在响应数据的时候，会把Cookie对象响应给浏览器
• 浏览器接收到响应数据，会把Cookie对象中的数据存储在浏览器内存中，此时浏览器和服务端就建立了一次会话
• 在同一次会话中浏览器再次发送HTTP请求2给服务端ServletB，浏览器会携带Cookie对象中的所有数据
• ServletB接收到请求和数据后，就可以获取到存储在Cookie对象中的数据，这样同一个会话中的多次请求之间就实现了数据共享

3.Cookie的基本使用

对于Cookie的使用，我们更关注的应该是后台代码如何操作Cookie，对于Cookie的操作主要分两大类，本别是发送Cookie和获取Cookie,对于上面这两块内容，分别该如何实现呢?

3.1 发送Cookie

• 创建Cookie对象，并设置数据

Cookie cookie = new Cookie("key","value");

• 发送Cookie到客户端：使用response对象

response.addCookie(cookie);

介绍完发送Cookie对应的步骤后，接下面通过一个案例来完成Cookie的发送，具体实现步骤为:

需求:在Servlet中生成Cookie对象并存入数据，然后将数据发送给浏览器

1.创建Maven项目,项目名称为cookie-demo，并在pom.xml添加依赖

2.编写Servlet类，名称为AServlet

3.在AServlet中创建Cookie对象，存入数据，发送给前端

4.启动测试，在浏览器查看Cookie对象中的值

(1)创建Maven项目cookie-demo，并在pom.xml添加依赖

<properties>
    <maven.compiler.source>8maven.compiler.source>
    <maven.compiler.target>8maven.compiler.target>
properties>

<dependencies>
    
    <dependency>
        <groupId>javax.servletgroupId>
        <artifactId>javax.servlet-apiartifactId>
        <version>3.1.0version>
        <scope>providedscope>
    dependency>
    
    <dependency>
        <groupId>javax.servlet.jspgroupId>
        <artifactId>jsp-apiartifactId>
        <version>2.2version>
        <scope>providedscope>
    dependency>
    
    <dependency>
        <groupId>jstlgroupId>
        <artifactId>jstlartifactId>
        <version>1.2version>
    dependency>
    <dependency>
        <groupId>taglibsgroupId>
        <artifactId>standardartifactId>
        <version>1.1.2version>
    dependency>
dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.tomcat.mavengroupId>
            <artifactId>tomcat7-maven-pluginartifactId>
            <version>2.2version>
        plugin>
    plugins>
build>

(2)编写Servlet类，名称为AServlet

@WebServlet("/aServlet")
public class AServlet 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);
    }
}

(3)在Servlet中创建Cookie对象，存入数据，发送给前端

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //发送Cookie
        //1. 创建Cookie对象
        Cookie cookie = new Cookie("username","zs");
        //2. 发送Cookie，response
        response.addCookie(cookie);
    }

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

（4）启动测试，在浏览器查看Cookie对象中的值

访问http://localhost:8080/cookie-demo/aServlet

chrome浏览器查看Cookie的值

选中打开开发者工具或者 使用快捷键F12 或者 Ctrl+Shift+I

3.2 获取Cookie

• 获取客户端携带的所有Cookie，使用request对象

Cookie[] cookies = request.getCookies();

• 遍历数组，获取每一个Cookie对象：for
• 使用Cookie对象方法获取数据

cookie.getName();
cookie.getValue();

介绍完获取Cookie对应的步骤后，接下面再通过一个案例来完成Cookie的获取，具体实现步骤为:

需求:在Servlet中获取前一个案例存入在Cookie对象中的数据

1.编写一个新Servlet类，名称为BServlet

2.在BServlet中使用request对象获取Cookie数组，遍历数组，从数据中获取指定名称对应的值

3.启动测试，在控制台打印出获取的值

(1)编写一个新Servlet类，名称为BServlet

@WebServlet("/bServlet")
public class BServlet 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）在BServlet中使用request对象获取Cookie数组，遍历数组，从数据中获取指定名称对应的值

@WebServlet("/bServlet")
public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取Cookie
        //1. 获取Cookie数组
        Cookie[] cookies = request.getCookies();
        //2. 遍历数组
        for (Cookie cookie : cookies) {
            //3. 获取数据
            String name = cookie.getName();
            if("username".equals(name)){
                String value = cookie.getValue();
                System.out.println(name+":"+value);
                break;
            }
        }

    }

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

（3）启动测试，在控制台打印出获取的值

访问http://localhost:8080/cookie-demo/bServlet

在IDEA控制台就能看到输出的结果:

小结

• 发送Cookie:
  • 创建Cookie对象，并设置值:Cookie cookie = new Cookie(“key”,“value”);
  • 发送Cookie到客户端使用的是Reponse对象:response.addCookie(cookie);
• 获取Cookie:
  • 使用Request对象获取Cookie数组:Cookie[] cookies = request.getCookies();
  • 遍历数组
  • 获取数组中每个Cookie对象的值:cookie.getName()和cookie.getValue()

2.2 Cookie原理分析

对于Cookie的实现原理是基于HTTP协议的,其中设计到HTTP协议中的两个请求头信息:

• 响应头:set-cookie
• 请求头: cookie

• 前面的案例中已经能够实现，AServlet给前端发送Cookie,BServlet从request中获取Cookie的功能
• 对于AServlet响应数据的时候，Tomcat服务器都是基于HTTP协议来响应数据
• 当Tomcat发现后端要返回的是一个Cookie对象之后，Tomcat就会在响应头中添加一行数据==Set-Cookie:username=zs==
• 浏览器获取到响应结果后，从响应头中就可以获取到Set-Cookie对应值username=zs,并将数据存储在浏览器的内存中
• 浏览器再次发送请求给BServlet的时候，浏览器会自动在请求头中添加==Cookie: username=zs==发送给服务端BServlet
• Request对象会把请求头中cookie对应的值封装成一个个Cookie对象，最终形成一个数组
• BServlet通过Request对象获取到Cookie[]后，就可以从中获取自己需要的数据

2.3 Cookie使用细节

2.3.1 Cookie的存活时间

在访问AServlet和BServlet的中间把关闭浏览器,重启浏览器后访问BServlet能否获取到Cookie中的数据?

(1)浏览器发送请求给AServlet,AServlet会响应一个存有usernanme=zs的Cookie对象给浏览器

(2)浏览器接收到响应数据将cookie存入到浏览器内存中

(3)当浏览器再次发送请求给BServlet,BServlet就可以使用Request对象获取到Cookie数据

(4)在发送请求到BServlet之前，如果把浏览器关闭再打开进行访问，BServlet能否获取到Cookie数据?

注意：浏览器关闭再打开不是指打开一个新的选显卡，而且必须是先关闭再打开，顺序不能变。

针对上面这个问题，通过演示，会发现，BServlet中无法再获取到Cookie数据，这是为什么呢?

• 默认情况下，Cookie存储在浏览器内存中，当浏览器关闭，内存释放，则Cookie被销毁

这个结论就印证了上面的演示效果，但是如果使用这种默认情况下的Cookie,有些需求就无法实现，比如:

上面这个网站的登录页面上有一个记住我的功能，这个功能大家都比较熟悉

• 第一次输入用户名和密码并勾选记住我然后进行登录
• 下次再登陆的时候，用户名和密码就会被自动填充，不需要再重新输入登录
• 比如记住我这个功能需要记住用户名和密码一个星期，那么使用默认情况下的Cookie就会出现问题
• 因为默认情况，浏览器一关，Cookie就会从浏览器内存中删除，对于记住我功能就无法实现

所以现在就遇到一个难题是如何将Cookie持久化存储?

Cookie其实已经为我们提供了对应的API来完成这件事，这个API就是setMaxAge

• 设置Cookie存活时间

setMaxAge(int seconds)

参数值为:

1.正数：将Cookie写入浏览器所在电脑的硬盘，持久化存储。到时间自动删除

2.负数：默认值，Cookie在当前浏览器内存中，当浏览器关闭，则Cookie被销毁

3.零：删除对应Cookie

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //发送Cookie
        //1. 创建Cookie对象
        Cookie cookie = new Cookie("username","zs");
        //设置存活时间   ，1周 7天
        cookie.setMaxAge(60*60*24*7); //易阅读，需程序计算
		//cookie.setMaxAge(604800); //不易阅读(可以使用注解弥补)，程序少进行一次计算
        //2. 发送Cookie，response
        response.addCookie(cookie);
    }

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

修改完代码后，启动测试，访问http://localhost:8080/cookie-demo/aServlet

• 访问一个AServlet后，把浏览器关闭重启后，再去访问http://localhost:8080/cookie-demo/bServet,能在控制台打印出username:zs,说明Cookie没有随着浏览器关闭而被销毁
• 通过浏览器查看Cookie的内容，会发现Cookie的相关信息

2.3.2 Cookie存储中文

首先，先来演示一个效果，将之前username=zs的值改成username=张三，把汉字张三存入到Cookie中，看是什么效果:

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 		//发送Cookie
        String value = "张三";
        Cookie cookie = new Cookie("username",value);
        //设置存活时间   ，1周 7天
        cookie.setMaxAge(60*60*24*7);
        //2. 发送Cookie，response
        response.addCookie(cookie);
    }

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

启动访问测试，访问http://localhost:8080/cookie-demo/aServlet会发现浏览器会提示错误信息

通过上面的案例演示，我们得到一个结论:

• Cookie不能直接存储中文

Cookie不能存储中文，但是如果有这方面的需求，这个时候该如何解决呢?

可以使用之前学过的一个知识点叫URL编码，所以如果需要存储中文，就需要进行转码，具体的实现思路为:

1.在AServlet中对中文进行URL编码，采用URLEncoder.encode()，将编码后的值存入Cookie中

2.在BServlet中获取Cookie中的值,获取的值为URL编码后的值

3.将获取的值在进行URL解码,采用URLDecoder.decode()，就可以获取到对应的中文值

(1)在AServlet中对中文进行URL编码

@WebServlet("/aServlet")
public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //发送Cookie
        String value = "张三";
        //对中文进行URL编码
        value = URLEncoder.encode(value, "UTF-8");
        System.out.println("存储数据："+value);
        //将编码后的值存入Cookie中
        Cookie cookie = new Cookie("username",value);
        //设置存活时间   ，1周 7天
        cookie.setMaxAge(60*60*24*7);
        //2. 发送Cookie，response
        response.addCookie(cookie);
    }

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

(2)在BServlet中获取值，并对值进行解码

@WebServlet("/bServlet")
public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取Cookie
        //1. 获取Cookie数组
        Cookie[] cookies = request.getCookies();
        //2. 遍历数组
        for (Cookie cookie : cookies) {
            //3. 获取数据
            String name = cookie.getName();
            if("username".equals(name)){
                String value = cookie.getValue();//获取的是URL编码后的值 %E5%BC%A0%E4%B8%89
                //URL解码
                value = URLDecoder.decode(value,"UTF-8");
                System.out.println(name+":"+value);//value解码后为 张三
                break;
            }
        }

    }

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

至此，我们就可以将中文存入Cookie中进行使用。

小结

• 存活时间，需要掌握setMaxAage()API的使用

• 存储中文，需要掌握URL编码和解码的使用

3.Session

3.1 Session基本使用

1.概念

Session：服务端会话跟踪技术：将数据保存到服务端。

• Session是存储在服务端而Cookie是存储在客户端
• 存储在客户端的数据容易被窃取和截获，存在很多不安全的因素
• 存储在服务端的数据相比于客户端来说就更安全

2.Session的工作流程

• 在服务端的AServlet获取一个Session对象，把数据存入其中
• 在服务端的BServlet获取到相同的Session对象，从中取出数据
• 就可以实现一次会话中多次请求之间的数据共享了
• 现在最大的问题是如何保证AServlet和BServlet使用的是同一个Session对象?

3.Session的基本使用

在JavaEE中提供了HttpSession接口，来实现一次会话的多次请求之间数据共享功能。

具体的使用步骤为:

• 获取Session对象,使用的是request对象

HttpSession session = request.getSession();

• Session对象提供的功能:

  • 存储数据到 session 域中

    void setAttribute(String name, Object o)
    

  • 根据 key，获取值

    Object getAttribute(String name)
    

  • 根据 key，删除该键值对

    void removeAttribute(String name)
    

通过一个案例来完成对Session的使用，具体实现步骤为:

需求:在一个Servlet中往Session中存入数据，在另一个Servlet中获取Session中存入的数据

1.创建名为SessionDemo1的Servlet类

2.创建名为SessionDemo2的Servlet类

3.在SessionDemo1的方法中:获取Session对象、存储数据

4.在SessionDemo2的方法中:获取Session对象、获取数据

5.启动测试

(1)创建名为SessionDemo1的Servlet类

@WebServlet("/demo1")
public class SessionDemo1 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)创建名为SessionDemo2的Servlet类

@WebServlet("/demo2")
public class SessionDemo2 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);
    }
}

(3)SessionDemo1:获取Session对象、存储数据

@WebServlet("/demo1")
public class SessionDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    	//存储到Session中
        //1. 获取Session对象
        HttpSession session = request.getSession();
        //2. 存储数据
        session.setAttribute("username","zs");
    }

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

(4)SessionDemo2:获取Session对象、获取数据

@WebServlet("/demo2")
public class SessionDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取数据，从session中
        //1. 获取Session对象
        HttpSession session = request.getSession();
        //2. 获取数据
        Object username = session.getAttribute("username");
        System.out.println(username);
    }

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

(5)启动测试，

• 先访问http://localhost:8080/cookie-demo/demo1,将数据存入Session
• 在访问http://localhost:8080/cookie-demo/demo2,从Session中获取数据
• 查看控制台

通过案例的效果，能看到Session是能够在一次会话中两次请求之间共享数据。

小结

• Session的获取

  HttpSession session = request.getSession();
  

• Session常用方法的使用

  void setAttribute(String name, Object o)
  Object getAttribute(String name)
  

  **注意:**Session中可以存储的是一个Object类型的数据，也就是说Session中可以存储任意数据类型。

3.2 Session原理分析

• Session是基于Cookie实现的

分析下Session的具体实现原理:

(1)前提条件

Session要想实现一次会话多次请求之间的数据共享，就必须要保证多次请求获取Session的对象是同一个。

那么它们是一个对象么？要验证这个结论也很简单，只需要在上面案例中的两个Servlet中分别打印下Session对象

SessionDemo1

@WebServlet("/demo1")
public class SessionDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    	//存储到Session中
        //1. 获取Session对象
        HttpSession session = request.getSession();
        System.out.println(session);
        //2. 存储数据
        session.setAttribute("username","zs");
    }

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

SessionDemo2

@WebServlet("/demo2")
public class SessionDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取数据，从session中
        //1. 获取Session对象
        HttpSession session = request.getSession();
        System.out.println(session);
        //2. 获取数据
        Object username = session.getAttribute("username");
        System.out.println(username);
    }

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

启动测试，分别访问

http://localhost:8080/cookie-demo/demo1

http://localhost:8080/cookie-demo/demo2

通过打印可以得到如下结论:

• 两个Servlet类中获取的Session对象是同一个
• 把demo1和demo2请求刷新多次，控制台最终打印的结果都是同一个

那么问题又来了，如果新开一个浏览器，访问demo1或者demo2,打印在控制台的Session还是同一个对象么?

注意:在一台电脑上演示的时候，如果是相同的浏览器必须要把浏览器全部关掉重新打开，才算新开的一个浏览器。

当然也可以使用不同的浏览器进行测试，就不需要把之前的浏览器全部关闭。

测试的结果：如果是不同浏览器或者重新打开浏览器后，打印的Session就不一样了。

所以Session实现的也是一次会话中的多次请求之间的数据共享。

那么最主要的问题就来了，Session是如何保证在一次会话中获取的Session对象是同一个呢?

(1)demo1在第一次获取session对象的时候，session对象会有一个唯一的标识，假如是id:10

(2)demo1在session中存入其他数据并处理完成所有业务后，需要通过Tomcat服务器响应结果给浏览器

(3)Tomcat服务器发现业务处理中使用了session对象，就会把session的唯一标识id:10当做一个cookie，添加Set-Cookie:JESSIONID=10到响应头中，并响应给浏览器

(4)浏览器接收到响应结果后，会把响应头中的coookie数据存储到浏览器的内存中

(5)浏览器在同一会话中访问demo2的时候，会把cookie中的数据按照cookie: JESSIONID=10的格式添加到请求头中并发送给服务器Tomcat

(6)demo2获取到请求后，从请求头中就读取cookie中的JSESSIONID值为10，然后就会到服务器内存中寻找id:10的session对象，如果找到了，就直接返回该对象，如果没有则新创建一个session对象

(7)关闭打开浏览器后，因为浏览器的cookie已被销毁，所以就没有JESSIONID的数据，服务端获取到的session就是一个全新的session对象

3.3 Session使用细节

3.3.1 Session钝化与活化

首先需要思考的问题是:

• 服务器重启后，Session中的数据是否还在?

要想回答这个问题，可以先看下下面这幅图，

(1)服务器端AServlet和BServlet共用的session对象应该是存储在服务器的内存中

(2)服务器重新启动后，内存中的数据应该是已经被释放，对象也应该都销毁了

所以session数据应该也已经不存在了。但是如果session不存在会引发什么问题呢?

举个例子说明下，

(1)用户把需要购买的商品添加到购物车，因为要实现同一个会话多次请求数据共享，所以假设把数据存入Session对象中

(2)用户正要付钱的时候接到一个电话，付钱的动作就搁浅了

(3)正在用户打电话的时候，购物网站因为某些原因需要重启

(4)重启后session数据被销毁，购物车中的商品信息也就会随之而消失

(5)用户想再次发起支付，就会出为问题

所以说对于session的数据，我们应该做到就算服务器重启了，也应该能把数据保存下来才对。

分析了这么多，那么Tomcat服务器在重启的时候，session数据到底会不会保存以及是如何保存的，我们可以通过实际案例来演示下:

注意:这里所说的关闭和启动应该要确保是正常的关闭和启动。

那如何才是正常关闭Tomcat服务器呢?

需要使用命令行的方式来启动和停止Tomcat服务器:

启动:进入到项目pom.xml所在目录，执行tomcat7:run

停止:在启动的命令行界面，输入ctrl+c

有了上述两个正常启动和关闭的方式后，接下来的测试流程是:

(1)先启动Tomcat服务器

(2)访问http://localhost:8080/cookie-demo/demo1将数据存入session中

(3)正确停止Tomcat服务器

(4)再次重新启动Tomcat服务器

(5)访问http://localhost:8080/cookie-demo/demo2 查看是否能获取到session中的数据

经过测试，会发现只要服务器是正常关闭和启动，session中的数据是可以被保存下来的。

那么Tomcat服务器到底是如何做到的呢?

具体的原因就是：Session的钝化和活化

• 钝化：在服务器正常关闭后，Tomcat会自动将Session数据写入硬盘的文件中

  • 钝化的数据路径为:项目目录\target\tomcat\work\Tomcat\localhost\项目名称\SESSIONS.ser

    

• 活化：再次启动服务器后，从文件中加载数据到Session中

  • 数据加载到Session中后，路径中的SESSIONS.ser文件会被删除掉

小结

• session数据存储在服务端，服务器重启后，session数据会被保存

• 浏览器被关闭启动后，重新建立的连接就已经是一个全新的会话，获取的session数据也是一个新的对象

• session的数据要想共享，浏览器不能关闭，所以session数据不能长期保存数据

• cookie是存储在客户端，是可以长期保存

3.3.2 Session销毁

session的销毁会有两种方式:

• 默认情况下，无操作，30分钟自动销毁

  • 对于这个失效时间，是可以通过配置进行修改的

    • 在项目的web.xml中配置

      
      <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
               version="3.1">
      
          <session-config>
              <session-timeout>100session-timeout>
          session-config>
      web-app>
      

    • 如果没有配置，默认是30分钟，默认值是在Tomcat的web.xml配置文件中写死的

      

• 调用Session对象的invalidate()进行销毁

  • 在SessionDemo2类中添加session销毁的方法

    @WebServlet("/demo2")
    public class SessionDemo2 extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            //获取数据，从session中
    
            //1. 获取Session对象
            HttpSession session = request.getSession();
            System.out.println(session);
    
            // 销毁
            session.invalidate();
            //2. 获取数据
            Object username = session.getAttribute("username");
            System.out.println(username);
        }
    
        @Override
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            this.doGet(request, response);
        }
    }
    

  • 启动访问测试，先访问demo1将数据存入到session，再次访问demo2从session中获取数据

    

  • 该销毁方法一般会在用户退出的时候，需要将session销毁掉。

Cookie和Session小结

• Cookie 和 Session 都是来完成一次会话内多次请求间数据共享的。

所需两个对象放在一块，就需要思考:

Cookie和Session的区别是什么?

Cookie和Session的应用场景分别是什么?

• 区别:
  • 存储位置：Cookie 是将数据存储在客户端，Session 将数据存储在服务端
  • 安全性：Cookie不安全，Session安全
  • 数据大小：Cookie最大3KB，Session无大小限制
  • 存储时间：Cookie可以通过setMaxAge()长期存储，Session默认30分钟
  • 服务器性能：Cookie不占服务器资源，Session占用服务器资源
• 应用场景:
  • 购物车:使用Cookie来存储
  • 以登录用户的名称展示:使用Session来存储
  • 记住我功能:使用Cookie来存储
  • 验证码:使用session来存储
• 结论
  • Cookie是用来保证用户在未登录情况下的身份识别
  • Session是用来保存用户登录后的数据