• JavaWeb基础6——Request,Response,JSP&MVC

    用于复习快速回顾。

    目录

    Request&Response概述

    Request对象

    Request继承体系

    Request获取请求数据的方法

    获取请求行数据

     获取请求头数据

    获取请求体数据

    获取请求参数的通用方式

    IDEA使用模板创建Servlet

    请求参数中文乱码问题

    POST请求getParameter解决方案 

    GET请求getParameter解决方案

    Request请求转发

    Response对象

    Response设置响应数据

    Respones请求重定向

    重定向

    转发和重定向区别和应用场景

    在路径中判断是否加虚拟目录

    Response响应字符数据

    Response响应字节数据

    Request、Response、Mybatis、前端注册登录小项目

    代码

    SqlSessionFactory工具类抽取

    JSP

    JSP 概述

    helloworld

    JSP 原理

    JSP 脚本

    JSP 脚本分类

    案例,使用JSP脚本展示品牌数据

    JSP 缺点

    EL 表达式

    概述

    代码演示，把Servlet的List转发给jsp页面输出

    域对象

    JSTL（JSP标准标签库）标签

    概述

    if 标签

    forEach 标签

    MVC模式和三层架构

    MVC模式

    三层架构

    MVC 和 三层架构

    品牌数据增删改查案例

    主要坑点

    环境准备

    查询所有​编辑

    添加​编辑

    修改（回显数据）​编辑

    Request&Response概述

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

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

    • request:获取请求数据

      • 浏览器会发送HTTP请求到后台服务器[Tomcat]

      • HTTP的请求中会包含很多请求数据[请求行+请求头+请求体]

      • 后台服务器[Tomcat]会对HTTP请求中的数据进行解析并把解析结果存入到request对象中

      • 我们可以从request对象中获取请求的相关参数

      • 获取到数据后就可以继续后续的业务，比如获取用户名和密码就可以实现登录操作的相关业务

    • response:设置响应数据

      • 业务处理完后，后台就需要给前端返回业务处理的结果即响应数据

      • 把响应数据封装到response对象中

      • 后台服务器[Tomcat]会解析response对象,按照[响应行+响应头+响应体]格式拼接结果

      • 浏览器最终解析结果，把内容展示在浏览器给用户浏览

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

    1. @WebServlet("/demo3")
    2. public class ServletDemo3 extends HttpServlet {
    3.     @Override
    4.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    5.         //使用request对象 获取请求数据
    6.         String name = request.getParameter("name");//url?name=zhangsan
    7.  
    8.         //使用response对象 设置响应数据
    9.         response.setHeader("content-type","text/html;charset=utf-8");
    10.         response.getWriter().write("
      "+name+",欢迎您！
      "      );
    11.     }
    12.  
    13.     @Override
    14.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    15.         System.out.println("Post...");
    16.     }
    17. }

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

    小结

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

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

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

    Request对象

    Request继承体系

    • Request的继承体系为ServletRequest-->HttpServletRequest-->RequestFacade

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

    思考

    • ServletRequest和HttpServletRequest的关系是什么?

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

    • request提供了哪些API,这些API从哪里查?

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

    RequestFacade类:

    • 该类是Tomcat定义的实现类，实现了HttpServletRequest接口，也间接实现了ServletRequest接口。

    • Servlet类中的service方法、doGet方法或者是doPost方法最终都是由Web服务器[Tomcat]来调用的，所以Tomcat提供了方法参数接口的具体实现类RequestFacade，并完成了对象的创建

    • 要想了解RequestFacade中都提供了哪些方法，我们可以直接查看JavaEE的API文档中关于ServletRequest和HttpServletRequest的接口文档，因为RequestFacade实现了其接口就需要重写接口中的方法

    Request获取请求数据的方法

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

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

    • 请求行

      • getMethod()获取请求方式

      • getContextPath()获取项目访问路径

      • getRequestURL()获取请求URL

      • getRequestURI()获取请求URI

      • getQueryString()获取GET请求方式的请求参数

    • 请求头

      • getHeader(String name)根据请求头名称获取其对应的值

    • 请求体

      • 注意: 浏览器发送的POST请求才有请求体

      • 如果是纯文本数据:getReader()

      • 如果是字节数据如文件数据:getInputStream()

    获取请求行数据

    请求行包含三块内容，分别是请求方式、请求资源路径、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()

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

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Titletitle>
    6. head>
    7. <body>
    8. <form action="/request-demo/req1" method="get" target="_blank">
    9.     <input name="username"/><input type="submit"/>
    10. form>
    11. body>
    12. html>

    1. /**
    2.  * request 获取请求数据
    3.  */
    4. @WebServlet("/req1")
    5. public class RequestDemo1 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    8.         // String getMethod()：获取请求方式： GET
    9.         String method = req.getMethod();
    10.         System.out.println(method);//GET
    11.         // String getContextPath()：获取虚拟目录(项目访问路径)：/request-demo
    12.         String contextPath = req.getContextPath();
    13.         System.out.println(contextPath);
    14.         // StringBuffer getRequestURL(): 获取URL(统一资源定位符)：http://localhost:8080/request-demo/req1
    15.         StringBuffer url = req.getRequestURL();
    16.         System.out.println(url.toString());
    17.         // String getRequestURI()：获取URI(统一资源标识符)： /request-demo/req1
    18.         String uri = req.getRequestURI();
    19.         System.out.println(uri);
    20.         // String getQueryString()：获取请求参数（GET方式）： username=zhangsan
    21.         String queryString = req.getQueryString();
    22.         System.out.println(queryString);
    23.     }
    24.     @Override
    25.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    26.     }
    27. }

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

     获取请求头数据

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

    1. Host: 表示请求的主机名
    2. User-Agent: 浏览器版本,例如Chrome浏览器的标识类似Mozilla/5.0 ...Chrome/79，IE浏览器的标识类似Mozilla/5.0 (Windows NT ...)like Gecko；
    3. Accept：表示浏览器能接收的资源类型，如text/*，image/*或者*/*表示所有；
    4. Accept-Language：表示浏览器偏好的语言，服务器可以据此返回不同语言的网页；
    5. Accept-Encoding：表示浏览器可以支持的压缩类型，例如gzip, deflate等。

      

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

    String getHeader(String name)

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

    1. /**
    2.  * request 获取请求数据
    3.  */
    4. @WebServlet("/req1")
    5. public class RequestDemo1 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    8.         //获取请求头: user-agent: 浏览器的版本信息
    9.         String agent = req.getHeader("user-agent");
    10. 		System.out.println(agent);
    11.     }
    12.     @Override
    13.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    14.     }
    15. }
    ​

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

    获取请求体数据

    浏览器在发送GET请求的时候是没有请求体的，请求参数在请求行里。

    所以需要把请求方式变更为POST，请求参数QueryString在请求体里。请求体中的数据格式如下:

    Request对象获取请求体数据方式：

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

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

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

    BufferedReader getReader()

    示例： 

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

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Titletitle>
    6. head>
    7. <body>
    9. <form action="/request-demo/req1" method="post">
    10.     <input type="text" name="username">
    11.     <input type="password" name="password">
    12.     <input type="submit">
    13. form>
    14. body>
    15. html>

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

    1. /**
    2.  * request 获取请求数据
    3.  */
    4. @WebServlet("/req1")
    5. public class RequestDemo1 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    8.     }
    9.     @Override
    10.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    11.          //获取post 请求体：请求参数
    12.         //1. 获取字符输入流
    13.         BufferedReader br = req.getReader();
    14.         //2. 读取数据，读一行即可，因为请求体只有一行。所有请求参数会用＆符号拼接成一行
    15.         String line = br.readLine();    
    16.         System.out.println(line);
    17.         //br.close();//可以不写，因为销毁request后br也就跟着销毁了
    18.     }
    19. }

    注意

    BufferedReader流是通过request对象来获取的，当请求完成后request对象就会被销毁，request对象被销毁后，BufferedReader流就会自动关闭，所以此处就不需要手动关闭流了。

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

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

    获取请求参数的通用方式

    1.什么是请求参数?

    我们拿用户登录的例子来说明，用户名和密码其实就是我们所说的请求参数。

    2.什么是请求数据?

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

    获取请求参数的两种方法： 

    方法一：获取连体参数，get和post不同

    • GET方式:

    String getQueryString()

    • POST方式:

    BufferedReader getReader();

    示例：

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

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

    代码如下:

    1. @WebServlet("/req1")
    2. public class RequestDemo1 extends HttpServlet {
    3.     @Override
    4.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    5.  
    6.         String result = req.getQueryString();
    7.         System.out.println(result);
    8.  
    9.     }
    10.     @Override
    11.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    12.         BufferedReader br = req.getReader();
    13.         String result = br.readLine();
    14.         System.out.println(result);
    15.     }
    16. }

    因为get和post请求参数分别在请求行和请求体，故存在代码重复问题

    方法二:通用方法获取分割后的参数，get和post通用

    request对象把分割后的请求参数，存入到一个Map集合中:

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

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

    • 获取所有参数Map集合

    Map<String,String[]> getParameterMap()    //标签的name：value。值是数组，因为有时传来的同name键对应多个value，例如checkbox。

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

    String[] getParameterValues(String name)

    • 根据名称获取参数值(单个值)，最常用

    String getParameter(String name)

    注意：用方法一获取后，再用方法一还能获取数值，再用方法二会返回不到数值。 用方法二获取后，再用方法二还能获取数值，再用方法一会返回不到数值。

    案例演示：

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

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Titletitle>
    6. head>
    7. <body>
    8. <form action="/request-demo/req2" method="get">
    9.     <input type="text" name="username"><br>
    10.     <input type="password" name="password"><br>
    11.     <input type="checkbox" name="hobby" value="1"> 游泳
    12.     <input type="checkbox" name="hobby" value="2"> 爬山 <br>
    13.     <input type="submit">
    14.  
    15. form>
    16. body>
    17. html>

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

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

    1. /**
    2.  * request 通用方式获取请求参数
    3.  */
    4. @WebServlet("/req2")
    5. public class RequestDemo2 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    8.         //GET请求逻辑
    9.         System.out.println("get....");
    10.         //1. 获取所有参数的Map集合
    11.         Map map = req.getParameterMap();
    12.         for (String key : map.keySet()) {
    13.             // username:zhangsan lisi
    14.             System.out.print(key+":");
    15.  
    16.             //获取值
    17.             String[] values = map.get(key);
    18.             for (String value : values) {
    19.                 System.out.print(value + " ");
    20.             }
    21.  
    22.             System.out.println();
    23.         }
    24.     }
    25.  
    26.     @Override
    27.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    28.         this.doGet(req,resp);
    29.     }
    30. }

    获取的结果为:

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

    1. /**
    2.  * request 通用方式获取请求参数
    3.  */
    4. @WebServlet("/req2")
    5. public class RequestDemo2 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    8.         //GET请求逻辑
    9.         //...
    10.         System.out.println("------------");
    11.         String[] hobbies = req.getParameterValues("hobby");
    12.         for (String hobby : hobbies) {
    13.             System.out.println(hobby);
    14.         }
    15.     }
    16.  
    17.     @Override
    18.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    19.     }
    20. }

    获取的结果为:

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

    1. /**
    2.  * request 通用方式获取请求参数
    3.  */
    4. @WebServlet("/req2")
    5. public class RequestDemo2 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    8.         //GET请求逻辑
    9.         //...
    10.         String username = req.getParameter("username");
    11.         String password = req.getParameter("password");
    12.         System.out.println(username);
    13.         System.out.println(password);
    14.     }
    15.  
    16.     @Override
    17.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    18.     }
    19. }

    获取的结果为:

    post与get一样，在Servlet代码中获取页面传递POST请求的参数值；将req.html页面form表单的提交方式改成post；将doGet方法中的内容直接复制到doPost方法中即可

    小结

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

    • 以后我们再写代码的时候，就只需要按照如下格式来编写:

    1. public class RequestDemo1 extends HttpServlet {
    2.     @Override
    3.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    4.        //采用request提供的获取请求参数的通用方式来获取请求参数
    5.        //编写其他的业务代码...
    6.     }
    7.     @Override
    8.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    9.         this.doGet(req,resp);
    10.     }
    11. }

    IDEA使用模板创建Servlet

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

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

    (1)按照自己的需求，修改Servlet创建的模板内容。annotated译为带注释的

     主要改动注解和加this使代码简洁：

    1. @WebServlet("/${Entity_Name}")
    2. public class ${Class_Name} extends HttpServlet {
    3.     @Override
    4.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    5.  
    6.     }
    7.  
    8.     @Override
    9.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    10.         this.doGet(request,response);
    11.     }
    12. }

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

    IDEA中new 没有servlet 的选项解决方法：

    首先检查Servlet的依赖是否导入pom.xml

    1.     <dependency>
    2.       <groupId>javax.servletgroupId>
    3.       <artifactId>javax.servlet-apiartifactId>
    4.       <version>3.1.0version>
    5.     dependency>

    file-项目结构（注意main文件夹下要有java和resources目录）：

    请求参数中文乱码问题

    getParameter方法

    post乱码原因：获取参数底层是获取请求体方法getReader()，获取到的参数编码为ISO-8859-1。解决思路：设置request字符编码为utf-8，或者请求参数字符串解码为utf-8。

    get乱码原因：提交表单后，get请求参数会进行SO-8859-1的url编码追加到地址栏链接后面，Tomcat7获取到的参数编码为ISO-8859-1的url编码，Tomcat8获取到的参数编码为utf-8的URL编码。

    解决思路：使用Tomcat8、9、10，或者先ISO-8859-1的url解码成字符数组，再utf-8编码。

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

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

    • GET请求Tomcat8直接解决。

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

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

      所以Tomcat8只setCharacterEncoding就可以解决所有编码中文问题。

    getQueryString和getReader方法：

    URLDecoder.decode(request.getQueryString(),"utf-8")

     问题展示:

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

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Titletitle>
    6. head>
    7. <body>
    8. <form action="/request-demo/req2" method="get">
    9.     <input type="text" name="username"><br>
    10.     <input type="password" name="password"><br>
    11.     <input type="checkbox" name="hobby" value="1"> 游泳
    12.     <input type="checkbox" name="hobby" value="2"> 爬山 <br>
    13.     <input type="submit">
    14.  
    15. form>
    16. body>
    17. html>

    (2)在Servlet方法中获取参数，并打印

    1. /**
    2.  * 中文乱码问题解决方案
    3.  */
    4. @WebServlet("/req4")
    5. public class RequestDemo4 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.        //1. 获取username
    9.        String username = request.getParameter("username");
    10.        System.out.println(username);
    11.     }
    12.  
    13.     @Override
    14.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    15.         this.doGet(request, response);
    16.     }
    17. }

    （3）启动服务器，页面上输入中文参数，提交后会发现控制台中文乱码：

    POST请求getParameter解决方案 

    •  设置输入流的编码

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

    • 分析出现中文乱码的原因：

      • POST的请求参数是通过request的getReader()来获取流中的数据

      • 在获取流的时候解码方式是ISO-8859-1

      • ISO-8859-1编码是不支持中文的，所以会出现乱码

    • 解决方案：

      • 页面设置的编码格式为UTF-8

      • 把TOMCAT在获取流数据之前的编码设置为UTF-8

      • 通过request.setCharacterEncoding("UTF-8")设置编码,UTF-8也可以写成小写

    getParameter代码:

    1. /**
    2.  * 中文乱码问题解决方案
    3.  */
    4. @WebServlet("/req4")
    5. public class RequestDemo4 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         //1. 解决乱码: POST getReader()
    9.         //设置字符输入流的编码，设置的字符集要和页面保持一致
    10.         request.setCharacterEncoding("UTF-8");    //Tomcat8可以注释这句
    11.        //2. 获取username
    12.        String username = request.getParameter("username");
    13.        System.out.println(username);
    14.     }
    15.  
    16.     @Override
    17.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    18.         this.doGet(request, response);
    19.     }
    20. }

    getReader代码: 

    1.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    2.  
    3.         BufferedReader br = request.getReader();
    4.         String string=br.readLine();
    5.         System.out.println(URLDecoder.decode(string,"utf-8"));
    6.     }

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

    GET请求getParameter解决方案

    在Tomcat7要new String(username.getBytes("ISO-8859-1"),"UTF-8");Tomcat8直接用不会乱码。

    POST请求的中文乱码解决方案为什么不适用GET请求？

    • request.setCharacterEncoding("utf-8")是设置request处理流的编码

    • getQueryString方法并没有通过流的方式获取数据

    所以GET请求不能用设置编码的方式来解决中文乱码问题。

    GET请求中文参数乱码的原因

    • 浏览器把中文参数按照UTF-8进行URL编码（URL编码示例：%E9%9D%9E。Chrome地址栏会把URL编码转成utf-8方便阅读，i传到服务器的还是URL编码）

    • Tomcat对获取到的内容进行了ISO-8859-1的URL解码

    • 在控制台就会出现类上å¼ ä¸的乱码，最后一位是个空格

    思考:

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

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

    URL编码

    这块知识了解即可。

    具体编码过程分两步，分别是:

    (1)将字符串按照编码方式转为二进制

    (2)每个字节转为2个16进制数并在前边加上%

    例如，张三按照UTF-8的方式转换成二进制的结果为:

    1110 0101 1011 1100 1010 0000 1110 0100 1011 1000 1000 1001

    计算utf-8字符串二进制方法

    使用http://www.mytju.com/classcode/tools/encode_utf8.asp，输入张三

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

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

    Java中url编码和解码的API工具类

    编码:

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

    解码:

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

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

    1. import java.io.UnsupportedEncodingException;
    2. import java.net.URLDecoder;
    3. import java.net.URLEncoder;
    4. public class URLDemo {
    5.  
    6.   public static void main(String[] args) throws UnsupportedEncodingException {
    7.         String username = "张三";
    8.         //1. URL编码
    9.         String encode = URLEncoder.encode(username, "utf-8");
    10.         System.out.println(encode); //打印:%E5%BC%A0%E4%B8%89
    11.  
    12.        //2. URL解码
    13.        //String decode = URLDecoder.decode(encode, "utf-8");//打印:张三
    14.        String decode = URLDecoder.decode(encode, "ISO-8859-1");//打印:`å¼ ä¸ `
    15.        System.out.println(decode);
    16.     }
    17. }

    分析解决乱码原理：

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

    解决代码

    1. /**
    2.  * 中文乱码问题解决方案
    3.  */
    4. @WebServlet("/req4")
    5. public class RequestDemo4 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         //1. 解决乱码：POST，getReader()
    9.         //request.setCharacterEncoding("UTF-8");//设置字符输入流的编码
    10.  
    11.  
    12.         //3. GET,获取参数的方式：getQueryString
    13.         // 乱码原因：tomcat进行URL解码，默认的字符集ISO-8859-1
    14.        /* //3.1 先对乱码数据进行编码：转为字节数组
    15.         byte[] bytes = username.getBytes(StandardCharsets.ISO_8859_1);
    16.         //3.2 字节数组解码
    17.         username = new String(bytes, StandardCharsets.UTF_8);*/
    18.  
    19.         username  = new String(username.getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8);
    20.  
    21.         System.out.println("解决乱码后："+username);
    22.  
    23.     }
    24.  
    25.     @Override
    26.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    27.         this.doGet(request, response);
    28.     }
    29. }

    注意

    把request.setCharacterEncoding("UTF-8")代码注释掉后，会发现GET请求参数乱码解决方案同时也可也把POST请求参数乱码的问题也解决了。

    只不过对于POST请求参数一般都会比较多，采用这种方式解决乱码起来比较麻烦，所以对于POST请求还是建议使用设置编码的方式进行。

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

    小结

    中文乱码解决方案

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

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

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

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

    所有Tomcat版本通用方式（GET/POST）：需要先解码，再编码

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

    URL编码实现方式:

    • 编码:

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

    • 解码:

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

    Request请求转发

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

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

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

    (3)资源B处理完后将结果响应给浏览器，继续执行A剩下代码

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

    请求转发的实现方式:

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

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

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

    (1)创建RequestDemo5类

    1. /**
    2.  * 请求转发
    3.  */
    4. @WebServlet("/req5")
    5. public class RequestDemo5 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         System.out.println("demo5...");
    9.     }
    10.  
    11.     @Override
    12.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    13.         this.doGet(request, response);
    14.     }
    15. }

    (2)创建RequestDemo6类

    1. /**
    2.  * 请求转发
    3.  */
    4. @WebServlet("/req6")
    5. public class RequestDemo6 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         System.out.println("demo6...");
    9.     }
    10.  
    11.     @Override
    12.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    13.         this.doGet(request, response);
    14.     }
    15. }

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

    1. /**
    2.  * 请求转发
    3.  */
    4. @WebServlet("/req5")
    5. public class RequestDemo5 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         System.out.println("demo5...");
    9.         //请求转发
    10.         request.getRequestDispatcher("/req6").forward(request,response);
    11.     }
    12.  
    13.     @Override
    14.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    15.         this.doGet(request, response);
    16.     }
    17. }

    (4)启动测试

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

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

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

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

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

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

    void setAttribute(String name,Object o);

    • 根据key获取值

    Object getAttribute(String name);

    • 根据key删除该键值对

    void removeAttribute(String name);

    代码示例：

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

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

    3.启动访问测试

    (1)修改RequestDemo5中的方法

    1. @WebServlet("/req5")
    2. public class RequestDemo5 extends HttpServlet {
    3.     @Override
    4.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    5.         System.out.println("demo5...");
    6.         //存储数据
    7.         request.setAttribute("msg","hello");
    8.         //请求转发
    9.         request.getRequestDispatcher("/req6").forward(request,response);
    10.  
    11.     }
    12.  
    13.     @Override
    14.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    15.         this.doGet(request, response);
    16.     }
    17. }

    (2)修改RequestDemo6中的方法

    1. /**
    2.  * 请求转发
    3.  */
    4. @WebServlet("/req6")
    5. public class RequestDemo6 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         System.out.println("demo6...");
    9.         //获取数据
    10.         Object msg = request.getAttribute("msg");
    11.         System.out.println(msg);
    12.  
    13.     }
    14.  
    15.     @Override
    16.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    17.         this.doGet(request, response);
    18.     }
    19. }

    (3)启动测试

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

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

    请求转发的特点

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

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

    • 只能转发到当前服务器的内部资源。不能从一个服务器通过转发访问另一台服务器

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

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

    Response对象

    • Request:使用request对象来获取请求数据

    • Response:使用response对象来设置响应数据

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

    Response设置响应数据

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

    响应行

    常用的就是设置响应状态码:

    void setStatus(int sc);

    响应头

    设置响应头键值对：

    void setHeader(String name,String value);

    响应体

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

    获取字符输出流:

    PrintWriter getWriter();

    获取字节输出流

    ServletOutputStream getOutputStream();

    Respones请求重定向

    重定向

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

    重定向只是向response中添加了一条重定向地址，并不会立即响应给浏览器，只有当doFilter()或者service()执行完毕才会将响应信息封装起来发送给浏览器

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

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

    (3)浏览器（对比，请求转发是直接资源a到资源b）接收到响应状态码为302就会重新发送请求到location对应的访问地址去访问资源B

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

    状态码分类    说明
    1xx    响应中——临时状态码，表示请求已经接受，告诉客户端应该继续请求或者如果它已经完成则忽略它
    2xx    成功——表示请求已经被成功接收，处理已完成
    3xx    重定向——重定向到其它地方：它让客户端再发起一个请求以完成整个处理。
    4xx    客户端错误——处理发生错误，责任在客户端，如：客户端的请求一个不存在的资源，客户端未被授权，禁止访问等
    5xx    服务器端错误——处理发生错误，责任在服务端，如：服务端抛出异常，路由出错，HTTP版本不支持等

    重定向的实现方式一:

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

    方式二：推荐

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


    1. //动态获取项目虚拟目录更好
    2.         String contextPath = request.getContextPath();
    3.         response.sendRedirect(contextPath+"/resp2");

    案例：

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

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

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

    3.在ResponseDemo1的方法中使用

    response.setStatus(302);

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

    4.启动测试

    (1)创建ResponseDemo1类

    1. @WebServlet("/resp1")
    2. public class ResponseDemo1 extends HttpServlet {
    3.     @Override
    4.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    5.         System.out.println("resp1....");
    6.         //重定向
    7.         //1.设置响应状态码 302
    8.         response.setStatus(302);
    9.         //2. 设置响应头 Location
    10.         response.setHeader("Location","/request-demo/resp2");
    11.     }
    12.  
    13.     @Override
    14.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    15.         this.doGet(request, response);
    16.     }
    17. }

    (2)创建ResponseDemo2类

    1. @WebServlet("/resp2")
    2. public class ResponseDemo2 extends HttpServlet {
    3.     @Override
    4.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    5.         System.out.println("resp2....");
    6.     }
    7.  
    8.     @Override
    9.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    10.         this.doGet(request, response);
    11.     }
    12. }

    (3)启动测试

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

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

    简化的重定向编写方式为:

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

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

    1. @WebServlet("/resp1")
    2. public class ResponseDemo1 extends HttpServlet {
    3.     @Override
    4.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    5.         System.out.println("resp1....");
    6.         //重定向
    7.         resposne.sendRedirect("/request-demo/resp2")；
    8.     }
    9.  
    10.     @Override
    11.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    12.         this.doGet(request, response);
    13.     }
    14. }

    重定向的特点：（与请求转发正好相反）

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

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

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

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

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

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

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

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

    转发和重定向区别和应用场景

    区别 

    1.跳转的范围不同
    由于转发是在服务器内部进行的，跳转的范围被限制在当前服务器的当前应用。

    而重定向由浏览器发送URL请求完成，范围是所有服务器的所有应用

    2.“/”标识符代表的含义不同
    由于转发是在服务器内部进行的，在指定转发的URL中，“/”代表当前应用

    而重定向的“/”则代表当前服务器。

    3.刷新后是否会重新提交表单/参数
    转发：对于转发而言，通过Request对象携带的参数会继续存在，若刷新当前页面，则会导致已经提交的表单再次提交，对于主流浏览器而言，此时会弹出是否重复提交表单的确认弹窗。

    重定向：而重定向不会携带这些数据，刷新时安全的。

    6.效率不同
    对于转发而言，过程发生在服务器内部，不经过重定向的二次网络过程和请求，因此效率更高

    7.携带参数的方式不同
    对于转发而言，携带参数跳转的方式是通过方法request.setParameter来绑定。

    而对于重定向，一种可行的办法是用?key=value&key2=value2的方式在URL后面增加显性参数。

    应用场景：


    建议一：

    对于竭力避免表单重复提交的场景下选择重定向方式，防止不断刷新页面引起的重复提交表单。

    建议二：

    对于效率要求更高的场景选择服务器内转发

    建议三：

    若携带较多参数则选择服务器内转发，一般是同一业务内需要携带参数多。

    请求转发偏向于、为同一业务功能服务
    重定向偏向于、不同业务功能之间的跳转

    在路径中判断是否加虚拟目录

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

    是否加虚拟目录(项目访问路径)的依据

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

    • 服务端使用:不需要加虚拟目录

    对于转发来说，因为是在服务端直接从资源a发送到b，所以不需要加虚拟目录

    对于重定向来说，路径最终是由浏览器来发送请求到location地址去访问资源B，就需要添加虚拟目录。

    练习：下面是否需要加虚拟目录

    答案:

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

    目前学的也就转发不加虚拟目录。 

    问题2：如何动态配置项目虚拟目录。防止后期通过Tomcat插件配置了项目的访问路径，那么所有需要重定向的地方都需要重新修改

    答案也比较简单，我们可以在代码中动态去获取项目访问的虚拟目录，使用request对象中的请求行获取虚拟目录方法getContextPath()，修改后的代码如下:

    1. @WebServlet("/resp1")
    2. public class ResponseDemo1 extends HttpServlet {
    3.     @Override
    4.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    5.         System.out.println("resp1....");
    6.  
    7.         //简化方式完成重定向
    8.         //动态获取虚拟目录
    9.         String contextPath = request.getContextPath();
    10.         response.sendRedirect(contextPath+"/resp2");    //使用指定的重定向位置URL向客户端发送一个临时重定向响应，并清除缓冲区。
    11.     }
    12.  
    13.     @Override
    14.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    15.         this.doGet(request, response);
    16.     }
    17. }

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

    Response响应字符数据

    了解即可，实际应用一般是把request转发到前端页面JSP中展示，每行用write写太复杂，并且前后端不分离。

    响应字符数据到浏览器

    • 先设置内容类型contentType和编码

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

    • 通过Response对象获取字符输出流： PrintWriter writer = resp.getWriter();

    • 通过字符输出流写数据: writer.write("aaa");

     PrintWriter是字符打印流

    示例：

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

    1. /**
    2.  * 响应字符数据：设置字符数据的响应体
    3.  */
    4. @WebServlet("/resp3")
    5. public class ResponseDemo3 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         //必须设置编码，否则中文会乱码
    9.         response.setContentType("text/html;charset=utf-8");    
    10.         //1. 获取字符输出流
    11.         PrintWriter writer = response.getWriter();
    12. 		 writer.write("aaa");
    13.     }
    14.     @Override
    15.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    16.         this.doGet(request, response);
    17.     }
    18. }

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

    1. PrintWriter writer = response.getWriter();
    2. //content-type，告诉浏览器返回的数据类型是HTML类型数据，这样浏览器才会解析HTML标签
    3. //设置字符集防止乱码中文
    4. response.setHeader("content-type","text/html;charset=utf-8");
    5. //response.setContentType("text/html;charset=utf-8");//或者直接设置content-type
    6. writer.write("
      aaa
      "      );

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

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

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

    Response响应字节数据

    响应字节数据到浏览器

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

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

    示例：

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

    1. /**
    2.  * 响应字节数据：设置字节数据的响应体
    3.  */
    4. @WebServlet("/resp4")
    5. public class ResponseDemo4 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         //1. 读取文件
    9.         FileInputStream fis = new FileInputStream("d://a.jpg");
    10.         //2. 获取response字节输出流
    11.         ServletOutputStream os = response.getOutputStream();
    12.         //3.1. 方法一，完成流的copy
    13.         byte[] buff = new byte[1024];
    14.         int len = 0;
    15.         while ((len = fis.read(buff))!= -1){
    16.             os.write(buff,0,len);
    17.         }
    18.         //3.2.  方法二，工具类快速流的复制，需要pom导坐标commons-io
    19.         //IOUtils.copy(fis,os);
    20.         fis.close();
    21.     }
    22.  
    23.     @Override
    24.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    25.         this.doGet(request, response);
    26.     }
    27. }

    使用IOUtils.copy(fis,os)进行流的复制（推荐）

    (1)pom.xml添加依赖

    1. <dependency>
    2.     <groupId>commons-iogroupId>
    3.     <artifactId>commons-ioartifactId>
    4.     <version>2.6version>
    5. dependency>

    (2)调用工具类方法实现复制

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

    优化后的代码:

    1. /**
    2.  * 响应字节数据：设置字节数据的响应体
    3.  */
    4. @WebServlet("/resp4")
    5. public class ResponseDemo4 extends HttpServlet {
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.         //1. 读取文件
    9.         FileInputStream fis = new FileInputStream("d://a.jpg");
    10.         //2. 获取response字节输出流
    11.         ServletOutputStream os = response.getOutputStream();
    12.         //3. 完成流的copy
    13.       	IOUtils.copy(fis,os);
    14.         fis.close();
    15.     }
    16.  
    17.     @Override
    18.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    19.         this.doGet(request, response);
    20.     }
    21. }

    Request、Response、Mybatis、前端注册登录小项目

    代码

    需求：

    项目结构

     数据库准备

    1. -- 创建用户表，在db1数据库下创建
    2. CREATE TABLE tb_user(
    3. 	id int primary key auto_increment,
    4. 	username varchar(20) unique,
    5. 	password varchar(32)
    6. );
    7.  
    8. -- 添加数据
    9. INSERT INTO tb_user(username,password) values('zhangsan','123'),('lisi','234');
    10.  
    11. SELECT * FROM tb_user;
    12.  
    13.

     代码

    Request、Response、Mybatis、前端注册登录小项目-Java文档类资源-CSDN下载

    SqlSessionFactory工具类抽取

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

    注册登录Servlet.java在使用Mybatis时候中都用到了上面代码，这些重复代码就会造成一些问题:

    • 重复代码不利于后期的维护

    • SqlSessionFactory工厂类进行重复创建

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

    解决方案

    • 代码重复可以抽取工具类

    • 对指定代码只需要执行一次可以使用静态代码块 

    注意：

    SqlSession sqlSession = sqlSessionFactory.openSession();

     虽然上面语句也重复，但不能抽取到工具类里。因为SqlSession是一个连接、会话，每次连接数据库时候创建一次会话是合适，如果所有连接都共用一个会话会互相影响。

    SqlSession是一个会话，相当于JDBC中的一个Connection对象，Mybatis中所有的数据库交互都由SqlSession来完成。

    代码示例：

    抽取工具类

    1. public class SqlSessionFactoryUtils {
    2.  
    3.     private static SqlSessionFactory sqlSessionFactory;
    4.  
    5.     static {
    6.         //静态代码块会随着类的加载而自动执行，且只执行一次
    7.         //静态代码块不能抛异常，要用try-catch
    8.         try {
    9.             String resource = "mybatis-config.xml";
    10.             InputStream inputStream = Resources.getResourceAsStream(resource);
    11.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    12.         } catch (IOException e) {
    13.             e.printStackTrace();
    14.         }
    15.     }
    16.  
    17.  
    18.     public static SqlSessionFactory getSqlSessionFactory(){
    19.         return sqlSessionFactory;
    20.     }
    21. }

    使用工具类

    SqlSessionFactory sqlSessionFactory =SqlSessionFactoryUtils.getSqlSessionFactory();

    JSP

    JSP 概述

    了解即可，现在基本都不用jsp了，新技术都是用vue、axios，前后端分离。jsp算旧技术，但有些项目是用jsp开发的，所以还是学一下。

    JSP（全称：Java Server Pages）：Java 服务端页面。

    是一种动态的网页技术，其中既可以定义 HTML、JS、CSS等静态内容，还可以定义 Java代码的动态内容，也就是 JSP = HTML + Java。

    JSP和JavaScript是两码事，JSP是java服务端页面，JavaScript是脚本语言的一种。 

    jsp代码示例：

    1. <html>
    2.     <head>
    3.         <title>Titletitle>
    4.     head>
    5.     <body>
    6.         <h1>JSP,Hello Worldh1>
    7.         <%
    8.         	System.out.println("hello,jsp~");
    9.         %>
    10.     body>
    11. html>

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

    JSP 作用：

    简化开发，避免了在Servlet中直接输出HTML标签，前后端分离。

    如果只用 servlet，实现页面动态显示用户名：

     

    上面的代码有大量使用到 writer 对象向页面写标签内容，这样我们的代码就显得很麻烦；将来如果展示的效果出现了问题，排错也显得有点力不从心。

    用JSP实现页面动态显示用户名：

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

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

    helloworld

    接下来我们做一个简单的快速入门代码。

    创建maven的 web 项目

    导入JSP依赖

    1. <dependency>
    2.     <groupId>javax.servlet.jspgroupId>
    3.     <artifactId>jsp-apiartifactId>
    4.     <version>2.2version>
    5.     <scope>providedscope>
    6. dependency>

    pom.xml 文件内容如下：导入Servlet和JSP依赖，Tomcat插件

    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <groupId>org.examplegroupId>
    8.     <artifactId>jsp-demoartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.     <packaging>warpackaging>
    11.  
    12.     <properties>
    13.         <maven.compiler.source>8maven.compiler.source>
    14.         <maven.compiler.target>8maven.compiler.target>
    15.     properties>
    16.  
    17.     <dependencies>
    18.       <dependency>
    19.             <groupId>javax.servletgroupId>
    20.             <artifactId>javax.servlet-apiartifactId>
    21.             <version>3.1.0version>
    22.             <scope>providedscope>
    23.         dependency>
    24.     dependencies>
    25.  
    26.     <build>
    27.         <plugins>
    28.             <plugin>
    29.                 <groupId>org.apache.tomcat.mavengroupId>
    30.                 <artifactId>tomcat7-maven-pluginartifactId>
    31.                 <version>2.2version>
    32.             plugin>
    33.         plugins>
    34.     build>
    35. project>

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

    创建 jsp 页面

    在项目的 webapp 下创建jsp页面

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

    编写代码

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

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    4.     Title
    7.     
      hello jsp
    8.  
    9.     <%
    10.         System.out.println("hello,jsp~");
    11.     %>

    测试

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

     注意：Tomcat版本和jdk版本不能差太大，例如jdk18、Tomcat8.5运行jsp就会报错HTTP 500-Unable to compile class for JSP，jdk18和Tomcat10会Servlet页面打不开400，jdk18和Tomcat9正常。

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

    JSP 原理

    JSP 本质上就是一个 Servlet，所以可以写 Java 代码。

    访问jsp时的流程

     最终对外提供服务的就是jsp转换、编译成的字节码文件。

    1. 浏览器第一次访问 hello.jsp 页面

    2. tomcat 会将 hello.jsp 转换为名为 hello_jsp.java 的一个 Servlet

    3. tomcat 再将转换的 servlet 编译成字节码文件 hello_jsp.class

    4. tomcat 会执行该字节码文件，向外提供服务

    验证jsp文件转成Servlet类 

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

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

    可以看到这个由jsp转成的Servlet类继承了名为 HttpJspBase 这个类，而通过Tomcat源码可以发现HttpJspBase 继承了 HttpServlet ：

    那么 hello_jsp 这个由jsp转换的类就间接的继承了 HttpServlet ，也就说明 hello_jsp 是一个 servlet。

    hello_jsp 类有一个名为 _jspService() 的方法，该方法就是每次访问 jsp 时自动执行的方法，和 servlet 中的 service 方法一样 。

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

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

    JSP 脚本

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

    JSP 脚本分类

    JSP 脚本有如下三个分类：

    • <%...%>            ：内容会直接放到_jspService()方法之中，中间内容在服务器运行

    • <%="…"%>         ：内容会放到out.print()中，作为out.print()的参数，中间内容会打印在网页

    • <%!…%>           ：内容会放到_jspService()方法之外，被类直接包含，中间定义成员变量、方法

    jsp转成的Servlet类中的_jspService() 方法就是每次访问 jsp 时自动执行的方法，和 servlet 中的 service 方法一样 。 

    代码演示：

    <%...%> 

    在 hello.jsp 中书写

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

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

     <%=…%>

    在 hello.jsp 中书写

    1. <%="hello"%>
    2. <%=i%>

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

     <%!…%>

    在 hello.jsp 中书写

    1. <%!
    2.     void  show(){}
    3. 	String name = "zhangsan";
    4. %>

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

    案例,使用JSP脚本展示品牌数据

    需求

    使用JSP脚本展示品牌数据

    素材

    静态的jsp

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2.  
    3. <%
    4.     // 查询数据库
    5.     List<Brand> brands = new ArrayList<Brand>();
    6.     brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
    7.     brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
    8.     brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));
    9.  
    10. %>
    11. html>
    12. <html lang="en">
    13. <head>
    14.     <meta charset="UTF-8">
    15.     <title>Titletitle>
    16. head>
    17. <body>
    18. <input type="button" value="新增"><br>
    19. <hr>
    20. <table border="1" cellspacing="0" width="800">
    21.     <tr>
    22.         <th>序号th>
    23.         <th>品牌名称th>
    24.         <th>企业名称th>
    25.         <th>排序th>
    26.         <th>品牌介绍th>
    27.         <th>状态th>
    28.         <th>操作th>
    29.  
    30.     tr>
    31.     <tr align="center">
    32.         <td>1td>
    33.         <td>三只松鼠td>
    34.         <td>三只松鼠td>
    35.         <td>100td>
    36.         <td>三只松鼠，好吃不上火td>
    37.         <td>启用td>
    38.         <td><a href="#">修改a> <a href="#">删除a>td>
    39.     tr>
    40.  
    41.     <tr align="center">
    42.         <td>2td>
    43.         <td>优衣库td>
    44.         <td>优衣库td>
    45.         <td>10td>
    46.         <td>优衣库，服适人生td>
    47.         <td>禁用td>
    48.  
    49.         <td><a href="#">修改a> <a href="#">删除a>td>
    50.     tr>
    51.  
    52.     <tr align="center">
    53.         <td>3td>
    54.         <td>小米td>
    55.         <td>小米科技有限公司td>
    56.         <td>1000td>
    57.         <td>为发烧而生td>
    58.         <td>启用td>
    59.  
    60.         <td><a href="#">修改a> <a href="#">删除a>td>
    61.     tr>
    62.  
    63.  
    64. table>
    65.  
    66. body>
    67. html>

    实体类Brand.java

    1. package com.itheima.pojo;
    2.  
    3. /**
    4.  * 品牌实体类
    5.  */
    6.  
    7. public class Brand {
    8.     // id 主键
    9.     private Integer id;
    10.     // 品牌名称
    11.     private String brandName;
    12.     // 企业名称
    13.     private String companyName;
    14.     // 排序字段
    15.     private Integer ordered;
    16.     // 描述信息
    17.     private String description;
    18.     // 状态：0：禁用  1：启用
    19.     private Integer status;
    20.  
    21.  
    22.     public Brand() {
    23.     }
    24.  
    25.     public Brand(Integer id, String brandName, String companyName, String description) {
    26.         this.id = id;
    27.         this.brandName = brandName;
    28.         this.companyName = companyName;
    29.         this.description = description;
    30.     }
    31.  
    32.     public Brand(Integer id, String brandName, String companyName, Integer ordered, String description, Integer status) {
    33.         this.id = id;
    34.         this.brandName = brandName;
    35.         this.companyName = companyName;
    36.         this.ordered = ordered;
    37.         this.description = description;
    38.         this.status = status;
    39.     }
    40.  
    41.     public Integer getId() {
    42.         return id;
    43.     }
    44.  
    45.     public void setId(Integer id) {
    46.         this.id = id;
    47.     }
    48.  
    49.     public String getBrandName() {
    50.         return brandName;
    51.     }
    52.  
    53.     public void setBrandName(String brandName) {
    54.         this.brandName = brandName;
    55.     }
    56.  
    57.     public String getCompanyName() {
    58.         return companyName;
    59.     }
    60.  
    61.     public void setCompanyName(String companyName) {
    62.         this.companyName = companyName;
    63.     }
    64.  
    65.     public Integer getOrdered() {
    66.         return ordered;
    67.     }
    68.  
    69.     public void setOrdered(Integer ordered) {
    70.         this.ordered = ordered;
    71.     }
    72.  
    73.     public String getDescription() {
    74.         return description;
    75.     }
    76.  
    77.     public void setDescription(String description) {
    78.         this.description = description;
    79.     }
    80.  
    81.     public Integer getStatus() {
    82.         return status;
    83.     }
    84.  
    85.     public void setStatus(Integer status) {
    86.         this.status = status;
    87.     }
    88.  
    89.     @Override
    90.     public String toString() {
    91.         return "Brand{" +
    92.                 "id=" + id +
    93.                 ", brandName='" + brandName + '\'' +
    94.                 ", companyName='" + companyName + '\'' +
    95.                 ", ordered=" + ordered +
    96.                 ", description='" + description + '\'' +
    97.                 ", status=" + status +
    98.                 '}';
    99.     }
    100. }

    将 brand.jsp 页面改为动态的

    for循环后面可以用JSP标准标签库JSTL的foreach标签优化

    1. <%@ page import="com.itheima.pojo.Brand" %>
    2. <%@ page import="java.util.List" %>
    3. <%@ page import="java.util.ArrayList" %>
    4. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    5.  
    6. <%
    7.     // 查询数据库
    8.     List brands = new ArrayList();
    9.     brands.add(new Brand(1,"三只松鼠","三只松鼠",100,"三只松鼠，好吃不上火",1));
    10.     brands.add(new Brand(2,"优衣库","优衣库",200,"优衣库，服适人生",0));
    11.     brands.add(new Brand(3,"小米","小米科技有限公司",1000,"为发烧而生",1));
    12.  
    13. %>
    14.  
    15.  
    19.     
    20.     Title

    26.     
    27.         
    28.         
    29.         
    30.         
    31.         
    32.         
    33.         
    34.     
    35.     <%
    36.         for (int i = 0; i < brands.size(); i++) {
    37.             Brand brand = brands.get(i);
    38.     %>
    39.  
    40.     
    41.         
    42.         
    43.         
    44.         
    45.         
    46. 		
    47.         
    48.     
    49.  
    50.     <%
    51.         }
    52.     %>
      54. 序号品牌名称企业名称排序品牌介绍状态操作
      <%=brand.getId()%><%=brand.getBrandName()%><%=brand.getCompanyName()%><%=brand.getOrdered()%><%=brand.getDescription()%><%=brand.getStatus() == 1 ? "启用":"禁用"%>修改 删除

    测试

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

    JSP 缺点

    通过上面的案例，我们可以看到 JSP 的很多缺点。

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

    难写难读难维护。

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

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

    • 阅读麻烦

      上面案例的代码，相信你后期再看这段代码时还需要花费很长的时间去梳理

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

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

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

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

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

    由于上述的问题， JSP 已逐渐退出历史舞台，以后开发更多的是使用 HTML + Ajax 来替代。Ajax 是异步的JavaScript。有个这个技术后，前端工程师负责前端页面开发，而后端工程师只负责前端代码开发。

    技术的发展过程

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

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

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

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

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

    • 一些公司可能有些老项目还在用 JSP ，所以要求我们必须动 JSP

    • 我们如果不经历这些复杂的过程，就不能体现后面阶段开发的简单

    接下来我们来学习第三阶段，使用 EL表达式 和 JSTL 标签库替换 JSP 中的 Java 代码。

    EL 表达式

    概述

    EL（全称Expression Language ）表达式语言。

    作用：

    1.用于简化 JSP 页面内的 Java 代码。

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

    用法：

    page标签设置不忽略EI表达式

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

    ${表达式} 。

    例如：${brands} 就是获取域中存储的 key 为 brands 的数据。

    回顾：

    ${} ：学Mybatis时参数占位符：拼接SQL。底层使用的是 Statement，会存在SQL注入问题。

    代码演示，把Servlet的List转发给jsp页面输出

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

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

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

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

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

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

    域对象

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

    • page：当前页面有效

    • request：当前请求有效

    • session：当前会话有效

    • application：当前应用有效

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

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

    JSTL（JSP标准标签库）标签

    概述

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

    示例

    2.     男
    5.     女

    上面代码看起来比 JSP 中嵌套 Java 代码看起来舒服好了。

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

    最常用的标签：

    标签和 标签。

    JSTL 使用

    • 导入坐标

      2.     jstl
      3.     jstl
      4.     1.2
      7.     taglibs
      8.     standard
      9.     1.1.2

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

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

      要使用EL表达式记得isELIgnored="false"

    • 使用标签

    if 标签

    ：相当于 if 判断，条件渲染

    • 属性：test，用于定义条件表达式，表达式要在$里判断。test="${flag == 1}"可以，test="${flag }== 1"不行。

    2.     男
    5.     女

    代码演示：

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

      1. package web;
      2.  
      3. import javax.servlet.*;
      4. import javax.servlet.http.*;
      5. import javax.servlet.annotation.*;
      6. import java.io.IOException;
      7.  
      8. @WebServlet("/ServletDemo1")
      9. public class ServletDemo1 extends HttpServlet {
      10.     @Override
      11.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      12.         //1. 存储数据到request域中
      13.         request.setAttribute("status",1);
      14.  
      15.         //2. 转发到 jstl-if.jsp
      16.         request.getRequestDispatcher("/hello.jsp").forward(request,response);
      17.     }
      18.  
      19.     @Override
      20.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      21.         this.doGet(request, response);
      22.     }
      23. }

    • 定义 hello.jsp 页面，在该页面使用 标签

      1. <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
      2. <%--<%@ page contentType="text/html;charset=UTF-8" language="java" %>--%>
      3. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
      6.   Title
      9. <%--
      10.     c:if：来完成逻辑判断，替换java  if else，别忘了isELIgnored="false"
      11. --%>
      13.   启用
      15. 查看${status}
      16. <%
      17.   System.out.println(request.getAttribute("status"));;
      18. %>
      20.   禁用

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

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

    forEach 标签

    ：相当于 for 循环。java中有增强for循环和普通for循环。

    用法一

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

    • items：被遍历的容器

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

    • varStatus：遍历状态对象，用于自动生成序号，status.index是从0开始，status.count是从1开始

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

    2.     
    3.         ${brand.id}
    4.         ${brand.brandName}
    5.         ${brand.companyName}
    6.         ${brand.description}
    7.     
    1.     
    2.         
    3.             ${status.count}
    4.             ${brand.id}
    5.             ${brand.brandName}
    6.             ${brand.companyName}
    7.             ${brand.description}
    8.         
    9.

    注意： ${brand.id}是给id转getId，调用Brand对象里的getId()方法，不是直接id成员变量。

    代码演示：

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

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

      1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
      2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
      3.  
      7.     
      8.     Title

      14.     
      15.         
      16.         
      17.         
      18.         
      19.         
      20.         
      21.         
      22.     
      23.  
      24.     
      25.         
      26.             <%--
        27. --%>
      27.             
      28.             
      29.             
      30.             
      31.             
      32.             
      33.                 
      34.             
      35.             
      36.                 
      37.             
      38.             
      39.         
      40.     
        42. 序号品牌名称企业名称排序品牌介绍状态操作
        ${brand.id}${status.count}${brand.brandName}${brand.companyName}${brand.ordered}${brand.description}启用禁用修改 删除

    用法二

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

    • begin：开始数

    • end：结束数

    • step：步长

    实例代码：

    从0循环到10，变量名是 i ，每次自增1，可以配合a标签进行分页展示。

    2.     ${i}

    MVC模式和三层架构

    提高代码维护性和扩展性。

    MVC模式

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

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

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

    • C：Controller，控制器。获取并处理请求，调用模型来获取数据，发送数据给视图View展示

    视图和控制器是表现层， 模型是业务层和数据访问层（持久层，dao层）。

    流程： 

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

    MVC 好处：

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

    • 有利于分工协作。

    • 有利于组件重用

    三层架构

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

    • 数据访问层（也叫持久层，dao层）：对数据库的CRUD基本操作

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

    • 表现层：接收请求，封装数据，调用业务逻辑层，响应数据

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

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

    • 表现层： com.itheima.controller 或者 com.itheima.web

    • 业务逻辑层：com.itheima.service

    • 数据访问层：com.itheima.dao 或者 com.itheima.mapper

    后期我们还会学习一些框架，不同的框架是对不同层进行封装的

    MVC 和 三层架构

     MVC 和 三层架构有什么区别和联系？

    通过控制器连接，控制器获取并处理请求，调用模型（访问数据库，处理业务）来获取数据，发送数据给视图展示

    如上图上半部分是 MVC 模式，上图下半部分是三层架构。

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

    可以将 MVC 模式 理解成是一个大的概念，而 三层架构 是对 MVC 模式 实现架构的思想。 那么我们以后按照要求将不同层的代码写在不同的包下，每一层里功能职责做到单一，将来如果将表现层的技术换掉，而业务逻辑层和数据访问层的代码不需要发生变化。

    品牌数据增删改查案例

        排序：<input name="ordered" value="${brand.ordered}"><br>

    需求：完成品牌数据的增删改查操作

    这个功能我们之前一直在做，而这个案例是将今天学习的所有的内容（包含 MVC模式 和 三层架构）进行应用，并将整个流程贯穿起来。

    主要坑点

    1.input标签的value里不能有空格，特别是要String转Integer的。

        排序：<input name="ordered" value="${brand.ordered}"><br>

     2.添加、修改数据别忘了在服务层提交事务。

    sqlSession.commit();

    3.Servlet使用post方式别忘了设置编码

     request.setCharacterEncoding("utf-8");

    4.请求转发路径没有虚拟目录（项目名） ，目前学到的路径只有它没有虚拟目录

    request.getRequestDispatcher("/brand.jsp").forward(request,response);

    环境准备

    环境准备工作，我们分以下步骤实现：

    • 1.创建新的模块 brand_demo，引入坐标

    • 2.创建三层架构的包结构

    • 3.数据库表 tb_brand

    • 4.实体类 Brand

    • 5.MyBatis 基础环境

      • Mybatis-config.xml

      • BrandMapper.xml

      • BrandMapper接口

    1.创建新的模块 brand_demo，引入坐标

    创建新的模块 brand_demo，引入坐标。我们只要分析出要用到哪儿些技术，那么需要哪儿些坐标也就明确了

    • 需要操作数据库。mysql的驱动包

    • 要使用mybatis框架。mybaits的依赖包

    • web项目需要用到servlet和jsp。servlet和jsp的依赖包

    • 需要使用 jstl 进行数据展示。jstl的依赖包

    pom.xml 内容如下：

    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.     <groupId>org.examplegroupId>
    7.     <artifactId>brand-demoartifactId>
    8.     <version>1.0-SNAPSHOTversion>
    9.     <packaging>warpackaging>
    10.  
    11.     <properties>
    12.         <maven.compiler.source>8maven.compiler.source>
    13.         <maven.compiler.target>8maven.compiler.target>
    14.     properties>
    15.  
    16.     <dependencies>
    17.         
    18.         <dependency>
    19.             <groupId>org.mybatisgroupId>
    20.             <artifactId>mybatisartifactId>
    21.             <version>3.5.5version>
    22.         dependency>
    23.  
    24.         
    25.         <dependency>
    26.             <groupId>mysqlgroupId>
    27.             <artifactId>mysql-connector-javaartifactId>
    28.             <version>5.1.34version>
    29.         dependency>
    30.  
    31.         
    32.         <dependency>
    33.             <groupId>javax.servletgroupId>
    34.             <artifactId>javax.servlet-apiartifactId>
    35.             <version>3.1.0version>
    36.             <scope>providedscope>
    37.         dependency>
    38.  
    39.         
    40.         <dependency>
    41.             <groupId>javax.servlet.jspgroupId>
    42.             <artifactId>jsp-apiartifactId>
    43.             <version>2.2version>
    44.             <scope>providedscope>
    45.         dependency>
    46.  
    47.         
    48.         <dependency>
    49.             <groupId>jstlgroupId>
    50.             <artifactId>jstlartifactId>
    51.             <version>1.2version>
    52.         dependency>
    53.         <dependency>
    54.             <groupId>taglibsgroupId>
    55.             <artifactId>standardartifactId>
    56.             <version>1.1.2version>
    57.         dependency>
    58.     dependencies>
    59.  
    60.     <build>
    61.         <plugins>
    62.             <plugin>
    63.                 <groupId>org.apache.tomcat.mavengroupId>
    64.                 <artifactId>tomcat7-maven-pluginartifactId>
    65.                 <version>2.2version>
    66.             plugin>
    67.         plugins>
    68.     build>
    69. project>

    2.创建三层架构的包结构

    创建不同的包结构，用来存储不同的类。包结构如下

     mapper下BrandMapper.java接口，pojo下Brand.java实体类，service下BrandService.java业务类，util下SqlSessionFactoryUtils.java工具类，web下SelectAllServlet.java、AddServlet.java等Servlet类

    3.数据库表 tb_brand

    1. -- 删除tb_brand表
    2. drop table if exists tb_brand;
    3. -- 创建tb_brand表
    4. create table tb_brand
    5. (
    6.     -- id 主键
    7.     id           int primary key auto_increment,
    8.     -- 品牌名称
    9.     brand_name   varchar(20),
    10.     -- 企业名称
    11.     company_name varchar(20),
    12.     -- 排序字段
    13.     ordered      int,
    14.     -- 描述信息
    15.     description  varchar(100),
    16.     -- 状态：0：禁用  1：启用
    17.     status       int
    18. );
    19. -- 添加数据
    20. insert into tb_brand (brand_name, company_name, ordered, description, status)
    21. values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
    22.        ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
    23.        ('小米', '小米科技有限公司', 50, 'are you ok', 1);

    4.创建实体类

    在 pojo 包下创建名为 Brand 的类。

    1. public class Brand {
    2.     // id 主键
    3.     private Integer id;
    4.     // 品牌名称
    5.     private String brandName;
    6.     // 企业名称
    7.     private String companyName;
    8.     // 排序字段
    9.     private Integer ordered;
    10.     // 描述信息
    11.     private String description;
    12.     // 状态：0：禁用  1：启用
    13.     private Integer status;
    14.  
    15.  
    16.     public Brand() {
    17.     }
    18.  
    19.     public Brand(Integer id, String brandName, String companyName, String description) {
    20.         this.id = id;
    21.         this.brandName = brandName;
    22.         this.companyName = companyName;
    23.         this.description = description;
    24.     }
    25.  
    26.     public Brand(Integer id, String brandName, String companyName, Integer ordered, String description, Integer status) {
    27.         this.id = id;
    28.         this.brandName = brandName;
    29.         this.companyName = companyName;
    30.         this.ordered = ordered;
    31.         this.description = description;
    32.         this.status = status;
    33.     }
    34.  
    35.     public Integer getId() {
    36.         return id;
    37.     }
    38.  
    39.     public void setId(Integer id) {
    40.         this.id = id;
    41.     }
    42.  
    43.     public String getBrandName() {
    44.         return brandName;
    45.     }
    46.  
    47.     public void setBrandName(String brandName) {
    48.         this.brandName = brandName;
    49.     }
    50.  
    51.     public String getCompanyName() {
    52.         return companyName;
    53.     }
    54.  
    55.     public void setCompanyName(String companyName) {
    56.         this.companyName = companyName;
    57.     }
    58.  
    59.     public Integer getOrdered() {
    60.         return ordered;
    61.     }
    62.  
    63.     public void setOrdered(Integer ordered) {
    64.         this.ordered = ordered;
    65.     }
    66.  
    67.     public String getDescription() {
    68.         return description;
    69.     }
    70.  
    71.     public void setDescription(String description) {
    72.         this.description = description;
    73.     }
    74.  
    75.     public Integer getStatus() {
    76.         return status;
    77.     }
    78.  
    79.     public void setStatus(Integer status) {
    80.         this.status = status;
    81.     }
    82.  
    83.     @Override
    84.     public String toString() {
    85.         return "Brand{" +
    86.                 "id=" + id +
    87.                 ", brandName='" + brandName + '\'' +
    88.                 ", companyName='" + companyName + '\'' +
    89.                 ", ordered=" + ordered +
    90.                 ", description='" + description + '\'' +
    91.                 ", status=" + status +
    92.                 '}';
    93.     }
    94. }

    5.准备mybatis环境

    定义核心配置文件 Mybatis-config.xml ，并将该文件放置在 resources 下

    2. configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.     
    7.     <typeAliases>
    8.         <package name="package1.pojo"/>
    9.     typeAliases>
    10.  
    11.     <environments default="development">
    12.         <environment id="development">
    13.             <transactionManager type="JDBC"/>
    14.             <dataSource type="POOLED">
    15.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
    16.                 <property name="url" value="jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true"/>
    17.                 <property name="username" value="root"/>
    18.                 <property name="password" value="1234"/>
    19.             dataSource>
    20.         environment>
    21.     environments>
    22.     <mappers>
    23.         
    24.         <package name="package1.mapper"/>
    25.     mappers>
    26. configuration>

    在 resources 下创建放置映射配置文件的目录结构 com/itheima/mapper，并在该目录下创建映射配置文件 BrandMapper.xml

    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.itheima.mapper.BrandMapper">
    6.     
    7. mapper>

    查询所有

    当我们点击 index.html 页面中的 查询所有 这个超链接时，就能查询到上图右半部分的数据。

    对于上述的功能，点击 查询所有 超链接是需要先请后端的 servlet ，由 servlet 跳转到对应的页面进行数据的动态展示。而整个流程如下图：

    之前代码是直接用web层直接调用数据访问层方法，加上业务层是为了提高代码复用性。如果用Servlet实现包含多个Dao层方法的业务，其他Servlet想使用这个业务就得重新写，不如直接调用业务层方法方便。

    编写BrandMapper

    在 mapper 包下创建创建 BrandMapper 接口，在接口中定义 selectAll() 方法

    1. /**
    2.   * 查询所有
    3.   * @return
    4.   */
    5. //sql语句简单，直接注解开发，替代配置文件开发
    6. @Select("select * from tb_brand")
    7. List selectAll();

    编写工具类

    在 com.itheima 包下创建 utils 包，并在该包下创建名为 SqlSessionFactoryUtils 工具类

    1. package package1.util;
    2.  
    3. import org.apache.ibatis.io.Resources;
    4. import org.apache.ibatis.session.SqlSessionFactory;
    5. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    6.  
    7. import java.io.IOException;
    8. import java.io.InputStream;
    9.  
    10. public class SqlSessionFactoryUtils {
    11.  
    12.     private static SqlSessionFactory sqlSessionFactory;
    13.  
    14.     static {
    15.         //静态代码块会随着类的加载而自动执行，且只执行一次
    16.         //静态代码块不能抛异常，要用try-catch
    17.         try {
    18.             String resource = "mybatis-config.xml";
    19.             InputStream inputStream = Resources.getResourceAsStream(resource);
    20.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    21.         } catch (IOException e) {
    22.             e.printStackTrace();
    23.         }
    24.     }
    25.  
    26.  
    27.     public static SqlSessionFactory getSqlSessionFactory(){
    28.         return sqlSessionFactory;
    29.     }
    30. }

    编写BrandService

    在 service 包下创建 BrandService 类

    1. public class BrandService {
    2.     SqlSessionFactory factory = SqlSessionFactoryUtils.getSqlSessionFactory();
    3.  
    4.     /**
    5.      * 查询所有
    6.      * @return
    7.      */
    8.     public List selectAll(){
    9.         //调用BrandMapper.selectAll()
    10.  
    11.         //2. 获取SqlSession
    12.         SqlSession sqlSession = factory.openSession();
    13.         //3. 获取BrandMapper
    14.         BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
    15.  
    16.         //4. 调用方法
    17.         List brands = mapper.selectAll();
    18.         //一定别忘了关闭会话
    19.         sqlSession.close();
    20.  
    21.         return brands;
    22.     }
    23. }

    编写Servlet

    在 web 包下创建名为 SelectAllServlet 的 servlet，该 servlet 的逻辑如下：

    • 调用 BrandService 的 selectAll() 方法进行业务逻辑处理，并接收返回的结果

    • 将上一步返回的结果存储到 request 域对象中

    • 跳转到 brand.jsp 页面进行数据的展示

    具体的代码如下：

    1. @WebServlet("/selectAllServlet")
    2. public class SelectAllServlet extends HttpServlet {
    3.     //在这里创建服务对象
    4.     private  BrandService service = new BrandService();
    5.  
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.  
    9.         //1. 调用BrandService完成查询
    10.         List brands = service.selectAll();
    11.         //2. 存入request域中
    12.         request.setAttribute("brands",brands);
    13.         //3. 转发到brand.jsp
    14.         request.getRequestDispatcher("/brand.jsp").forward(request,response);
    15.     }
    16.  
    17.     @Override
    18.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    19.         this.doGet(request, response);
    20.     }
    21. }

    编写brand.jsp页面

    将资料 资料\2. 品牌增删改查案例\静态页面 下的 brand.html 页面拷贝到项目的 webapp 目录下，并将该页面改成 brand.jsp 页面，而 brand.jsp 页面在表格中使用 JSTL 和 EL表达式 从request域对象中获取名为 brands 的集合数据并展示出来。页面内容如下：

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
    2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    3.  
    7.     
    8.     Title
    13.     
    14.         
    15.         
    16.         
    17.         
    18.         
    19.         
    20.         
    21.     
    22.  
    23.     
    24.         
    25.                 <%--
      26. --%>
    26.             
    27.             
    28.             
    29.             
    30.             
    31.             
    32.                 
    33.             
    34.             
    35.                 
    36.             
    37.             
    38.         
    39.     
      41. 序号品牌名称企业名称排序品牌介绍状态操作
      ${brand.id}${status.count}${brand.brandName}${brand.companyName}${brand.ordered}${brand.description}启用禁用修改 删除

    测试

    启动服务器，并在浏览器输入 http://localhost:8080/brand-demo/index.html，看到如下 查询所有 的超链接，点击该链接就可以查询出所有的品牌数据

    为什么出现这个问题呢？是因为查询到的字段名和实体类对象的属性名没有一一对应。相比看到这大家一定会解决了，就是在映射配置文件中使用 resultMap 标签定义映射关系。映射配置文件内容如下：

    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.itheima.mapper.BrandMapper">
    6.  
    7.     <resultMap id="brandResultMap" type="brand">
    8.         <result column="brand_name" property="brandName">result>
    9.         <result column="company_name" property="companyName">result>
    10.     resultMap>
    11. mapper>

    并且在 BrandMapper 接口中的 selectAll() 上使用 @ResuleMap 注解指定使用该映射

    1. /**
    2.   * 查询所有
    3.   * @return
    4.   */
    5. @Select("select * from tb_brand")
    6. @ResultMap("brandResultMap")
    7. List selectAll();

    重启服务器，再次访问就能看到我们想要的数据了

    添加

    上图是做 添加 功能流程。点击 新增 按钮后，会先跳转到 addBrand.jsp 新增页面，在该页面输入要添加的数据，输入完毕后点击 提交 按钮，需要将数据提交到后端，而后端进行数据添加操作，并重新将所有的数据查询出来。整个流程如下：

    接下来我们根据流程来实现功能：

    编写BrandMapper方法

    在 BrandMapper 接口，在接口中定义 add(Brand brand) 方法

    1. @Insert("insert into tb_brand values(null,#{brandName},#{companyName},#{ordered},#{description},#{status})")
    2. void add(Brand brand);

    编写BrandService方法

    在 BrandService 类中定义添加品牌数据方法 add(Brand brand)

    1.  	/**
    2.      * 添加
    3.      * @param brand
    4.      */
    5.     public void add(Brand brand){
    6.  
    7.         //2. 获取SqlSession
    8.         SqlSession sqlSession = factory.openSession();
    9.         //3. 获取BrandMapper
    10.         BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
    11.  
    12.         //4. 调用方法
    13.         mapper.add(brand);
    14.  
    15.         //提交事务，一定别忘了
    16.         sqlSession.commit();
    17.         //释放资源
    18.         sqlSession.close();
    19.     }

    改进brand.jsp页面

    我们需要在该页面表格的上面添加 新增 按钮

    <input type="button" value="新增" id="add"><br>

    并给该按钮绑定单击事件，当点击了该按钮需要跳转到 brand.jsp 添加品牌数据的页面

    1. <script>
    2.     document.getElementById("add").onclick = function (){
    3.         location.href = "/brand-demo/addBrand.jsp";
    4.     }
    5. script>

    注意：该 script 标签建议放在 body 结束标签前面。

    编写addBrand.jsp页面

     addBrand.jsp 动态页面

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
    2. html>
    3. <html lang="en">
    4.  
    5. <head>
    6.     <meta charset="UTF-8">
    7.     <title>添加品牌title>
    8. head>
    9. <body>
    10. <h3>添加品牌h3>
    11. <form action="/brand-demo/addServlet" method="post">
    12.     品牌名称：<input name="brandName"><br>
    13.     企业名称：<input name="companyName"><br>
    14.     排序：<input name="ordered"><br>
    15.     描述信息：<textarea rows="5" cols="20" name="description">textarea><br>
    16.     状态：
    17.     <input type="radio" name="status" value="0">禁用
    18.     <input type="radio" name="status" value="1">启用<br>
    19.  
    20.     <input type="submit" value="提交">
    21. form>
    22. body>
    23. html>

    编写servlet

    在 web 包下创建 AddServlet 的 servlet，该 servlet 的逻辑如下:

    • 设置处理post请求乱码的字符集

    • 接收客户端提交的数据

    • 将接收到的数据封装到 Brand 对象中

    • 调用 BrandService 的add() 方法进行添加的业务逻辑处理

    • 跳转到 selectAllServlet 资源重新查询数据

    具体的代码如下：

    1. @WebServlet("/addServlet")
    2. public class AddServlet extends HttpServlet {
    3.     private BrandService service = new BrandService();
    4.  
    5.  
    6.     @Override
    7.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    8.  
    9.         //处理POST请求的乱码问题，Tomcat8及以后版本默认utf-8
    10.         request.setCharacterEncoding("utf-8");
    11.  
    12.         //1. 接收表单提交的数据，封装为一个Brand对象
    13.         String brandName = request.getParameter("brandName");
    14.         String companyName = request.getParameter("companyName");
    15.         String ordered = request.getParameter("ordered");
    16.         String description = request.getParameter("description");
    17.         String status = request.getParameter("status");
    18.  
    19.         //封装为一个Brand对象
    20.         Brand brand = new Brand();
    21.         brand.setBrandName(brandName);
    22.         brand.setCompanyName(companyName);
    23.         brand.setOrdered(Integer.parseInt(ordered));
    24.         brand.setDescription(description);
    25.         brand.setStatus(Integer.parseInt(status));
    26.  
    27.         //2. 调用service 完成添加
    28.         service.add(brand);
    29.  
    30.         //3. 转发到查询所有Servlet
    31.         request.getRequestDispatcher("/selectAllServlet").forward(request,response);
    32.     }
    33.  
    34.     @Override
    35.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    36.         this.doGet(request, response);
    37.     }
    38. }

    测试

    点击 brand.jsp 页面的 新增 按钮，会跳转到 addBrand.jsp页面

    点击 提交 按钮，就能看到如下页面，里面就包含我们刚添加的数据

    修改（回显数据）

    点击每条数据后面的 编辑 按钮会跳转到修改页面，如下图：

    在该修改页面我们可以看到将 编辑 按钮所在行的数据 回显 到表单，然后需要修改那个数据在表单中进行修改，然后点击 提交 的按钮将数据提交到后端，后端再将数据存储到数据库中。

    从上面的例子我们知道 修改 功能需要从两方面进行实现，数据回显和修改操作。

    回显数据

    上图就是回显数据的效果。要实现这个效果，那当点击 修改 按钮时不能直接跳转到 update.jsp 页面，而是需要先带着当前行数据的 id 请求后端程序，后端程序根据 id 查询数据，将数据存储到域对象中跳转到 update.jsp 页面进行数据展示。整体流程如下

    编写BrandMapper方法

    在 BrandMapper 接口，在接口中定义 selectById(int id) 方法

    1. 	/**
    2.      * 根据id查询
    3.      * @param id
    4.      * @return
    5.      */
    6.     @Select("select * from tb_brand where id = #{id}")
    7.     @ResultMap("brandResultMap")
    8.     Brand selectById(int id);

    编写BrandService方法

    在 BrandService 类中定义根据id查询数据方法 selectById(int id)

    1.     /**
    2.      * 根据id查询
    3.      * @return
    4.      */
    5.     public Brand selectById(int id){
    6.         //调用BrandMapper.selectAll()
    7.         //2. 获取SqlSession
    8.         SqlSession sqlSession = factory.openSession();
    9.         //3. 获取BrandMapper
    10.         BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
    11.         //4. 调用方法
    12.         Brand brand = mapper.selectById(id);
    13.         sqlSession.close();
    14.         return brand;
    15.     }

    编写servlet

    在 web 包下创建 SelectByIdServlet 的 servlet，该 servlet 的逻辑如下:

    • 获取请求数据 id

    • 调用 BrandService 的 selectById() 方法进行数据查询的业务逻辑

    • 将查询到的数据存储到 request 域对象中

    • 跳转到 update.jsp 页面进行数据真实

    具体代码如下：

    1. @WebServlet("/selectByIdServlet")
    2. public class SelectByIdServlet extends HttpServlet {
    3.     private  BrandService service = new BrandService();
    4.  
    5.     @Override
    6.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    7.         //1. 接收id
    8.         String id = request.getParameter("id");
    9.         //2. 调用service查询
    10.         Brand brand = service.selectById(Integer.parseInt(id));
    11.         //3. 存储到request中
    12.         request.setAttribute("brand",brand);
    13.         //4. 转发到update.jsp
    14.         request.getRequestDispatcher("/update.jsp").forward(request,response);
    15.     }
    16.  
    17.     @Override
    18.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    19.         this.doGet(request, response);
    20.     }
    21. }

    编写update.jsp页面

    拷贝 addBrand.jsp 页面，改名为 update.jsp 并做出以下修改：

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
    2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    3. html>
    4. <html lang="en">
    5. <head>
    6.     <meta charset="UTF-8">
    7.     <title>修改品牌title>
    8. head>
    9. <body>
    10. <h3>修改品牌h3>
    11. <form action="/brand-demo/updateServlet" method="post">
    12.  
    13.     品牌名称：<input name="brandName" value="${brand.brandName}"><br>
    14.     企业名称：<input name="companyName" value="${brand.companyName}"><br>
    15.     排序：<input name="ordered" value="${brand.ordered}"><br>
    16.     描述信息：<textarea rows="5" cols="20" name="description">${brand.description} textarea><br>
    17.     状态：
    18.     <c:if test="${brand.status == 0}">
    19.         <input type="radio" name="status" value="0" checked>禁用
    20.         <input type="radio" name="status" value="1">启用<br>
    21.     c:if>
    22.  
    23.     <c:if test="${brand.status == 1}">
    24.         <input type="radio" name="status" value="0" >禁用
    25.         <input type="radio" name="status" value="1" checked>启用<br>
    26.     c:if>
    27.  
    28.     <input type="submit" value="提交">
    29. form>
    30. body>
    31. html>

    修改数据

    做完回显数据后，接下来我们要做修改数据了，而下图是修改数据的效果：

    在修改页面进行数据修改，点击 提交 按钮，会将数据提交到后端程序，后端程序会对表中的数据进行修改操作，然后重新进行数据的查询操作。整体流程如下：

    编写BrandMapper方法

    在 BrandMapper 接口，在接口中定义 update(Brand brand) 方法

    1. /**
    2.   * 修改
    3.   * @param brand
    4.   */
    5. @Update("update tb_brand set brand_name = #{brandName},company_name = #{companyName},ordered = #{ordered},description = #{description},status = #{status} where id = #{id}")
    6. void update(Brand brand);

    编写BrandService方法

    在 BrandService 类中定义根据id查询数据方法 update(Brand brand)

    1. 	/**
    2.      * 修改
    3.      * @param brand
    4.      */
    5.     public void update(Brand brand){
    6.         //2. 获取SqlSession
    7.         SqlSession sqlSession = factory.openSession();
    8.         //3. 获取BrandMapper
    9.         BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
    10.         //4. 调用方法
    11.         mapper.update(brand);
    12.         //提交事务
    13.         sqlSession.commit();
    14.         //释放资源
    15.         sqlSession.close();
    16.     }

    编写servlet

    在 web 包下创建 AddServlet 的 servlet，该 servlet 的逻辑如下:

    • 设置处理post请求乱码的字符集

    • 接收客户端提交的数据

    • 将接收到的数据封装到 Brand 对象中

    • 调用 BrandService 的update() 方法进行添加的业务逻辑处理

    • 跳转到 selectAllServlet 资源重新查询数据

    具体的代码如下：

    1. @WebServlet("/updateServlet")
    2. public class UpdateServlet extends HttpServlet {
    3.     private BrandService service = new BrandService();
    4.  
    5.     @Override
    6.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    7.  
    8.         //处理POST请求的乱码问题
    9.         request.setCharacterEncoding("utf-8");
    10.         //1. 接收表单提交的数据，封装为一个Brand对象
    11.         String id = request.getParameter("id");
    12.         String brandName = request.getParameter("brandName");
    13.         String companyName = request.getParameter("companyName");
    14.         String ordered = request.getParameter("ordered");
    15.         String description = request.getParameter("description");
    16.         String status = request.getParameter("status");
    17.  
    18.         //封装为一个Brand对象
    19.         Brand brand = new Brand();
    20.         brand.setId(Integer.parseInt(id));
    21.         brand.setBrandName(brandName);
    22.         brand.setCompanyName(companyName);
    23.         brand.setOrdered(Integer.parseInt(ordered));
    24.         brand.setDescription(description);
    25.         brand.setStatus(Integer.parseInt(status));
    26.  
    27.         //2. 调用service 完成修改
    28.         service.update(brand);
    29.  
    30.         //3. 转发到查询所有Servlet
    31.         request.getRequestDispatcher("/selectAllServlet").forward(request,response);
    32.     }
    33.  
    34.     @Override
    35.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    36.         this.doGet(request, response);
    37.     }
    38. }

    存在问题：update.jsp 页面提交数据时是没有携带主键数据的，而后台修改数据需要根据主键进行修改。

    针对这个问题，我们不希望页面将主键id展示给用户看，但是又希望在提交数据时能将主键id提交到后端。此时我们就想到了在学习 HTML 时学习的隐藏域，在 update.jsp 页面的表单中添加如下代码：

    1. <%--隐藏域，提交id--%>
    2. <input type="hidden" name="id" value="${brand.id}">

    update.jsp 页面的最终代码如下：

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    3. html>
    4. <html lang="en">
    5. <head>
    6.     <meta charset="UTF-8">
    7.     <title>修改品牌title>
    8. head>
    9. <body>
    10. <h3>修改品牌h3>
    11. <form action="/brand-demo/updateServlet" method="post">
    12.  
    13.     <%--隐藏域，提交id--%>
    14.     <input type="hidden" name="id" value="${brand.id}">
    15.  
    16.     品牌名称：<input name="brandName" value="${brand.brandName}"><br>
    17.     企业名称：<input name="companyName" value="${brand.companyName}"><br>
    18.     排序：<input name="ordered" value="${brand.ordered}"><br>
    19.     描述信息：<textarea rows="5" cols="20" name="description">${brand.description} textarea><br>
    20.     状态：
    21.     <c:if test="${brand.status == 0}">
    22.         <input type="radio" name="status" value="0" checked>禁用
    23.         <input type="radio" name="status" value="1">启用<br>
    24.     c:if>
    25.  
    26.     <c:if test="${brand.status == 1}">
    27.         <input type="radio" name="status" value="0" >禁用
    28.         <input type="radio" name="status" value="1" checked>启用<br>
    29.     c:if>
    30.     <input type="submit" value="提交">
    31. form>
    32. body>
    33. html>

  • 相关阅读:
    独立站+TikTok是下个风口吗
    【GIT】如何列出2个branch/tag/commitId 之间的所有commit
    什么是RabbitMQ？RabbitMQ的作用是什么？
    2023 年 数维杯（A题）国际大学生数学建模挑战赛 |数学建模完整代码+建模过程全解全析
    Flutter：setState() 能在 build() 中直接调用吗？
    vs code Conda退出虚拟环境报错 ERROR REPORT
    驱动 点灯
    linux添加一条到中间路由器的路由
    qemu-system-arm搭建arm仿真环境
    matplotlib库学习之绘图透明度设置（精炼准确）
  • 原文地址：https://blog.csdn.net/qq_40991313/article/details/126024588