1.Request和Response的概述

# 重点
1. service方法的两个参数request和response是由tomcat创建的

2. request 表示请求数据, tomcat将浏览器发送过来的请求数据解析并封装到request对象中
		servlet开发者可以通过request对象获得请求数据
3. response 表示响应数据,服务器发送给浏览器的数据
		servlet开发者可以通过response对象设置响应数据

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

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

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

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

@WebServlet("/demo3")
public class ServletDemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //使用request对象 获取请求数据
        String name = request.getParameter("name");//url?name=zhangsan

        //使用response对象 设置响应数据
        response.setHeader("content-type","text/html;charset=utf-8");
        response.getWriter().write("<h1>"+name+",欢迎您！</h1>");
    }

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

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

小结

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

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

2.Request对象

2.1 Request 继承体系

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

那么，

• ServletRequest 和 HttpServletRequest 的关系是什么?
• request 对象是有谁来创建的?
• request 提供了哪些API,这些API从哪里查?

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

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

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

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

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

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

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

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

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

小结

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

2.2 Request获取请求数据

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

2.2.1 获取请求行数据

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

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

• 获取请求方式: GET

String getMethod()

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

String getContextPath()

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

StringBuffer getRequestURL()

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

String getRequestURI()

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

String getQueryString()

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

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

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

2.2.2 获取请求头数据

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

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

String getHeader(String name)

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

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

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

2.2.3 获取请求体数据

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

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

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

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

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

BufferedReader getReader()

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

具体实现的步骤如下:

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

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

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

4.访问测试

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

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

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

/**
 * request 获取请求数据
 */
@WebServlet("/req1")
public class RequestDemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //在此处获取请求体中的数据
    }
}

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

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

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

小结

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

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

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

在学习下面内容之前，我们先提出两个问题:

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

1.什么是请求参数?

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

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

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

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

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

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

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

2.什么是请求数据?

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

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

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

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

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

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

• GET方式:

String getQueryString()

• POST方式:

BufferedReader getReader();

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

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

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

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

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

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

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

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

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

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

解决方案一:

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

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

解决方案二:

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

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

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

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

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

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

• 获取所有参数Map集合

Map<String,String[]> getParameterMap()

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

String[] getParameterValues(String name)

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

String getParameter(String name)

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

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

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

</form>
</body>
</html>

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

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

/**
 * request 通用方式获取请求参数
 */
@WebServlet("/req2")
public class RequestDemo2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //GET请求逻辑
        System.out.println("get....");
        //1. 获取所有参数的Map集合
        Map<String, String[]> map = req.getParameterMap();
        for (String key : map.keySet()) {
            // username:zhangsan lisi
            System.out.print(key+":");

            //获取值
            String[] values = map.get(key);
            for (String value : values) {
                System.out.print(value + " ");
            }

            System.out.println();
        }
    }

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

获取的结果为:

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

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

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

获取的结果为:

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

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

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

获取的结果为:

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

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

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

小结

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

2.3 解决post请求乱码问题 掌握

内容讲解

html页面：

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

【1】从tomcat8开始以后，对于get请求乱码，tomcat已经解决。对于post请求中文乱码没有解决，需要我们自己处理。

【2】post请求乱码产生的原因和解决思路

说明：

1)页面使用的编码表是UTF-8编码，tomcat使用的是默认编码表ISO-8859-1进行解码，编码和解码使用的编码表不一致导致乱码。

2)解决思路：先按照ISO-8859-1编码，在按照UTF-8进行重新解码

【3】解决方案

解决方案有三种：

1.方案一

【1】方式一
             使用URLEncoder类进行编码:static String encode(String s, String enc)
                             参数：
                                 s:编码的字符串
                                 enc:使用编码表
             使用URLDecoder进行解码：static String decode(String s, String enc)
                             参数：
                                 s:解码的字符串
                                 enc:使用编码表

2.方案二

【2】方式二：
             使用String类中的方法进行编码：    byte[] getBytes(String charsetName)
                                               参数表示指定的编码表，返回值表示编码后的字节数组
             使用String类中的构造方法进行解码：String(byte[] bytes, String charsetName)
                                             参数：
                                                 bytes：字节数组
                                                 charsetName：表示指定的编码表
                                             返回值：解码后的字符串

3.方案三

【3】方式三：
             如果是get请求，tomcat8底层已经帮助我们解决完了，我们只需要解决post乱码即可，但是上述
             两种方式对于post请求可以解决乱码，对于get请求本身获取到的已经是正确的数据，处理
             后又乱码了。
             我们的想法是：get请求不用我们自己书写代码处理乱码，只需要我们书写代码处理post乱码。
             我们接下来学习第三种解决方案：
             只解决来自于请求体数据的乱码。而get请求体没有数据，post请求体含有数据，所以我们可以理解为第三种处理方案只				是用来解决post乱码的。使用的api是ServletRequest接口中的：
                 void setCharacterEncoding(String env)
                     参数：指定的编码表
             注意：该方式的代码必须书写在获取请求数据之前

【4】代码实现

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.net.URLDecoder;
import java.net.URLEncoder;

@WebServlet("/httpServletRequestDemo04Servlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取浏览器的请求数据
//        String username = request.getParameter("username");

        /*
            解决post乱码问题有三种方式：
            【1】方式一
                使用URLEncoder类进行编码:static String encode(String s, String enc)
                                参数：
                                    s:编码的字符串
                                    enc:使用编码表
                使用URLDecoder进行解码：static String decode(String s, String enc)
                                参数：
                                    s:解码的字符串
                                    enc:使用编码表
         */
        //1)编码 ： 使用URLEncoder类进行编码:static String encode(String s, String enc)
//        String encodeUsername = URLEncoder.encode(username, "ISO-8859-1");
//        //2)解码：使用URLDecoder进行解码：static String decode(String s, String enc)
//        username = URLDecoder.decode(encodeUsername, "UTF-8");

        /*
             解决post乱码问题有三种方式：
            【2】方式二：
                使用String类中的方法进行编码：    byte[] getBytes(String charsetName)
                                                  参数表示指定的编码表，返回值表示编码后的字节数组
                使用String类中的构造方法进行解码：String(byte[] bytes, String charsetName)
                                                参数：
                                                    bytes：字节数组
                                                    charsetName：表示指定的编码表
                                                返回值：解码后的字符串

         */
        //1)编码 ： 使用String类中的方法进行编码：    byte[] getBytes(String charsetName)
//        byte[] bytes = username.getBytes("ISO-8859-1");
//        //2)解码：使用String类中的构造方法进行解码：String(byte[] bytes, String charsetName)
//        username = new String(bytes, "UTF-8");

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

        /*
            解决post乱码问题有三种方式：
            【3】方式三：
                如果是get请求，tomcat8底层已经帮助我们解决完了，我们只需要解决post乱码即可，但是上述
                两种方式对于post请求可以解决乱码，对于get请求本身获取到的已经是正确的数据，处理
                后又乱码了。
                我们的想法是：get请求不用我们自己书写代码处理乱码，只需要我们书写代码处理post乱码。
                我们接下来学习第三种解决方案：
                只解决来自于请求体数据的乱码。而get请求体没有数据，post请求体含有数据，所以我们可以理解为第三种处理方案只是用来解决
                post乱码的。使用的api是ServletRequest接口中的：
                    void setCharacterEncoding(String env)
                        参数：指定的编码表
                注意：该方式的代码必须书写在获取请求数据之前
         */
        request.setCharacterEncoding("utf-8");//告知tomcat使用UTF-8解码页面请求数据

        //  1.获取浏览器的请求数据
        String username = request.getParameter("username");
        System.out.println("username = " + username);
    }
}

内容小结

1.tomcat8以后对于get请求乱码已经处理完毕，我们只需要处理post请求

2.处理post请求乱码有三种方式：

方式一：

 /*
            解决post请求乱码实现：
            方式一：
                编码：URLEncoder：HTML 格式编码的实用工具类。编码方法：
                    static String encode(String s, String enc)  参数：s 编码的字符串  enc  编码使用的编码表
                解码：URLDecoder ： HTML 格式解码的实用工具类，解码方法：
                    static String decode(String s, String enc)   参数：s 解码的字符串  enc  解码使用的编码表
         */
        //编码：URLEncoder：HTML 格式编码的实用工具类。编码方法：
//        String encode = URLEncoder.encode(username, "ISO-8859-1");
//        //解码：URLDecoder ： HTML 格式解码的实用工具类，解码方法：
//        username = URLDecoder.decode(encode, "UTF-8");

方式二：

  /*
            解决post请求乱码实现：
            方式二：
                编码：使用String类的方法进行编码：byte[] getBytes(String charsetName)   参数表示指定的码表
                解码：使用String类的构造方法：String(byte[] bytes, String charsetName) 参数：第一个参数是字节数组 第二个参数表示指定的码表
         */
         // 编码：使用String类的方法进行编码：byte[] getBytes(String charsetName)   参数表示指定的码表
//        byte[] bytes = username.getBytes("ISO-8859-1");
//        // 解码：使用String类的构造方法：String(byte[] bytes, String charsetName) 参数：第一个参数是字节数组 第二个参数表示指定的码表
//        username = new String(bytes, "UTF-8");
//        username = new String(username.getBytes("ISO-8859-1"), "UTF-8");

方式三：使用最多

 /*
            解决post请求乱码实现：
            方式三：推荐使用
            使用request对象调用方法： void setCharacterEncoding(String env) 参数：env指定的编码表
                                    说明：
                                        1.该方法是用来解决请求体数据的乱码问题。get请求体没有数据，post请求体含有数据。可以认为该方法
                                        就是解决post请求乱码的
                                        2.该方法必须放到获取所有请求数据之前处理乱码。
         */
        //处理请求乱码
        request.setCharacterEncoding("utf-8");

2.4 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.HTTP响应详解(理解)

1.使用抓包查看响应报文协议内容

学习目标

• 能够使用抓包查看响应报文协议内容

内容讲解

注意：

http响应报文协议包括：

1.响应行
2.响应头
3.响应体

响应数据：是服务器响应给浏览器

【1】步骤

1.创建html页面
2.创建servlet

【2】实现

1.创建html页面

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
</head>
<body>
<h2>get请求</h2>
<form action="/getServlet" method="get">
    用户名：<input type="text" name="username" value="suoge" /> <br/>
    密码：<input type="text" name="password" value="1234" /> <br/>
    <input type="submit" value="get提交" />
</form>
<h2>post请求</h2>
<form action="/postServlet" method="post">
    用户名：<input type="text" name="username" value="suoge" /> <br/>
    密码：<input type="text" name="password" value="1234" /> <br/>
    <input type="submit" value="post提交" />
</form>
</body>
</html>

2.创建servlet

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("/getServlet")
public class GetServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //响应给浏览器数据
        response.getWriter().print("get....");
    }
}

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("/postServlet")
public class PostServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //响应给浏览器数据
        response.getWriter().print("post....");
    }
}

【3】抓包结果

内容小结

​ 1.由于浏览器的原因，浏览器会把请求行和响应行信息放在了一起；

​ 2.get和post请求的响应没有区别；

2.HTTP响应报文协议介绍

学习目标

• 理解响应报文协议的组成部分

内容讲解

【1】响应行

响应行格式：协议/版本 状态码

如：HTTP/1.1 200 ;

状态码	状态码描述	说明
200	OK	请求已成功，请求所希望的响应头或数据体将随此响应返回。出现此状态码是表示正常状态。
302	Move temporarily	重定向，请求的资源临时从不同的 地址响应请求。
304	Not Modified	从浏览器缓存中读取数据，不从服务器重新获取数据。例如，用户第一次从浏览器访问服务器端图片资源，以后在访问该图片资源的时候就不会再从服务器上加载而直接到浏览器缓存中加载，这样效率更高。
404	Not Found	请求资源不存在。通常是用户路径编写错误，也可能是服务器资源已删除。
403	Forbidden	服务器已经理解请求，但是拒绝执行它
405	Method Not Allowed	请求行中指定的请求方法不能被用于请求相应的资源
500	Internal Server Error	服务器内部错误。通常程序抛异常

【2】响应头

响应头也是用的键值对key:value，服务器基于响应头通知浏览器的行为。

常见的响应头 ：

响应头Key	响应头value
location	指定响应的路径，需要与状态码302配合使用，完成重定向
content-Type	响应正文的类型（MIME类型，属于服务器里面的一种类型，例如文件在window系统有自己的类型，.txt .doc .jpg。文件在服务器中也有自己的类型），同时还可以解决乱码问题。例如：text/html;charset=UTF-8
content-disposition	通过浏览器以附件形式解析正文，例如：attachment;filename=xx.zip
refresh	页面刷新，例如：3;url=www.itcast.cn //三秒刷新页面到www.itcast.cn

常见的MIME类型：就是文件在tomcat服务器中的文件类型：

				windows    tomcat(MIME类型)
超文本标记语言文本 .html      text/html ***
xml文档 .xml 				text/xml
XHTML文档 .xhtml 			application/xhtml+xml
普通文本         .txt 	   text/plain ***
PDF文档 .pdf 				application/pdf
Microsoft Word文件 .word 	application/msword
PNG图像 .png  			image/png **
GIF图形 .gif 				image/gif
JPEG图形 .jpeg,.jpg 		image/jpeg **
......

【3】响应体

​ 响应体，就是服务器发送给浏览器的数据。当前浏览器向服务器请求的资源是hello.html，所以服务器给浏览器响应的数据是一个html页面。

请求资源路径：

响应结果：

如果请求是servlet,那么浏览器的响应体接收到的是servlet响应的数据：

内容小结

1.响应行：

​ 协议版本号 状态码 200(一切正常) 404(找不到资源路径) 500(服务器报异常) 302(和location一起使用，实现重定向) 304(从浏览器缓存中读取数据) 405(服务器的servlet没有重写doGet和doPost方法)

2.响应头：

​ location 指定响应的路径

​ content-type:告诉浏览器文件格式，告诉浏览器不要解析html文件(text/plain)，解决中文乱码问题

​ refresh 定时刷新

​ content-disposition 以附件形式展示图片等资源

3.响应体：

​ 服务器处理的结果响应到浏览器中

4.Response对象

1 Response对象介绍

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

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

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

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

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

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

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

1. 响应行

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

void setStatus(int sc);

2. 响应头
   

设置响应头键值对：

void setHeader(String name,String value);

3. 响应体

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

获取字符输出流:

PrintWriter getWriter();

获取字节输出流

ServletOutputStream getOutputStream();

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

3 Respones请求重定向

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都被访问到了。到这重定向就已经完成了。

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

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对象进行共享数据

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

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

# 如果需要在资源之间传递数据,使用请求转发, 否则就用重定向

4 路径问题

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

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

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

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

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

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

• <a href='路劲'>
• <form action='路径'>
• req.getRequestDispatcher(“路径”)
• resp.sendRedirect(“路径”)

答案:

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

5 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("<h1>aaa</h1>");

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

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

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

6 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-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

(2)调用工具类方法

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

优化后的代码:

/**
 * 响应字节数据：设置字节数据的响应体
 */
@WebServlet("/resp4")
public class ResponseDemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, 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);
    }
}

5.用户注册登录案例

接下来我们通过两个比较常见的案例，一个是注册，一个是登录来对今天学习的内容进行一个实战演练，首先来实现用户登录。

5.1 用户登录

1.登录案例分析

学习目标

• 能够分析登录案例的步骤
• 能够理解登录案例整体流程

内容讲解

1.开发步骤

1.画流程开发图

2.搭建项目环境

3.根据流程图编写代码

4.浏览器访问服务器，测试功能

2.画流程开发图

#web层：
    1.获取浏览器的请求数据
    2.创建实体类对象user
    3.将用户名和密码封装到对象user
    4.创建业务层对象
    5.使用业务层对象调用业务层登录方法
    6.判断业务层返回的对象是否是null
    7.是null，说明没有查到用户，登录失败，跳转到登录失败页面
    8.如果不是null,登录成功，跳转到成功页面
    
#service层：   
    1.定义登录方法接收web层传递的用户对象
    2.使用mybatis工具类获取session对象
    3.使用session对象调用方法获取接口Mapper对象
    4.使用Mapper对象调用接口的登录方法
    User u = mapper.login(user);
    5.返回给web层对象u
#dao层：
 	1.定义接口UserMapper
 	2.在接口UserMapper中定义登录方法
    

2.环境搭建

学习目标

• 能够独立完成前后台环境的搭建

内容讲解

1后台环境

【1】数据库环境

create database day11_db;
use day11_db;
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) NOT NULL,
  `password` varchar(32) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'zhangsan', '1234');
INSERT INTO `user` VALUES ('2', 'lisi', '1234');
INSERT INTO `user` VALUES ('3', 'wangwu', '1234');
INSERT INTO `user` VALUES ('4', 'zhaoliu', '1234');

【2】创建工程并创建分层包

【3】导入第三方jar包

 <dependencies>
         <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <!--<version>4.13</version>-->
            <version>4.13</version>
            <!--范围：测试存在-->
            <!--<scope>test</scope>-->
        </dependency>

        <!--mybatis核心包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.0</version>
        </dependency>
        <!--logback日志包-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.18</version>
        </dependency>

		<dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <!--编译 测试需要，运行时不需要-->
            <scope>provided</scope>
        </dependency>
    </dependencies>
	<!--插件管理-->
    <build>
        <plugins>
            <!--JDK编译插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!-- put your configurations here -->
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>

【4】配置文件

db.properties:

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/day33_usermanager
jdbc.username=root
jdbc.password=1234

mybatis核心配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--加载外部的配置文件-->
    <properties resource="db.properties"></properties>
    <!--settings-->
    <settings>
        <!--开启驼峰自动映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!--别名-->
    <typeAliases>
        <package name="com.itheima.sh.pojo"></package>
    </typeAliases>
    <!--mybatis环境的配置
        一个核心配置文件，可以配置多个运行环境，default默认使用哪个运行环境
    -->
    <environments default="development">
        <!--通常我们只需要配置一个就可以了， id是环境的名字 -->
        <environment id="development">
            <!--事务管理器：由JDBC来管理-->
            <!--
                事务管理器type的取值：
                1. JDBC：由JDBC进行事务的管理
                2. MANAGED：事务由容器来管理，后期学习Spring框架的时候，所有的事务由容器管理
            -->
            <transactionManager type="JDBC"/>
            <!--数据源的配置：mybatis自带的连接池-->
            <!--
                数据源：
                1. POOLED：使用mybatis创建的连接池
                2. UNPOOLED：不使用连接池，每次自己创建连接
                3. JNDI：由服务器提供连接池的资源，我们通过JNDI指定的名字去访问服务器中资源。
            -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>

    </environments>
    <!--映射器-->
    <mappers>
        <!--加载其它的映射文件 注：注解开发是点号-->
        <!-- <package name="com.itheima.sh.dao"></package>-->
        <!--加载其它的映射文件 注：不是点号-->
        <!--<mapper resource="org/mybatis/example/BlogMapper.xml"/>-->
        <!--
            加载其它的映射文件 xml形式
                包扫描方式加载mapper映射文件,说明：
                1. 要求mapper映射文件，与mapper接口要放在同一个目录
                2. 要求mapper映射文件的名称，与mapper接口的名称要一致
            -->
        <package name="com.itheima.sh.dao"></package>
    </mappers>
</configuration>

【5】实体类

public class User {
    //成员变量
    private Integer id;
    private String username;
    private String password;

    public User() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

【6】工具类

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;

/*
    工具类特点：
        1.位于util包
        2.私有化构造方法
        3.提供静态方法
 */
public class SqlSessionUtil {
    private static SqlSessionFactory factory = null;

    //2.私有化构造方法 目的：不能创建对象，使用类名调用本类静态方法
    private SqlSessionUtil() {
    }

    //定义静态代码块：当前类加载就执行，之后执行一次
    static {
        try {
            //1.创建工厂创造类对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //2.获取工厂对象
            factory = builder.build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //编写静态方法获取会话对象，设置自动提交事务
    public static SqlSession getSqlSession() {
        //1.根据会话工厂对象获取会话对象
        SqlSession sqlSession = factory.openSession(true);
        //2.返回会话对象
        return sqlSession;
    }

    //编写静态方法获取会话对象，方法接收调用者传递的参数是布尔类型，决定是否设置自动提交事务
    public static SqlSession getSqlSession(boolean isAutoCommit) {
        //1.根据会话工厂对象获取会话对象
        SqlSession sqlSession = factory.openSession(isAutoCommit);
        //2.返回会话对象
        return sqlSession;
    }

    //编写静态方法接收会话对象，手动提交事务并且关闭会话
    public static void commitAndClose(SqlSession sqlSession) {
        //防止空指针异常
        if (sqlSession != null) {
            //1.手动提交事务
            sqlSession.commit();
            //2.释放资源
            sqlSession.close();
        }

    }

    //编写静态方法接收会话对象，回滚事务并且关闭会话
    public static void rollbackAndClose(SqlSession sqlSession) {
        //防止空指针异常
        if (sqlSession != null) {
            //1.回滚事务
            sqlSession.rollback();
            //2.释放资源
            sqlSession.close();
        }
    }
}

【7】UserMapper接口

import org.apache.ibatis.annotations.Select;

public interface UserMapper {
    //登录
    /*
        1.username=#{username} 等号左边的username数据表的字段名  等号右边大括号中的username看此时login登录方法的形参类型
        这里login登录方法形参类型是User类型，如果形参是一个pojo属于复杂类型，看实体类User中的getXxxx()去掉get，X变为x
        例如getUsername----username,#{username}在mybatis底层调用的是User实体类中的getUsername
     */
    @Select("select * from user where username=#{username} and password=#{password}")
    User login(User user);
}

【8】测试类

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class LoginTest {

    //查询
    @Test
    public void login(){
        //1.使用工具类获取会话对象
        SqlSession session = SessionFactoryUtils.getSession();
        //2.使用会话对象获取接口代理对象
        UserMapper mapper = session.getMapper(UserMapper.class);
        //3.使用接口代理对象调用接口中的登录方法
        User user = new User();
        user.setUsername("zhangsan");
        user.setPassword("1234");
        User u = mapper.login(user);
        //4.输出结果
        System.out.println("u = " + u);
        //5.关闭会话
        session.close();
    }
}

2前台环境

直接将资料中的内容复制到工程下面的web文件夹即可。

3.根据流程图编写代码

1.dao层代码的编写

学习目标

• 能够编写出dao层的代码向数据库查询数据

内容讲解

【1】步骤

1.创建UserMapper接口
2.在UserMapper接口中定义登录方法
3.在登录方法上使用注解向数据库根据用户名和密码查询数据

【2】实现

import org.apache.ibatis.annotations.Select;
// 1.定义接口UserMapper
public interface UserMapper {
    // 2.在接口UserMapper中定义登录方法
    //登录
    /*
        1.username=#{username} 等号左边的username数据表的字段名  等号右边大括号中的username看此时login登录方法的形参类型
        这里login登录方法形参类型是User类型，如果形参是一个pojo属于复杂类型，看实体类User中的getXxxx()去掉get，X变为x
        例如getUsername----username,#{username}在mybatis底层调用的是User实体类中的getUsername
     */
    @Select("select * from user where username=#{username} and password=#{password}")
    User login(User user);
}

内容小结

1.定义根据用户名和密码查询的方法

username=#{username}:
            1.等号左边的username看数据表的字段名
            2.#{username}:大括号中的username，由于login方法参数是User实体类类型，所以这里的username书写看User实体类中的成员变量名username
            实际上这里调用的是User实体类中的getUsername

2.service层代码的编写

学习目标

• 能够编写业务层代码

内容讲解

【1】步骤：

 	1.定义登录方法接收web层传递的用户对象
    2.使用mybatis工具类获取session对象
    3.使用session对象调用方法获取接口Mapper对象
    4.使用Mapper对象调用接口的登录方法
    User u = mapper.login(user);
    5.返回给web层对象u

【2】实现：

import org.apache.ibatis.session.SqlSession;

/*
    业务层
 */
public class UserServcie {
    //1.定义登录方法接收web层传递的用户对象
    public User login(User user) {
        //2.使用mybatis工具类获取session对象
        SqlSession session = SessionFactoryUtils.getSession();
        //3.使用session对象调用方法获取接口Mapper对象
        UserMapper mapper = session.getMapper(UserMapper.class);
        //4.使用Mapper对象调用接口的登录方法
        User u = mapper.login(user);
        //User u = mapper.login(user);
        //关闭会话对象
        session.close();
        //5.返回给web层对象u
        return u;
    }
}

内容小结

使用mybatis工具类获取接口代理对象，调用方法查询用户并返回查询的实体类对象给web层。

3.web层代码的编写

学习目标

• 能够编写web层代码

内容讲解

【1】步骤

  	1.获取浏览器的请求数据
    2.创建实体类对象user
    3.将用户名和密码封装到对象user
    4.创建业务层对象
    5.使用业务层对象调用业务层登录方法
    6.判断业务层返回的对象是否是null
    7.是null，说明没有查到用户，登录失败，跳转到登录失败页面
    8.如果不是null,登录成功，跳转到成功页面

【2】实现

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("/loginServlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取浏览器的请求数据
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        //2.创建实体类对象user
        User user = new User();
        //3.将用户名和密码封装到对象user
        user.setUsername(username);
        user.setPassword(password);
        //4.创建业务层对象
        UserServcie userServcie = new UserServcie();
        //5.使用业务层对象调用业务层登录方法
        User u = userServcie.login(user);
        //6.判断业务层返回的对象是否是null
        if (u == null) {
            //7.是null，说明没有查到用户，登录失败，跳转到登录失败页面
            request.getRequestDispatcher("/error.html").forward(request,response);
        } else {
            //8.如果不是null,登录成功，跳转到成功页面
            request.getRequestDispatcher("/success.html").forward(request,response);
        }
    }
}

5.2 用户注册

学习目标

• 完成注册案例

内容讲解

1.开发步骤

1.画注册流程图

2.根据流程图编写代码

3.浏览器访问服务器，测试功能

2.画注册流程图

dao层：
     //1.在接口中定义根据用户名查询的方法
     //2.在接口中定义注册方法
service层：
    //1.定义注册的方法接收web层传递的user对象
    //2.获取会话对象
    //3.获取接口代理对象
    //4.使用接口代理对象调用接口中的根据用户名查询的方法
    //5.判断返回的User对象是否等于null
    //6.如果等于null,说明没有查到，可以注册，使用接口代理对象调用注册方法
    //7.提交事务
    //8.返回给web层true
    //9.如果查询的用户对象不等于null,说明用户存在，不能注册，返回给web层false
    //10.释放资源
web层：
    	//1.处理请求乱码
        //2.获取页面的数据
        //3.创建User对象
        //4.将获取的数据封装到User对象中
        //5.创建业务层对象
        //6.使用业务层对象调用注册方法，将User对象作为参数传递到业务层
        //7.判断返回值
        //8.如果返回值是true，注册成功，跳转到登录页面
        //9.如果返回值是false，注册失败，跳转到失败页面

注意：注册案例需要先根据注册的用户名查询数据，如果用户名存在注册失败，用户名不存在，注册成功。

3.根据流程图编写代码

3.1dao层

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;
//1.创建接口UserMapper

public interface UserMapper {
   
    //1.定义根据用户名查询用户的方法
    @Select("select * from user where username=#{username}")
    User queryUserByUsername(@Param("username") String username);

    //2.添加用户的方法
    @Insert("insert into user values(null,#{username},#{password})")
    void addUser(User user);
}

3.2service层

import org.apache.ibatis.session.SqlSession;

/*
    业务层
 */
public class UserService {
    //1.定义一个登录方法接收web层传递的数据
    public User login(User user) {
        //2.使用mybatis工具类调用方法获取会话对象
        SqlSession session = SessionFactoryUtils.getSession();
        //3.使用session对象调用UserMapper接口代理对象
        UserMapper mapper = session.getMapper(UserMapper.class);
        //4.使用接口代理对象mapper调用接口中的方法根据用户名和密码查询数据
        User u = mapper.login(user);
        //5.关闭session
        session.close();
        //6.返回u
        return u;
    }


    //1.定义注册方法接收web层传递的数据user
    public boolean register(User user) {
        //2.使用mybatis工具类获取session会话对象
        SqlSession session = SessionFactoryUtils.getSession();
        //3.使用会话对象调用方法获取接口UserMapper代理对象
        UserMapper mapper = session.getMapper(UserMapper.class);

        //4.根据UserMapper代理对象 调用根据用户名查询的方法
        String username = user.getUsername();
        User u = mapper.queryUserByUsername(username);

        //5.判断u是否等于null
        if (u == null) {
            //6.没有查到用户，可以注册，直接调用添加方法
            mapper.addUser(user);
            //提交事务
            session.commit();
            //7.关闭session
            session.close();
            //8.返回true
            return true;
        } else {
            //9.注册失败,关闭session
            session.close();
            //10.返回false
            return false;
        }
    }

}

小结：

1.在业务层我们主要是先根据用户名查询用户是否存在，如果不存在在执行添加用户方法，存在则不添加。

2.别忘记提交事务，增删改需要提交事务

3.3web层

import org.apache.commons.beanutils.BeanUtils;

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.lang.reflect.InvocationTargetException;

@WebServlet("/registerServlet")
public class RegisterServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.处理post请求乱码
        request.setCharacterEncoding("utf-8");
        //2.接收请求数据封装到User实体类对象中
        User user = new User();
        try {
            BeanUtils.populate(user, request.getParameterMap());
            //3. 创建业务层对象
            UserService service = new UserService();
            //4. 使用业务层对象调用注册方法将用户数据传递到service层
            boolean result = service.register(user);
            //5. 判断result结果
            if (result) {
                //6. 表示注册成功, 跳转到登录页面
                response.sendRedirect("/login.html");
            } else {
                //7. 注册失败，跳转到失败页面
                response.sendRedirect("/registerError.html");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.4页面实现

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="#" method="get">

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

registerError.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h2>注册失败，<a href="register.html">重新注册</a></h2>
</body>
</html>