SpringMVC 教程

SpringMVC

本项目参考【狂神说Java】SpringMVC 最新教程 IDEA 版通俗易懂
Github 地址：https://github.com/Lockegogo/Java-Study

回顾 MVC

什么是 MVC

MVC 是：

模型 (Model)、视图 (View)、控制器 (Controller) 的简写，是一种软件设计规范；
是将业务逻辑、数据、显示分离的方法来组织代码；
MVC 的主要作用是降低了视图与业务逻辑间的双向耦合；
MVC 不是一种设计模式，MVC 是一种架构模式。

Model：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或 JavaBean 组件（包含数据和行为），不过现在一般都分离开：Value Object（数据 Dao）和服务层（行为 Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

View：负责模型的展示，一般就是我们见到的用户页面，客户想看到的东西

Controller：接受用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示，也就是控制器做了个调度员的工作。

最典型的 MVC 就是 JSP + servlet + javabean 的模式。

回顾 Servlet

新建一个 Maven 工程当做父工程！ pom 依赖！

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

建立一个 Moudle：springmvc-01-servlet ，添加 Web app 的支持，导入 servlet 和 jsp 的 jar 依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
</dependency>

编写一个 servlet 类，用来处理用户的请求

// 实现 Servlet 接口
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 获取前端参数
        String method = req.getParameter("method");
        if (method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }
        if (method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        // 2. 调用业务层
        // 3. 视图转发或者重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

编写 test.jsp，在 WEB-INF 目录下新建一个 jsp 的文件夹，新建 test.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>My Java</title>
    </head>
    <body>

        ${msg}

    </body>
</html>

在 web.xml 中注册 Servlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.locke.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

    <!--配置超时时间-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>

    <!--配置欢迎页面-->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>


</web-app>

配置 Tomcat，并启动测试
1. localhost:8080/hello?method=add
2. localhost:8080/hello?method=delete

MVC 框架要做哪些事情？

将 url 映射到 java 类或者 java 类的方法
封装用户提交的数据
处理请求 —— 调用相关的业务处理 —— 封装相应数据
将响应的数据进行渲染 .jsp/html 等表示层数据

什么是 SpringMVC

Spring MVC 是 Spring Framework 的一部分，是基于 Java 实现 MVC 的轻量级 Web 框架。

中心控制器

Spring MVC 框架以请求为驱动，围绕一个中心 Servlet 分派请求及提供其他功能，DispatcherServlet 是一个实际的 Servlet (它继承自 HttpServlet 基类)。

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

执行原理

HelloSpring

原理版

新建一个 Moudle， springmvc-02-hello ，添加 web 的支持！

<!--导入依赖-->
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

配置 web.xml，注册 DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--1.注册 DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个 springmvc 的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

编写 SpringMVC 的配置文件！名称：springmvc-servlet.xml : [servletname]-servlet.xml，在 resources 包内

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--添加处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--添加处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--视图解析器: DispatcherServlet 给他的 ModelAndView
    1. 获取 ModelAndView 的数据
    2. 解析 ModelAndView 的视图名字
    3. 拼接视图名字，找到对应的视图 /WEB-INF/jsp/hello.jsp
    4. 将数据渲染到这个视图上
    -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--Handler-->
    <bean id="/hello" class="com.locke.controller.HelloController"/>

</beans>

编写我们要操作的业务 Controller，要么实现 Controller 接口，要么增加注解；需要返回一个 ModelAndView，装数据，封视图：

// 注意：这里我们先导入 Controller 接口
public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();
        // 封装对象，放在 ModelAndView 中 Model
        mv.addObject("msg","HelloSpringMVC!");
        // 封装要跳转的视图，放在 ModelAndView 中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }

}

将自己的类交给 SpringIOC 容器，注册 bean

<!--Handler-->
<bean id="/hello" class="com.locke.controller.HelloController"/>

写要跳转的 hello.jsp 页面，显示 ModelandView 存放的数据，以及我们的正常页面；

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	${msg}
</body>
</html>

配置 Tomcat 启动测试：

注意，可能遇到的问题如下：

查看控制台输出，看一下是不是缺少了什么 jar 包

如果 jar 包存在，显示无法输出，就在 IDEA 的项目发布里，添加 lib 依赖

重启 Tomcat 即可解决

注解版

由于 Maven 可能存在资源过滤的问题，我们将配置完善

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

在 pom.xml 文件中引入相关的依赖：主要有 Spring 框架核心库、SpringMVC、servlet，JSTL 等，我们已经在父依赖中引入了
配置 web.xml
1. 注意 web.xml 版本问题，要最新版！
2. 注册 DispatcherServlet
3. 关联 SpringMVC 的配置文件
4. 启动级别为 1
5. 映射路径为 / 【不要用 /*，会 404】

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--1.注册 DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个 springmvc 的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

添加 Spring MVC 配置文件：在 resource 目录下添加 springmvc-servlet.xml 配置文件，配置的形式与 Spring 容器配置基本类似，为了支持基于注解的 IOC，设置了自动扫描包的功能，具体配置信息如下：
1. 让 IOC 注解生效
2. 静态资源过滤：HTML 等
3. MVC 的注解驱动
4. 配置视图解析器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 自动扫描包, 让指定包下的注解生效, 由 IOC 容器统一管理 -->
    <context:component-scan base-package="com.locke.controller"/>
    <!-- 让 Spring MVC 不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
    支持 mvc 注解驱动
        在 spring 中一般采用 @RequestMapping 注解来完成映射关系
        要想使 @RequestMapping 注解生效
        必须向上下文中注册 DefaultAnnotationHandlerMapping
        和一个 AnnotationMethodHandlerAdapter 实例
        这两个实例分别在类级别和方法级别处理。
        而 annotation-driven 配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

在视图解析器中我们把所有的视图都存放在 /WEB-INF/ 目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

创建 Controller：编写一个 Java 控制类 com.locke.controller.HelloController, 注意编码规范
1. @Controller 是为了让 Spring IOC 容器初始化时自动扫描到；
2. @RequestMapping 是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是 /HelloController/hello；
3. 方法中声明 Model 类型的参数是为了把 Action 中的数据带到视图中；
4. 方法返回的结果是视图的名称 hello，加上配置文件中的前后缀变成 WEB-INF/jsp/hello.jsp。

@Controller
// 父路径
@RequestMapping("/HelloController")
public class HelloController {
    // 真实访问地址: 项目名/HelloController/hello
    // 子路径
    @RequestMapping("/hello")
    public String sayHello(Model model){
        // 向模型中添加属性 msg 与值，可以在 JSP 页面中取出并渲染
        model.addAttribute("msg","hello,SpringMVC");
        // web-inf/jsp/hello.jsp
        return "hello";
    }
}

创建视图层：在 WEB-INF/jsp 目录中创建 hello.jsp ，视图可以直接取出并展示从 Controller 带回的信息；

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>SpringMVC</title>
</head>
<body>
    ${msg}
</body>
</html>

配置 Tomcat 运行：HelloController/hello

实现步骤：

新建一个 web 文件
导入相关 jar 包
编写 web.xml，注册 DispatcherServlet
编写 springmvc 配置文件
接下来就是去创建对应的控制类 Controller
最后完善前端视图和 Controller 之间的对应
测试运行调试

小结：

使用 SpringMVC 必须配置的三大件：处理器映射器、处理器适配器、视图解析器

通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，从而省去了大段的 xml 配置

RestFul 风格

Restful 就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

功能：

资源：互联网所有的事物都可以被抽象为资源
资源操作：使用 POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
分别对应添加、删除、修改、查询。

传统方式操作资源：通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询，GET
http://127.0.0.1/item/saveItem.action 新增，POST
http://127.0.0.1/item/updateItem.action 更新，POST
http://127.0.0.1/item/deleteItem.action?id=1 删除，GET 或 POST

使用 RESTful 操作资源：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询，GET
http://127.0.0.1/item 新增，POST
http://127.0.0.1/item 更新，PUT
http://127.0.0.1/item/1 删除，DELETE

实现：

在 Spring MVC 中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个 URI 模板变量上。

@Controller
public class RestFulController {
    // 映射访问路径
    @RequestMapping("/commit/{p1}/{p2}")
    public String index(@PathVariable int p1, @PathVariable int p2, Model model){
        int result = p1+p2;
        // Spring MVC 会自动实例化一个 Model 对象用于向视图中传值
        model.addAttribute("msg", "结果："+result);
        // 返回视图位置
        return "test";
    }
}

思考：使用路径变量的好处？

使路径变得更加简洁、高效（支持缓存）、安全
获得参数更加方便，框架会自动进行类型转换
通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问的路径是 /commit/1/a，则路径与方法不匹配，而不会是参数转换失败

使用 method 属性请求指定类型：

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如 GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE 等

// 映射访问路径,必须是 POST 请求
@RequestMapping(value = "/hello", method = {RequestMethod.POST})
public String index2(Model model){
    model.addAttribute("msg", "hello!");
    return "test";
}

使用浏览器地址栏进行访问默认是 Get 请求，会报错 405。需要将 POST 修改为 GET：

// 映射访问路径,必须是 Get 请求
@RequestMapping(value = "/hello",method = {RequestMethod.GET})
public String index2(Model model){
    model.addAttribute("msg", "hello!");
    return "test";
}

结果跳转方式

通过 SpringMVC 来实现转发和重定向：无需视图解析器

重定向和转发的区别

测试前，需要将视图解析器注释掉

@Controller
public class ResultSpringMVC {
    @RequestMapping("/rsm/t1")
    public String test1(){
        // 转发
        return "/index.jsp";
    }
    @RequestMapping("/rsm/t2")
    public String test2(){
        // 转发二
        return "forward:/index.jsp";
    }
    @RequestMapping("/rsm/t3")
    public String test3(){
        // 重定向
        return "redirect:/index.jsp";
    }
}

通过 SpringMVC 来实现转发和重定向：有视图解析器

@Controller
public class ResultSpringMVC2 {
    @RequestMapping("/rsm2/t1")
    public String test1(){
        // 转发
        return "test";
    }
    @RequestMapping("/rsm2/t2")
    public String test2(){
        // 重定向
        return "redirect:/index.jsp";
    }
}

数据处理

处理提交数据

提交的域名称和处理方法的参数名一致
1. 提交数据：http://localhost:8080/hello?name=locke
2. 后台输出：locke

@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
    return "hello";
}

提交的域名称和处理方法的参数名不一致
1. 提交数据：http://localhost:8080/hello?username=locke
2. 后台输出：locke

@RequestMapping("/hello")
// @RequestParam("username"): username 提交的域的名称
public String hello(@RequestParam("username") String name){
    System.out.println(name);
    return "hello";
}

提交的是一个对象
1. 要求提交的表单域和对象的属性名一致，参数使用对象即可
2. 提交数据：http://localhost:8080/mvc04/user?name=locke&id=1&age=15
3. 后台输出：User

public class User {
    private int id;
    private String name;
    private int age;
    //构造
    //get/set
    //tostring()
}

@RequestMapping("/user")
public String user(User user){
    System.out.println(user);
    return "hello";
}

如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是 null

数据显示到前端

通过 ModelAndView

public class ControllerTest1 implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        // 返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

通过 ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
    // 封装要显示到视图中的数据
    // 相当于 req.setAttribute("name",name);
    model.addAttribute("name",name);
    System.out.println(name);
    return "hello";
}

通过 Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
    // 封装要显示到视图中的数据
    // 相当于 req.setAttribute("name",name);
    model.addAttribute("msg",name);
    System.out.println(name);
    return "test";
}

区别：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于 Model 对象的操作和理解；
ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

乱码问题

首先在首页编写一个提交的表单：

<form action="/e/t" method="post">
  <input type="text" name="name">
  <input type="submit">
</form>

然后后台编写对应的处理类：

@Controller
public class Encoding {
    @RequestMapping("/e/t")
    public String test(Model model,String name){
        model.addAttribute("msg",name); // 获取表单提交的值
        return "test"; // 跳转到 test 页面显示输入的值
    }
}

输入中文测试，发现乱码！

以前乱码问题通过过滤器解决，而 SpringMVC 给我们提供了一个过滤器，可以在 web.xml 中配置。

注意：修改了 xml 文件需要重启服务器！

<filter>
    <filter-name>encoding</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

但是在一些极端情况下，这个过滤器对 get 的支持不好。

处理方法：

修改 tomcat 配置文件 conf/server.xml：设置编码

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

自定义过滤器：com.locke.filter

/**
 * 解决 get 和 post 请求全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {
    @Override
    public void destroy() {
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 处理 response 的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");
        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对 request 包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
}
//自定义 request 对象，HttpServletRequest 的包装类
class MyRequest extends HttpServletRequestWrapper {
    private HttpServletRequest request;
    // 是否编码的标记
    private boolean hasEncode;
    // 定义一个可以传入 HttpServletRequest 对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request); // super 必须写
        this.request = request;
    }
    // 对需要增强方法进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post 请求
            try {
                // 处理 post 乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get 请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保 get 手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理 get 乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }
    // 取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }
    // 取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

然后在 web.xml 中配置这个过滤器

<!--配置 SpringMVC 的乱码过滤-->
<filter>
    <filter-name>encoding</filter-name>
    <filter-class>com.locke.filter.GenericEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

乱码问题，需要平时多注意，在尽可能设置编码的地方，都设置为统一编码 UTF-8

Json

前后端分类时代：

后端部署后端，提供接口，提供数据
json 连接前端和后端
前端独立部署，负责渲染后端的数据

代码测试

新建一个 module ，springmvc-04-json ，添加 web 的支持
在 web 目录下新建一个 jsontest.html ，编写测试内容

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JSON_LK</title>
</head>
<body>
<script type="text/javascript">
    // 编写一个 js 的对象
    var user = {
        name: "LK",
        age: 26,
        sex: "Female"
    };
    // console.log(user);

    // 将 js 对象转换成 json 字符串
    var str = JSON.stringify(user);
    console.log(str);
    // 将 json 字符串转换为 js 对象
    var user2 = JSON.parse(str);
    console.log(user2.age, user2.name, user2.sex);
</script>
</body>
</html>

在 IDEA 中使用浏览器打开，查看控制台输出！

Controller 返回 JSON 数据

导入 Jackson 的 jar 包

<dependencies>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.14.1</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

配置 SpringMVC 的 web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--1.注册 servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定 SpringMVC 配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--所有请求都会被 springmvc 拦截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/</url-pattern>
    </filter-mapping>
</web-app>

springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 自动扫描指定的包，下面所有注解类交给 IOC 容器管理 -->
    <context:component-scan base-package="com.locke.controller"/>
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

写一个 User 的实体类，然后我们去编写我们的测试 Controller

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

// @RestController: 如果使用这个，就不需要再配合使用 @ResponseBody
@Controller
public class UserController {
    @RequestMapping("/json1")
    @ResponseBody // 它就不会走视图解析器，会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        // 创建一个 jackson 的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        // 创建一个对象
        User user = new User("LK", 26, "Female");
        // 将我们的对象解析成为 json 格式
        String str = mapper.writeValueAsString(user);
        // 由于 @ResponseBody 注解，这里会将 str 转成 json 格式返回；十分方便
        return str;
    }
}

配置 Tomcat，如果有乱码问题，再设置一下编码格式为 utf-8，以及它的返回类型

// produces: 指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

代码优化

乱码统一解决

上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过 Spring 配置统一指定，这样就不用每次都去处理了。

我们可以在 springmvc 的配置文件上添加一段消息 StringHttpMessageConverter 转换配置！

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

返回 json 字符串统一解决

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加 @ResponseBody ！我们在前后端分离开发中，一般都使用 @RestController ，十分便捷！

@RestController
public class UserController {
    // produces: 指定响应体返回类型和编码
    @RequestMapping(value = "/json1")
    public String json1() throws JsonProcessingException {
        // 创建一个 jackson 的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        // 创建一个对象
        User user = new User("LK", 26, "Female");
        // 将我们的对象解析成为 json 格式
        String str = mapper.writeValueAsString(user);
        // 由于 @ResponseBody 注解，这里会将 str 转成 json 格式返回；十分方便
        return str;
    }
}

测试集合输出

增加一个新的方法：

@RequestMapping("/json2")
public String json2() throws JsonProcessingException {
    // 创建一个 jackson 的对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    // 创建一个对象
    User user1 = new User("LK1", 1, "Female");
    User user2 = new User("LK2", 2, "Female");
    User user3 = new User("LK3", 3, "Female");
    User user4 = new User("LK4", 4, "Female");
    List<User> list = new ArrayList<User>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);
    // 将我们的对象解析成为json格式
    String str = mapper.writeValueAsString(list);
    return str;
}

输出时间对象

增加一个新的方法：

@RequestMapping("/json3")
public String json3() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    // 创建时间一个对象，java.util.Date
    Date date = new Date();
    // 将我们的对象解析成为json格式
    String str = mapper.writeValueAsString(date);
    return str;
}

默认日期格式会变成一个数字，是 1970 年 1 月 1 日到当前日期的毫秒数！
Jackson 默认是会把时间转成 timestamps 形式

解决方案：取消 timestamps 形式，自定义时间格式

@RequestMapping("/json4")
public String json4() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    // 不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    // 自定义日期格式对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // 指定日期格式
    mapper.setDateFormat(sdf);
    Date date = new Date();
    String str = mapper.writeValueAsString(date);
    return str;
}

抽取为工具类

如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中；我们去编写下

public class JsonUtils {
    public static String getJson(Object object) {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }
    public static String getJson(Object object,String dateFormat) {
        ObjectMapper mapper = new ObjectMapper();
        // 不使用时间差的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // 自定义日期格式对象
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        // 指定日期格式
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

@RequestMapping("/json5")
public String json5() throws JsonProcessingException {
    Date date = new Date();
    String json = JsonUtils.getJson(date);
    return json;
}

FastJson

fastjson.jar 是阿里开发的一款专门用于 Java 开发的包，可以方便的实现 json 对象与 JavaBean 对象的转换，实现 JavaBean 对象与 json 字符串的转换，实现 json 对象与 json 字符串的转换。实现 json 的转换方法很多，最后的实现结果都是一样的。

fastjson 的 pom 依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

fastjson 三个主要的类：

JSONObject 代表 json 对象
- JSONObject 实现了 Map 接口，猜想 JSONObject 底层操作是由 Map 实现的。
- JSONObject 对应 json 对象，通过各种形式的 get() 方法可以获取 json 对象中的数据，也可利用诸如 size()，isEmpty() 等方法获取 "键：值" 对的个数和判断是否为空。其本质是通过实现 Map 接口并调用接口中的方法完成的。
JSONArray 代表 json 对象数组
- 内部是有 List 接口中的方法来完成操作的。
JSON 代表 JSONObject 和 JSONArray 的转化
- JSON 类源码分析与使用
- 仔细观察这些方法，主要是实现 json 对象，json 对象数组，javabean 对象，json 字符串之间的相互转化。

新建一个 FastJsonDemo 类：

package com.kuang.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.kuang.pojo.User;
import java.util.ArrayList;
import java.util.List;
public class FastJsonDemo {
    public static void main(String[] args) {
        //创建一个对象
        User user1 = new User("秦疆1号", 3, "男");
        User user2 = new User("秦疆2号", 3, "男");
        User user3 = new User("秦疆3号", 3, "男");
        User user4 = new User("秦疆4号", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        System.out.println("*******Java对象 转 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);
        System.out.println("\n****** JSON字符串 转 Java对象*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);
        System.out.println("\n****** Java对象 转 JSON对象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));
        System.out.println("\n****** JSON对象 转 Java对象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
    }
}

整合 SSM：非常重要！

op=>operation: 需求分析
db=>operation: 设计数据库
se=>operation: 业务
ht=>operation: 前端界面
op(right)->db(right)->se(right)->ht

ht=>operation: 前端
ct=>operation: Controller
sv=>operation: Service
do=>operation: Dao
db=>operation: 数据库
ht(right)->ct(right)->sv(right)->do(right)->db

读代码：从前往后
写代码：从后往前

数据库环境

创建一个存放书籍数据的数据库表：

CREATE DATABASE `ssmbuild`;
USE `ssmbuild`;
DROP TABLE IF EXISTS `books`;
CREATE TABLE `books` (
  `bookID` INT(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
  `bookName` VARCHAR(100) NOT NULL COMMENT '书名',
  `bookCounts` INT(11) NOT NULL COMMENT '数量',
  `detail` VARCHAR(200) NOT NULL COMMENT '描述',
  KEY `bookID` (`bookID`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`) VALUES
(1,'Java',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从进门到进牢');

基本环境搭建

新建一 Maven 项目! 添加 web 的支持
1. 导入相关的 pom 依赖！
2. Maven 资源过滤设置

<dependencies>
    <!--Junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
    </dependency>
    <!--数据库驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.32</version>
    </dependency>
    <!--数据库连接池-->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>
    <!--Servlet - JSP -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <!--Mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
    <!--Spring-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <!--Lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

建立基本结构和配置框架

com.locke.pojo
com.locke.dao
com.locke.service
com.locke.controller
mybatis-config.xml

<?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>
</configuration>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

Mybatis 层编写

数据库配置文件 database.properties：IDEA 关联数据库

jdbc.driver=com.mysql.cj.jdbc.Driver
# 如果使用的是 MySQL8.0+，还需要增加一个时区的配置 &serverTimezone=Asia/Shanghai
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=130914

编写 MyBatis 的核心配置文件：mybatis-config.xml

<?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>
    <typeAliases>
        <package name="com.locke.pojo"/>
    </typeAliases>
    <mappers>
        <mapper resource="com/locke/dao/BookMapper.xml"/>
    </mappers>
</configuration>

编写数据库对应的实体类 com.locke.pojo.Books，注意使用 lombok 插件

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;
}

编写 Dao 层的 BookMapper 接口

public interface BookMapper {
    // 增加一个 Book
    int addBook(Books book);

    // 根据 id 删除一个 Book
    // int deleteBookById(@Param("bookId") int id);
    int deleteBookById(int id);

    // 更新 Book
    int updateBook(Books books);

    // 根据 id 查询,返回一个 Book
    Books queryBookById(int id);

    // 查询全部 Book, 返回 list 集合
    List<Books> queryAllBook();

    // 根据 id 查询,返回一个Book
    Books queryBookByName(String bookName);
}

编写接口对应的 Mapper.xml 文件，需要导入 MyBatis 的包：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.locke.dao.BookMapper">
    <!--增加一个 Book-->
    <insert id="addBook" parameterType="Books">
        insert into ssmbuild.books(bookName, bookCounts, detail)
        values (#{bookName}, #{bookCounts}, #{detail})
    </insert>
    <!--根据 id 删除一个 Book-->
    <delete id="deleteBookById" parameterType="int">
        delete
        from ssmbuild.books
        where bookID = #{bookID}
    </delete>
    <!--更新 Book-->
    <update id="updateBook" parameterType="Books">
        update ssmbuild.books
        set bookName   = #{bookName},
            bookCounts = #{bookCounts},
            detail     = #{detail}
        where bookID = #{bookID}
    </update>
    <!--根据 id 查询,返回一个Book-->
    <select id="queryBookById" resultType="Books">
        select *
        from ssmbuild.books
        where bookID = #{bookID}
    </select>
    <!--查询全部 Book-->
    <select id="queryAllBook" resultType="Books">
        SELECT *
        from ssmbuild.books
    </select>
</mapper>

编写 Service 层的接口和实现类

// BookService: 底下需要去实现, 调用 dao 层
public interface BookService {
    // 增加一个 Book
    int addBook(Books book);

    // 根据 id 删除一个Book
    int deleteBookById(int id);

    // 更新 Book
    int updateBook(Books books);

    // 根据 id 查询, 返回一个 Book
    Books queryBookById(int id);

    // 查询全部 Book, 返回 list 集合
    List<Books> queryAllBook();

    // 根据 id 查询,返回一个Book
    Books queryBookByName(String bookName);
}

public class BookServiceImpl implements BookService {
    // 调用 dao 层的操作，设置一个 set 接口，方便 Spring 管理
    private BookMapper bookMapper;

    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
    }

    public int addBook(Books book) {
        return bookMapper.addBook(book);
    }

    public int deleteBookById(int id) {
        return bookMapper.deleteBookById(id);
    }

    public int updateBook(Books books) {
        return bookMapper.updateBook(books);
    }

    public Books queryBookById(int id) {
        return bookMapper.queryBookById(id);
    }

    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
    }
}

至此，底层需求编写完毕。

Spring 层

配置 Spring 整合 MyBatis，我们这里数据源使用 c3p0 连接池；
1. 编写 Spring 整合 Mybatis 的相关的配置文件：spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置整合 mybatis -->
    <!-- 1.关联数据库文件 -->
    <context:property-placeholder location="classpath:database.properties"/>
    <!-- 2.数据库连接池 -->
    <!-- 数据库连接池
         dbcp  半自动化操作  不能自动连接
         c3p0  自动化操作（自动的加载配置文件 并且设置到对象里面）
    -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 配置连接池属性 -->
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <!-- c3p0 连接池的私有属性 -->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!-- 关闭连接后不自动 commit -->
        <property name="autoCommitOnClose" value="false"/>
        <!-- 获取连接超时时间 -->
        <property name="checkoutTimeout" value="10000"/>
        <!-- 当获取连接失败重试次数 -->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>
    <!-- 3.配置 SqlSessionFactory 对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置 MyBatis 全局配置文件:mybatis-config.xml -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
    <!-- 4.配置扫描 Dao 接口包，动态实现 Dao 接口注入到 spring 容器中 -->
    <!-- 解释 ： https://www.cnblogs.com/jpfss/p/7799806.html-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入 sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描 Dao 接口包 -->
        <property name="basePackage" value="com.locke.dao"/>
    </bean>
</beans>

Spring 整合 service 层：spring-service.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 扫描 service 相关的 bean -->
    <context:component-scan base-package="com.locke.service"/>
    <!-- BookServiceImpl 注入到 IOC 容器中 -->
    <bean id="BookServiceImpl" class="com.locke.service.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

SpringMVC 层

编写 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--DispatcherServlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--一定要注意:我们这里加载的是总的配置文件，之前被这里坑了！-->
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!--encodingFilter-->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--Session 过期时间-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
</web-app>

编写 spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 配置 SpringMVC -->
    <!-- 1.开启 SpringMVC 注解驱动 -->
    <mvc:annotation-driven/>
    <!-- 2.静态资源默认 servlet 配置-->
    <mvc:default-servlet-handler/>
    <!-- 3.配置 jsp 显示 ViewResolver 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!-- 4.扫描 web 相关的 bean -->
    <context:component-scan base-package="com.locke.controller"/>
</beans>

Spring 配置整合文件：applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <import resource="classpath:spring-dao.xml"/>
    <import resource="classpath:spring-service.xml"/>
    <import resource="classpath:spring-mvc.xml"/>
</beans>

编写 BookController

@Controller
@RequestMapping("/book")
public class BookController {
    @Autowired
    @Qualifier("BookServiceImpl")
    private BookService bookService;

    // 查询全部的书籍，并且返回到一个书籍展示页面
    @RequestMapping("/allBook")
    public String list(Model model) {
        List<Books> list = bookService.queryAllBook();
        model.addAttribute("list", list);
        return "allBook";
    }
}

编写首页 index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE HTML>
<html>
<head>
    <title>首页</title>
    <style type="text/css">
        a {
            text-decoration: none;
            color: #fdfdfd;
            font-size: 18px;
        }

        h3 {
            width: 180px;
            height: 38px;
            margin: 100px auto;
            text-align: center;
            line-height: 38px;
            background: #0b6c76;
            border-radius: 4px;
        }
    </style>
</head>
<body>
<h3>
    <a href="${pageContext.request.contextPath}/book/allBook">点击进入列表页</a>
</h3>
</body>
</html>

编写书籍列表 allbook.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>书籍列表</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <!-- 引入 Bootstrap -->
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>书籍列表 —— 显示所有书籍</small>
                </h1>
            </div>
        </div>
    </div>
    <div class="row">
        <div class="col-md-4 column">
            <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/toAddBook">新增书籍</a>
            <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/allBook">显示全部书籍</a>
        </div>
        <div class="col-md-8 column">
            <%--class="form-inline" 可以让组件横着排版--%>
            <form class="form-inline" action="${pageContext.request.contextPath}/book/queryBook" method="post" style="float: right">
                <span style="color: red;font-weight: bold">${error}</span>
                <input type="text" name="queryBookName" class="form-control" placeholder="输入查询书名" required>
                <input type="submit" value="查询" class="btn btn-primary">
            </form>
        </div>
    </div>
    <div class="row clearfix">
        <div class="col-md-12 column">
            <table class="table table-hover table-striped">
                <thead>
                <tr>
                    <th>书籍编号</th>
                    <th>书籍名字</th>
                    <th>书籍数量</th>
                    <th>书籍详情</th>
                    <th>书籍操作</th>
                </tr>
                </thead>

                <tbody>
                <c:forEach var="book" items="${requestScope.get('list')}">
                    <tr>
                        <td>${book.getBookID()}</td>
                        <td>${book.getBookName()}</td>
                        <td>${book.getBookCounts()}</td>
                        <td>${book.getDetail()}</td>
                        <td>
                            <%--取出当前 bookID，传给 toUpdateBook--%>
                            <a href="${pageContext.request.contextPath}/book/toUpdateBook/${book.getBookID()}">更改</a>
                            |
                            <a href="${pageContext.request.contextPath}/book/del/${book.getBookID()}">删除</a>
                        </td>
                    </tr>
                </c:forEach>
                </tbody>
            </table>
        </div>
    </div>
</div>
</body>

BookController 类编写，方法二：添加书籍

// 跳转到增加书籍页面
@RequestMapping("/toAddBook")
public String toAddPaper() {
    return "addBook";
}

// 添加书籍的请求
@RequestMapping("/addBook")
public String addPaper(Books books) {
    System.out.println(books);
    bookService.addBook(books);
    // 重定向
    return "redirect:/book/allBook";
}

添加书籍页面：addBook.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>新增书籍</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <!-- 引入 Bootstrap -->
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>新增书籍</small>
                </h1>
            </div>
        </div>
    </div>
    <form action="${pageContext.request.contextPath}/book/addBook" method="post">
        <%--required 表示此字段不可以为空--%>
        书籍名称：<input type="text" name="bookName" required><br><br><br>
        书籍数量：<input type="text" name="bookCounts" required><br><br><br>
        书籍详情：<input type="text" name="detail" required><br><br><br>
        <input type="submit" value="添加">
    </form>
</div>

BookController 类编写，方法三：修改书籍

// 跳转到修改页面
@RequestMapping("/toUpdateBook/{bookId}")
public String toUpdateBook(Model model, @PathVariable("bookId") int id) {
    Books books = bookService.queryBookById(id);
    System.out.println(books);
    model.addAttribute("book", books);
    return "updateBook";
}

// 修改书籍
@RequestMapping("/updateBook")
public String updateBook(Model model, Books book) {
    System.out.println(book);
    // 调业务层去修改
    bookService.updateBook(book);
    Books books = bookService.queryBookById(book.getBookID());
    model.addAttribute("books", books);
    return "redirect:/book/allBook";
}

修改书籍页面：updateBook.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>修改信息</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <!-- 引入 Bootstrap -->
    <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>修改信息</small>
                </h1>
            </div>
        </div>
    </div>
    <form action="${pageContext.request.contextPath}/book/updateBook" method="post">
        <%--出现问题：我们提交了修改的 SQL 请求，但是修改失败，初次考虑是事务问题，但配置完事务后依旧失败--%>
        <%--看一下 SQL 语句能否执行成功，SQL 执行失败，修改未完成--%>
        <%--前端传递隐藏域--%>
        书籍名称：<input type="text" name="bookName" value="${book.bookName}" required/><br><br><br>
        书籍数量：<input type="text" name="bookCounts" value="${book.bookCounts}" required/><br><br><br>
        书籍详情：<input type="text" name="detail" value="${book.detail}" required/><br><br><br>
        <input type="submit" value="提交"/>
        <input type="hidden" name="bookID" value="${book.bookID}"/><br><br><br>
    </form>
</div>

BookController 类编写，方法四：删除书籍

// 删除书籍
@RequestMapping("/del/{bookId}")
public String deleteBook(@PathVariable("bookId") int id) {
    bookService.deleteBookById(id);
    return "redirect:/book/allBook";
}

配置 Tomcat 运行

注意：如果遇到启动过滤器异常的问题（被它坑了好久），去项目结构 \(\to\) 工件中添加和 class 同级别的文件夹 lib，并导入相应的 library。

如果遇到问题：bean 不存在

查看这个 bean 注入是否成功

Junit 单元测试，看我们的代码是否能够查询出来结果

问题一定不在我们的底层，是 spring 出了问题

SpringMVC 整合的时候没调到我们的 service 层的 bean

applicationContext.xml 没有注入 bean

web.xml 中，我们也绑定过配置文件：发现问题，我们配置的是 Spring-mvc.xml，这里面确实没有 service bean，所以报错

整个项目的结构图如下：

SSM 框架的重要程度是不言而喻的，学到这里，大家已经可以进行基本网站的单独开发，但这只是增删改查的基本操作，还远远不够。

实现查询书籍功能

前端页面增加一个输入框和查询按钮

<div class="col-md-8 column">
    <%--class="form-inline" 可以让组件横着排版--%>
    <form class="form-inline" action="${pageContext.request.contextPath}/book/queryBook" method="post"
              style="float: right">
        <span style="color: red;font-weight: bold">${error}</span>
        <input type="text" name="queryBookName" class="form-control" placeholder="输入查询书名" required>
        <input type="submit" value="查询" class="btn btn-primary">
    </form>
</div>

编写查询的 Controller

// 查询
@RequestMapping("/queryBook")
public String queryBook(String queryBookName, Model model) {
    System.out.println("要查询的书籍:" + queryBookName);
    // 业务逻辑还没有写
    return "allBook";
}

搞定底层代码

Mapper 接口

//根据 id 查询, 返回一个 Book
Books queryBookByName(String bookName);

Mapper.xml

<!--根据书名查询, 返回一个 Book-->
<select id="queryBookByName" resultType="Books">
    select * from ssmbuild.books
    where bookName = #{bookName}
</select>

Service 接口

// 根据 id 查询, 返回一个 Book
Books queryBookByName(String bookName);

Service 实现类

public Books queryBookByName(String bookName) {
    return bookMapper.queryBookByName(bookName);
}

完善 Controller

// 查询
@RequestMapping("/queryBook")
public String queryBook(String queryBookName, Model model) {
    System.err.println("要查询的书籍:" + queryBookName);
    Books books = bookService.queryBookByName(queryBookName);
    List<Books> list = new ArrayList<Books>();
    list.add(books);
    // 如果查询为空，返回全部的书籍
    if (books == null) {
        list = bookService.queryAllBook();
        model.addAttribute("error", "所查询书籍不在数据库中，请重新输入!");
    }

    model.addAttribute("list", list);
    return "allBook";
}

Ajax

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

Ajax 是一种无需重新加载整个网页的情况下，能够更新部分网页的技术。
Google Suggest 使用 Ajax 创造出动态性极强的 web 界面：当您在谷歌的搜索框输入关键字时，JavaScript 会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表。
传统的网页想要更新内容或者提交一个表单，都需要重新加载整个网页；
使用 Ajax 技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新。
使用 Ajax，用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的 Web 用户界面。

利用 AJAX 可以做：

注册时，输入用户名自动检测用户是否已经存在；
登陆时，提示用户名密码错误；
删除数据行时，将行 ID 发送到后台，后台在数据库中删除，删除成功后，在页面 DOM 中将数据行也删除。

伪造 Ajax

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

    <script type="text/javascript">
        window.onload = function () {
            var myDate = new Date();
            document.getElementById('currentTime').innerText = myDate.getTime();
        };

        function LoadPage() {
            var targetUrl = document.getElementById('url').value;
            console.log(targetUrl);
            document.getElementById("iframePosition").src = targetUrl;
        }
    </script>

    <div>
        <p>请输入要加载的地址：<span id="currentTime"></span></p>
        <p>
            <input id="url" type="text" value="https://www.baidu.com/"/>
            <input type="button" value="提交" onclick="LoadPage()">
        </p>
    </div>

    <div>
        <h3>加载页面位置：</h3>
        <iframe id="iframePosition" style="width: 100%; height: 500px;"></iframe>
    </div>

</body>
</html>

jQuery.ajax

Ajax 的核心是 XMLHttpRequest 对象 (XHR)。XHR 为向服务器发送请求和解析服务器响应提供了接口，能够以异步方式从服务器获取新数据。
jQuery 提供多个与 AJAX 有关的方法。
通过 jQuery AJAX 方法，您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中。
jQuery 不是生产者，而是大自然搬运工。
jQuery Ajax 本质就是 XMLHttpRequest，对他进行了封装，方便调用！

jQuery.ajax(...)
       部分参数：
              url：请求地址
             type：请求方式，GET、POST（1.9.0之后用 method）
          headers：请求头
             data：要发送的数据
      contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
            async：是否异步
          timeout：设置请求超时时间（毫秒）
       beforeSend：发送请求前执行的函数(全局)
         complete：完成之后执行的回调函数(全局)
          success：成功之后执行的回调函数(全局)
            error：失败之后执行的回调函数(全局)
          accepts：通过请求头发送给服务器，告诉服务器当前客户端课接受的数据类型
         dataType：将服务器端返回的数据转换成指定类型
            "xml": 将服务器端返回的内容转换成xml格式
           "text": 将服务器端返回的内容转换成普通文本格式
           "html": 将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
         "script": 尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
           "json": 将服务器端返回的内容转换成相应的JavaScript对象
          "jsonp": JSONP 格式使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数

配置 web.xml 和 springmvc 的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 配置 SpringMVC -->
    <!-- 1.开启 SpringMVC 注解驱动 -->
    <mvc:annotation-driven/>
    <!-- 2.静态资源默认 servlet 配置-->
    <mvc:default-servlet-handler/>
    <!-- 3.配置 jsp 显示 ViewResolver 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!-- 4.扫描 web 相关的 bean -->
    <context:component-scan base-package="com.locke.controller"/>
</beans>

编写一个 AjaxController

@Controller
public class AjaxController {
    @RequestMapping("/a1")
    public void ajax1(String name , HttpServletResponse response) throws IOException {
        if ("admin".equals(name)){
            response.getWriter().print("true");
        }else{
            response.getWriter().print("false");
        }
    }
}

导入 jQuery，可以使用在线的 CDN ，也可以下载导入

<script src="https://code.jquery.com/jquery-3.6.3.min.js"></script>
<script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.3.js"></script>

编写 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>$Title$</title>
    <%--<script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>--%>
    <script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.3.js"></script>
    <script>
        function a1() {
            $.post({
                url: "${pageContext.request.contextPath}/a1",
                data: {'name': $("#txtName").val()},
                success: function (data) {
                    alert(data);
                }
            });
        }
    </script>
</head>
<body>
<%--onblur：失去焦点触发事件--%>
用户名: <input type="text" id="txtName" onblur="a1()"/>
</body>
</html>

启动 tomcat 测试！打开浏览器的控制台，当我们鼠标离开输入框的时候，可以看到发出了一个 ajax 的请求！是后台返回给我们的结果！测试成功！

SpringMVC 实现

实体类 User

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

获取一个集合对象，展示到前端页面

@RequestMapping("/a2")
public List<User> ajax2(){
    List<User> list = new ArrayList<User>();
    list.add(new User("LK 1 号",1,"女"));
    list.add(new User("LK 2 号",2,"女"));
    list.add(new User("LK 3 号",3,"女"));
    return list; //由于 @RestController 注解，将 list 转成 json 格式返回
}

前端页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<input type="button" id="btn" value="获取数据"/>
<table width="80%" align="center">
    <tr>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    <tbody id="content">
    </tbody>
</table>
<script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.3.js"></script>
<script>
    $(function () {
        $("#btn").click(function () {
            $.post("${pageContext.request.contextPath}/a2", function (data) {
                console.log(data)
                var html = "";
                for (var i = 0; i < data.length; i++) {
                    html += "<tr>" +
                        "<td>" + data[i].name + "</td>" +
                        "<td>" + data[i].age + "</td>" +
                        "<td>" + data[i].sex + "</td>" +
                        "</tr>"
                }
                $("#content").html(html);
            });
        })
    })
</script>
</body>
</html>

可以成功实现数据回显！

注册提示效果

写一个 Controller

@RequestMapping("/a3")
public String ajax3(String name,String pwd){
    String msg = "";
    // 模拟数据库中存在数据
    if (name!=null){
        if ("admin".equals(name)){
            msg = "OK";
        }else {
            msg = "用户名输入错误";
        }
    }
    if (pwd!=null){
        if ("123456".equals(pwd)){
            msg = "OK";
        }else {
            msg = "密码输入有误";
        }
    }
    return msg; //由于 @RestController 注解，将 msg 转成 json 格式返回
}

前端页面 login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ajax</title>
    <script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.3.js"></script>
    <script>
        function a1(){
            $.post({
                url:"${pageContext.request.contextPath}/a3",
                data:{'name':$("#name").val()},
                success:function (data) {
                    if (data.toString()=='OK'){
                        $("#userInfo").css("color","green");
                    }else {
                        $("#userInfo").css("color","red");
                    }
                    $("#userInfo").html(data);
                }
            });
        }
        function a2(){
            $.post({
                url:"${pageContext.request.contextPath}/a3",
                data:{'pwd':$("#pwd").val()},
                success:function (data) {
                    if (data.toString()=='OK'){
                        $("#pwdInfo").css("color","green");
                    }else {
                        $("#pwdInfo").css("color","red");
                    }
                    $("#pwdInfo").html(data);
                }
            });
        }
    </script>
</head>
<body>
<p>
    用户名:<input type="text" id="name" onblur="a1()"/>
    <span id="userInfo"></span>
</p>
<p>
    密码:<input type="text" id="pwd" onblur="a2()"/>
    <span id="pwdInfo"></span>
</p>
</body>
</html>

记得处理 json 乱码的问题。

可以测试一下效果：动态请求响应，局部刷新，就是如此！

拦截器

概述

SpringMVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter, 用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。

拦截器和过滤器的区别：拦截器是 AOP 思想的具体应用。

过滤器
- servlet 规范中的一部分，任何 java web 工程都可以使用
- 在 url-pattern 中配置了 /* 之后，可以对所有要访问的资源进行拦截
拦截器
- 拦截器是 SpringMVC 框架自己的，只有使用了 SpringMVC 框架的工程才能使用
- 拦截器只会拦截访问的控制器方法，如果访问的是 jsp/html/css/image/js 是不会进行拦截的

自定义拦截器

想要自定义拦截器，必须实现 HandlerInterceptor 接口。

新建一个 Moudule， springmvc-07-Interceptor，添加 web 支持
配置 web.xml 和 springmvc-servlet.xml 文件
编写一个拦截器

package com.locke.interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyInterceptor implements HandlerInterceptor {
    // 在请求处理的方法之前执行
    // 如果返回 true 执行下一个拦截器
    // 如果返回 false 就不执行下一个拦截器
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("------------处理前------------");
        return true;
    }
    // 在请求处理方法执行之后执行
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("------------处理后------------");
    }
    // 在 dispatcherServlet 处理后执行,做清理工作.
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("------------清理------------");
    }
}

在 springmvc 的配置文件中配置拦截器

<!--关于拦截器的配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--/** 包括路径及其子路径-->
        <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
        <!--/admin/** 拦截的是/admin/下的所有-->
        <mvc:mapping path="/**"/>
        <!--bean配置的就是拦截器-->
        <bean class="com.locke.interceptor.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

编写一个 Controller，接受请求

// 测试拦截器的控制器
@Controller
public class InterceptorController {
    @RequestMapping("/interceptor")
    @ResponseBody
    public String testFunction() {
        System.out.println("控制器中的方法执行了");
        return "hello";
    }
}

前端 index.jsp

<a href="${pageContext.request.contextPath}/interceptor">拦截器测试</a>

验证用户是否登录（认证用户）

实现思路：

有一个登陆页面，需要写一个 controller 访问页面。
登陆页面有一提交表单的动作。需要在 controller 中处理。判断用户名密码是否正确。如果正确，向 session 中写入用户信息。返回登陆成功。
拦截用户请求，判断用户是否登陆。如果用户已经登陆。放行，如果用户未登陆，跳转到登陆页面

具体实现：

编写 login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<h1>登录页面</h1>
<hr>
<body>
<%--在 web-inf 下的所有页面或者资源，只能通过 controller 或者 servlet 进行访问--%>
<form action="${pageContext.request.contextPath}/user/login">
    用户名：<input type="text" name="username"> <br>
    密码： <input type="password" name="pwd"> <br>
    <input type="submit" value="提交">
</form>
</body>
</html>

编写 Controller

@Controller
@RequestMapping("/user")
public class LoginController {
    // 跳转到登陆页面
    @RequestMapping("/jumplogin")
    public String jumpLogin() throws Exception {
        return "login";
    }

    // 跳转到成功页面
    @RequestMapping("/jumpSuccess")
    public String jumpSuccess() throws Exception {
        return "success";
    }

    // 登陆提交
    @RequestMapping("/login")
    public String login(HttpSession session, String username, String pwd) throws Exception {
        // 向 session 记录用户身份信息
        System.out.println("接收前端===" + username);
        session.setAttribute("user", username);
        return "success";
    }

    // 退出登陆
    @RequestMapping("logout")
    public String logout(HttpSession session) throws Exception {
        // session 过期
        session.invalidate();
        return "login";
    }
}

编写登录成功的页面 success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>登录成功页面</h1>
    <hr>
    ${user}
    <a href="${pageContext.request.contextPath}/user/logout">注销</a>
</body>
</html>

在 index 页面上测试跳转！启动 Tomcat 测试，未登录也可以进入主页

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <h1>首页</h1>
  <hr>
  <%--登录--%>
  <a href="${pageContext.request.contextPath}/user/jumplogin">登录</a>
  <a href="${pageContext.request.contextPath}/user/jumpSuccess">成功页面</a>
  </body>
</html>

编写用户登录拦截器

public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
        // 如果是登陆页面则放行
        System.out.println("uri: " + request.getRequestURI());
        if (request.getRequestURI().contains("login")) {
            return true;
        }
        HttpSession session = request.getSession();
        // 如果用户已登陆也放行
        if (session.getAttribute("user") != null) {
            return true;
        }
        // 用户没有登陆跳转到登陆页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
        return false;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
    }

    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
    }
}

在 SpringMVC 的配置文件中注册拦截器

<!--关于拦截器的配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean id="loginInterceptor" class="com.locke.interceptor.LoginInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

再次重启 Tomcat 测试！会发现点击成功页面按钮后不会跳转到登录成功页面，而是跳转到登录页面！这就是拦截器！

文件上传和下载

文件上传是项目开发中最常见的功能之一，springMVC 可以很好的支持文件上传，但是 SpringMVC 上下文中默认没有装配 MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用 Spring 的文件上传功能，则需要在上下文中配置 MultipartResolver。

前端表单要求：为了能上传文件，必须将表单的 method 设置为 POST，并将 enctype 设置为 multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器；

文件上传

导入文件上传的 jar 包，commons-fileupload ， Maven 会自动帮我们导入他的依赖包 commons-io 包；

<!--文件上传-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
<!--servlet-api导入高版本的-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>

配置 bean：multipartResolver

<!--文件上传配置-->
<bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
    <property name="defaultEncoding" value="utf-8"/>
    <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
    <property name="maxUploadSize" value="10485760"/>
    <property name="maxInMemorySize" value="40960"/>
</bean>

注意！！！这个 bena 的 id 必须为：multipartResolver ，否则上传文件会报 400 的错误！

CommonsMultipartFile 的常用方法：

String getOriginalFilename()：获取上传文件的原名

InputStream getInputStream()：获取文件流

void transferTo(File dest)：将上传文件保存到一个目录文件中

编写前端页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>$Title$</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/upload" enctype="multipart/form-data" method="post">
        <input type="file" name="file"/>
        <input type="submit" value="upload">
    </form>
</body>
</html>

Controller

import java.io.*;

// 注意 RestController 和 Controller 之间的区别
@Controller
public class FileController {
    // @RequestParam("file") 将 name=file 控件得到的文件封装成 CommonsMultipartFile 对象
    // 批量上传 CommonsMultipartFile 则为数组即可
    @RequestMapping("/upload")
    public String fileUpload(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {
        // 获取文件名 : file.getOriginalFilename();
        String uploadFileName = file.getOriginalFilename();
        // 如果文件名为空，直接回到首页！
        if ("".equals(uploadFileName)) {
            return "redirect:/index.jsp";
        }
        System.out.println("上传文件名 : " + uploadFileName);

        // 上传路径保存设置：在 out/artifacts/项目/upload 中找到
        String path = request.getServletContext().getRealPath("/upload");
        // 如果路径不存在，创建一个
        File realPath = new File(path);
        if (!realPath.exists()) {
            realPath.mkdir();
        }
        System.out.println("上传文件保存地址：" + realPath);
        InputStream is = file.getInputStream(); // 文件输入流
        OutputStream os = new FileOutputStream(new File(realPath, uploadFileName)); // 文件输出流
        // 读取写出
        int len = 0;
        byte[] buffer = new byte[1024];
        while ((len = is.read(buffer)) != -1) {
            os.write(buffer, 0, len);
            os.flush();
        }
        os.close();
        is.close();
        return "redirect:/index.jsp";
    }
}

测试上传文件，OK

采用 file.Transto 来保存上传的文件：

编写 Controller

/*
* 采用 file.Transto 来保存上传的文件
*/
@RequestMapping("/upload2")
public String fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {
    // 上传路径保存设置
    String path = request.getServletContext().getRealPath("/upload");
    File realPath = new File(path);
    if (!realPath.exists()) {
        realPath.mkdir();
    }
    // 上传文件地址
    System.out.println("上传文件保存地址：" + realPath);
    // 通过 CommonsMultipartFile 的方法直接写文件（注意这个时候）
    file.transferTo(new File(realPath + "/" + file.getOriginalFilename()));
    return "redirect:/index.jsp";
}

前端表单提交地址修改，访问提交测试，OK！

文件下载

文件下载步骤：

设置 response 响应头
读取文件：InputStream
写出文件：OutputStream
执行操作
关闭流：先开后关

代码实现：

@RequestMapping(value = "/download")
public String downloads(HttpServletResponse response, HttpServletRequest request) throws Exception {
    // 要下载的图片地址
    String path = request.getServletContext().getRealPath("/upload");
    String fileName = "IEEE 投稿样式对照.pdf";
    // 1. 设置 response 响应头
    response.reset(); // 设置页面不缓存,清空 buffer
    response.setCharacterEncoding("UTF-8"); // 字符编码
    response.setContentType("multipart/form-data"); // 二进制传输数据
    // 设置响应头
    response.setHeader("Content-Disposition",
                       "attachment;fileName=" + URLEncoder.encode(fileName, "UTF-8"));
    File file = new File(path, fileName);
    // 2. 读取文件--输入流
    InputStream input = new FileInputStream(file);
    // 3. 写出文件--输出流
    OutputStream out = response.getOutputStream();
    byte[] buff = new byte[1024];
    int index = 0;
    // 4. 执行 写出操作
    while ((index = input.read(buff)) != -1) {
        out.write(buff, 0, index);
        out.flush();
    }
    out.close();
    input.close();
    return null;
}

前端：

<a href="/download">点击下载</a>

posted @ 2024-02-10 23:15 Lockegogo 阅读(155) 评论(0) 编辑收藏举报

刷新页面返回顶部