springMVC

最新推荐文章于 2024-08-31 10:44:02 发布

m0_50538723

最新推荐文章于 2024-08-31 10:44:02 发布

阅读量435

点赞数

分类专栏： Spring 文章标签： servlet java spring

本文链接：https://blog.csdn.net/m0_50538723/article/details/129516658

版权

Spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.介绍

SpringMVC 是 Spring 的一个后续产品，是Spring的一个子项目，是View层一整套完备解决方案。

M：Model，模型层，指工程中的JavaBean，作用是处理数据
V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器

1.1 特点

Spring 家族原生产品，与IOC容器无缝对接。
基于原生Servlet，通过了功能强大的前端控制器DispatcherServlet来进行请求的统一管理。
内部组件化程度高、可插拔式组件即插即用，想要什么功能配置相应组件即可。

2. 快速搭建

2.1 开发环境

IDEA : 2022.1
构建工具：Maven 3.8.6
服务器：tomcat 8.5
Spring 版本 5.3.1

2.2 创建Maven工程

创建Web类型的工程即可（体现在打包方式为war）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu.springmvc</groupId>
    <artifactId>springmvc_mvc_helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>

        <!-- 依赖 SpringMVC 则就直接依赖了 Spring 的IOC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!-- Servlet API -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- Spring5 和 Thymeleaf 整合包 -->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>

        <!-- logback 日志: thymeleaf 整合包里面包含了 slf4j 的门面, 因此需要此实现 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
    </dependencies>

</project>

2.3 配置 web.xml

主要目的是注册 DispatcherServlet → 其会完成 IOC容器的创建和管理.

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

    <!-- 配置SpringMVC的前端控制器 DispatcherServlet -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>  <!-- 名称可以随便写 -->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        
<!--        <init-param>-->
<!--            <param-name>ContextConfigLocation</param-name>-->
<!--            <param-value>classpath:springmvc-config.xml</param-value>-->
<!--        </init-param>-->

        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <!--
            /  : 能匹配所有的请求，但是不能包括 .jsp 结尾的请求，需要交给 JSPServlet 进行处理.  且需 springmvc 开启静态资源处理, 才能访问静态资源
            /* : 能匹配到所有的请求(包括)
            *.do : 后缀匹配 , 
              优点：1. 静态资源不会经过 springmvc， 不用额外开启静态资源配置 ; 
                   2. 可以实现伪静态的效果, 比如 *.html
                       作用1: 给黑客入侵增加难度.
                       作用2: 有利于SEO的优化(排名更靠前)
              缺点：不符合 RESTful 风格
              推荐方式: 
         -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

2.4 SpringMVC配置文件

默认固定名字：-servlet.xml → dispatcherServlet-servlet.xml
默认固定位置：WEB-INF下 → /WEB-INF/dispatcherServlet-servlet.xml

‼️如果想修改SpringMVC配置文件的名称和路径，则看上方 web.xml 中被注释掉的初始化参数即可.

可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置SpringMVC前端控制器DispatcherServlet的初始化时间

<?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:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/util
       https://www.springframework.org/schema/util/spring-util.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 包扫描 : 这里只管 controller，放置到MVC的容器里面-->
    <context:component-scan base-package="com.atguigu.springmvc.controller"></context:component-scan>

    <!-- 配置 Thymeleaf 视图解析器
         配置完毕后可以使用MVC的方式完成视图渲染和跳转了
    -->
    <!--下面配置的是视图解析器-->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">

                        <!-- 视图前缀 -->
                        <property name="prefix" value="/WEB-INF/templates/"/>

                        <!-- 视图后缀 -->
                        <property name="suffix" value=".html"/>

                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

    <!-- 开启注解驱动 
     @ControllerAdvice
     @ResponseBody
     @RequestBody
    -->
    <mvc:annotation-driven />

</beans>

物理视图：完整的路径
逻辑视图：物理视图减去视图前缀，减去视图后缀
举例：我们想要访问WEB_INF/templates/index.html
这个是他的完整路径，也就是物理视图，那他的逻辑视图，根据上面的试图前缀和试图后缀的设置，去掉前缀：/WEB-INF/templates/，去掉后缀：.html，逻辑视图为index。

2.5 编写页面

路径： /WEB-INF/templates/index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"><!--添加的thymeleaf的约束，只有加上这个，才能在下面使用“th：”这个thymeleaf的语法-->
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>Hello, Spring</h1>
</body>
</html>

2.5 Controller

package com.atguigu.springmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {

    @RequestMapping("/")  // / 即 ..../ContextRoot/
    public String portal() {
        // 将逻辑视图返回
        return "index";
    }
}

// @RequestMapping注解：处理浏览器请求和控制器方法之间的映射关系，也就是让他注解的这个方法处理请求
// @RequestMapping注解的value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径

意思就是，如果浏览器发送一个请求，这个请求路径和@RequestMapping注解中的value属性值一致的时候，这个请求就会通过这个方法处理
当前value属性值中的/代表：localhost：8080/+当前工程的上下文路径

当前这个方法的执行过程：返回一个逻辑视图，这个逻辑视图会被前面配置文件中的视图解析器解析，然后通过视图解析器，加上前缀，加上后缀，就匹配了当前路径下的一个物理视图，再通过thymeleaf的渲染，跳转到该视图所在的页面

通过超链接跳转到指定页面

在主页index.html中设置超链接

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>首页</title>
    </head>
    <body>
        <h1>首页</h1>
        <a th:href="@{/hello}">HelloWorld</a><br/><!--通过thymeleaf解析，就会自动添加上下文路径-->
        <!--
		<a href="/hello">HelloWorld</a>
		这个路径如果被解析，是不会添加上下文路径的，因为此时是由浏览器解析的
		-->
    </body>
</html>

在请求控制器中创建处理请求的方法：

@RequestMapping("/hello")
public String HelloWorld() {
	return "target";
}

3. @RequestMapping（重点）

从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。

SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

3.1 标识位置

源码：
在这里插入图片描述
说明它可以标明一个类，也可以标明一个方法。

@RequestMapping标识一个类：设置映射请求的请求路径的初始信息
@RequestMapping标识一个方法：设置映射请求请求路径的具体信息

大白话：就是，如果在方法所在的类上写了@RequestMapping，里面设置了一个属性，然后在方法上，也设置了一个属性，那么方法最后跳转的路径是：类上的属性中的路径+方法属性中的路径，如下，则跳转的是：localhost:8080/springMVC(上下文路径)/test/hello

@Controller
@RequestMapping("/test")
public class RequestMappingController {
    //此时请求映射所映射的请求的请求路径为：/test/testRequestMapping
    @RequestMapping("/hello")
    public String testRequestMapping(){
        return "success";
    }
}

3.2value

@RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求
是个数组，表明其可以放置多个 path ，匹配当中任意一个均可。
即当前浏览器发送的请求的请求路径和value中任意一个值能匹配的上，则当前请求就会被注解所表示的方法处理

@RequestMapping(
    value = {"/testRequestMapping", "/test"}
)
public String testRequestMapping(){
    return "success";
}

3.3 method 属性 (限制请求方式)

仍然是一个数组（RequestMethod类型的），匹配其中任意一个即可

除了匹配到 Path 还要请求方式相同，取值是个枚举量。

目前学习到的请求方式只有两种：get、post（提交表单的方式设置为post时请求也是post，其他都是get，比如超链接、）

@RequestMapping(
    value = {"/testRequestMapping", "/test"},
    method = {RequestMethod.GET, RequestMethod.POST}
)
public String testRequestMapping(){
    return "success";
}

对于处理指定请求方式的控制器方法，SpringMVC中提供@RequestMapping的派生注解：

处理get请求的映射–>@GetMapping

处理post请求的映射–>@PostMapping

处理put请求的映射–>@PutMapping

处理delete请求的映射–>@DeleteMapping

3.4 Params 属性（了解）

对参数进行限制，可以要求必须携带某些参数，或者是某些参数必须是某个值，或者是某些参数不是某个值

例如：我们期望让请求的资源路径为 /test/testParams 的 GET 请求，并且请求参数中具有 code参数能够被 testParams 方法处理，则可以写如下代码。

可以通过四种表达式设置请求参数和请求映射的匹配关系：

“param”：要求请求映射所匹配的请求必须携带param请求参数

“!param”：要求请求映射所匹配的请求必须不能携带param请求参数

“param=value”：要求请求映射所匹配的请求必须携带param请求参数且param=value

“param!=value”：可以不携带请求参数，但是若携带，则要求请求携带param请求参数的值一定不能是value

@RequestMapping(
    value = {"/testRequestMapping", "/test"},
    method = {RequestMethod.GET, RequestMethod.POST}
    params = {"username","!password","age=20"}
)
public String testRequestMapping(){
    return "success";
}

<!--设置参数的第一种方式-->
 <a th:href="@{/hello?username=admin}">HelloWorld</a><br/>
 <!--设置参数的第二种方式-->
  <a th:href="@{/hello(username='admin')}">HelloWorld</a><br/>

若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面回报错400：Parameter conditions “username, password!=123456” not met for actual request parameters: username={admin}, password={123456}

3.5 headers 属性 (了解)

设置请求头当中必须包含或必须不包含某个键。
在这里插入图片描述

注意最后一点

@RequestMapping(
    value = {"/testRequestMapping", "/test"},
    method = {RequestMethod.GET, RequestMethod.POST}
    params = {"username","!password","age=20"}
    header = {"referer"}<!--通过来源页面出现，也就是比如第一个页面中有链接，跳转到第二个页面，第二个页面的请求头就是referer-->
)
public String testRequestMapping(){
    return "success";
}

3.6 Ant 风格路径

即请求路径当中可以放置一些特殊字符来表示特殊含义

在这里插入图片描述
第一种情况不包括？本身
第三种情况，他的（**）前后不能有任何其他字符

@RequestMappng("/a?a/test/ant")    // aba/test/ant 或 ava/test/ant 都能匹配到，但是 ? 本身无法匹配
@RequestMappng("/a*a/test/ant")    // aaaa/test/ant 能匹配到，但是不能使用 ? 和 / 替换*
@RequestMappng("/**/test/ant")

3.8 路径中的占位符（重点）

参数也作为路径的一部分
原始方式：/user/deleteUser?id=1
Restful : /user/delete/1

SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参

<a th:href="@{/testRest/1/admin}">测试路径中的占位符-->/testRest</a><br>

@DeleteMapping("/delete/{username}/{id}")  // / 即 ..../ContextRoot/
public String delete(@PathVariable("username") String username, @PathVariable("id") Integer uid) {
    // 将逻辑视图返回
    return "index";
}

4. 获取请求参数(接11更详细)

4.1 ServletAPI 获取（不推荐）

@RequestMapping("/paramServletAPI")
public String getParamByServletAPI(HttpServletRequest request) {
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    return "success";
}

4.2直接形参（重点）

在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参

@RequestMapping("/testParam")
public String testParam(String username, String password){
    System.out.println("username:"+username+",password:"+password);
    return "success";
}

‼️ 当名字不一致的时候，使用 @RequestParam，就是让指定名字的请求参数与当前方法中的形参进行绑定。其有三个属性value、 required（是否传递）、 defaultValue（默认值）。
value：设置与形参绑定的请求参数的名字
required：设置是否必须传输value所对应的请求参数，默认值为true。若设置为false，则形参值为null
defaultValue：设置没有传输value所对应的请求参数时，形参的默认值（此时与required属性无关）
如果设置了defalutValue，此时就和required这个值无关了，即便是false，如果value处有形参对应的请求值，就把请求值付给形参，如果没有，就把默认值赋给形参。

4.3 获取请求头（重点）

将请求头信息和控制器方法的形参进行绑定，用法与@RequestParam一致

使用 @RequestHeader，其有三个属性 required, defaultValue

@RequestMapping("/mvc")
public String getParam(@RequestHeader(value = "referer", required = false, defaultValue = "aaa") String referer) {
    return "success";
}

4.4 获取Cookie值（重点）

将cookie信息和控制器方法的形参进行绑定，用法与@RequestParam一致

使用 @CookieValue，其有三个属性 required, defaultValue

@RequestMapping("/mvc")
public String getParam(@CookieValue(value = "JSESSIONID") String jsessionId) {
    return "success";
}

一个jessionID对应一个cookie数据，记得在value属性中都是大写的！

4.5 封装POJO（重点）

如果请求中有很多参数都想要获取，那总是一个个通过注解实现太麻烦，所以提出了可以将整个请求的所有参数封装为一个类。

‼️ 属性名和请求参数名字一致即可。
不管是 GET 或 POST 的x-www-urlencode 均可.

<!--这个pojo是我们创建的目录-->
<form th:action="@{/pojo}" method="post">
	id：<input type="text" name="id"><br>
    用户名：<input type="text" name="username"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit">
</form>

@Data
public class User {
    private Integer id;
    private String username;
    private String password;
}

@RequestMapping("/pojo")
public String getParamByPojo(User user) {
	System.out.println(user);
    return "success";
}
//最终结果-->User{id=null, username='张三', password='123', age=23, sex='男',email='123@qq.com'}

5. 编码过滤器

参考文章：https://zhuanlan.zhihu.com/p/488502005

5.1 POST 请求

解决请求参数获取时候的乱码问题
‼️此过滤器一定要配置到最前面，要不然会无效，因为在设置编码之前一定不能设置请求参数。

<filter>
    <filter-name>characterEncodingFilter</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>
    
    <!-- forseEncoding=true 会设置 response.setCharacterEncoding  -->
    <init-param><!--响应的编码-->
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

6. 域对象共享数据（重点）

6.1 ServletAPI → Request 域（不推荐）

@RequestMapping("/pojo")
public String getParamByPojo(User user, HttpServletRequest request) {
    request.setAttribute();
    return "success";
}

6.2 ModelAndView → Request（重点）

使用ModelAndView 时，可以使用其model功能向请求域共享数据，使用view功能设置逻辑视图，但是控制器方法一定要将ModelAndView 作为返回值。

不管用什么方式设置域数据，最终在SpringMVC的底层都会被封装成一个ModelAndView，所以直接用ModelAndView即可。

@Controller
@RequestMapping("/scope")
public class TestScopeController {
    @RequestMapping("/mav")
    public ModelAndView testMAV() {
        /**
         * 包含 Model 和 View 的功能
         * Model ： 向 Request 域中共享数据
         * View : 设置逻辑视图，实现页面跳转
         */
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("testRequestScope", "Hello, ModelAndView");//请求域的属性名，请求域的属性值
        modelAndView.setViewName("success");

        // 设置逻辑视图
        return modelAndView;
    }
}

在这里插入图片描述

6.3 Model → Request

就是Model单独拿出来，方法依然返回String即可。

@RequestMapping("/model")
public String testModel(Model model) {

    model.addAttribute("testRequestScope", "Hello Model");

    // 设置逻辑视图
    return "success";
}

6.4 ModelMap→ Request

@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap){
    modelMap.addAttribute("testScope", "hello,ModelMap");
    return "success";
}

6.5 ModelMap→ Request

@RequestMapping("/testMap")
public String testMap(Map<String, Object> map){
    map.put("testScope", "hello,Map");
    return "success";
}

在这里插入图片描述

6.6Model、ModelMap、Map的关系

Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap

6.7 向Session 域共享

建议直接向 Servlet API 即可.

6.8 向 application域共享

建议直接向 Servlet API 共享类型的

7.重定向/请求转发

7.1转发视图

SpringMVC中默认的转发视图是InternalResourceView

SpringMVC中创建转发视图的情况：
当控制器方法中所设置的视图名称以"forward:"为前缀时，创建InternalResourceView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"forward:"去掉，剩余部分作为最终路径通过转发的方式实现跳转

@RequestMapping("/testForward")
public String testForward(){
	return "forward:/testHello";
}

7.2重定向视图

SpringMVC中默认的重定向视图是RedirectView

当控制器方法中所设置的视图名称以"redirect:"为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"redirect:"去掉，剩余部分作为最终路径通过重定向的方式实现跳转

@RequestMapping("/testRedirect")
public String testRedirect(){
	return "redirect:/testHello";
}

8. 视图控制器（重点）

在控制器方法中，仅仅实现页面跳转，也就是指在其中设置页面名称来实现跳转，没有其他需求时，就不需要单独创建一个控制器方法了，只需要在配置文件中添加标签就可以达到目的

在SpringMVC的xml文件当中进行配置。

<!--
    path：设置处理的请求地址
    view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/testView" view-name="success"></mvc:view-controller>

<!--开启mvc的注解驱动，如果不加这个，那么只有使用视图控制器处理的请求会被响应，其他没有使用视图控制器的则会报错 -->
<mvc:annotation-driven/>

9. RESTful 支持（重点）

RESTful是我们看待服务器的一种方式。

类似于Java中的一切皆对象，使用RESTful就是在服务器上看成一切皆资源，每个资源是服务器上一个可命名的抽象概念。资源比如服务器上的一张图片，一个表格等等

状态转移：
状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述。通过转移和操作资源的表述，来间接实现操作资源的目的。

实现：
具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE用来删除资源。

REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性。
在这里插入图片描述

9.1 HiddenHttpMethodFilter

目前从浏览器能发送的请求只有GET 和 POST，所以需要再web.xml中添加 HiddenHttpMethodFilter让其支持 PUT 和 DELETE

发送的请求必须满足两个条件才能转换为put或delete：

‼️ 注意点1：PUT/DELETE 的请求从浏览器发出的时候必须以POST方式发出，然后携带请求参数 _method = “PUT” 或 “DELETE”。

‼️ 注意点2：如果配置了编码过滤器，记得将编码过滤器放到处理请求方式的过滤器的前面。

<!-- 处理请求方式的过滤器 -->
<filter>
    <filter-name>hiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>hiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <a th:href="@{/user}">查询所有的用户信息</a> <br/>
    
    <a th:href="@{/user/1}">查询id为1的用户信息</a> <br/>
    
    <form th:action="@{/user}" method="post">
        <input type="submit" value="添加用户信息"/>
    </form>

    <form th:action="@{/user}" method="post">
        <input type="hidden" name="_method" value="PUT"/>
        <input type="submit" value="修改用户信息"/>
    </form>

    <form th:action="@{/user/1}" method="post">
        <input type="hidden" name="_method" value="DELETE"/>
        <input type="submit" value="删除用户"/>
    </form>
</body>
</html>

package com.atguigu.springmvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * 用户资源 user
 * 查询所有的用户信息 ---> /user      :GET
 * 根据id查询所有的用户 ---> /user/id :GET
 * 添加用户信息 ---> /user           :POST
 * 修改用户信息 ---> /user           :PUT
 * 删除用户信息 ---> /user/id        :DELETE
 */
@Controller
@RequestMapping("/user")
public class TestRestController {

    @RequestMapping(value = "", method = RequestMethod.GET)
    public String getAllUser(){
        return "success";
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public String getUserById(@PathVariable("id") Integer userId) {
        return "success";
    }

    @RequestMapping(value = "", method = RequestMethod.POST)
    public String addUser() {
        return "success";
    }

    @RequestMapping(value = "", method = RequestMethod.PUT)
    public String modifyUser() {
        return "success";
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    public String deleteUser(@PathVariable("id") String userId) {
        return "success";
    }
}

目前为止，SpringMVC中提供了两个过滤器：CharacterEncodingFilter和HiddenHttpMethodFilter
在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter

原因：

在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字符集的request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作：

String paramValue = request.getParameter(this.methodParam);

10. 静态资源处理（重点）

使用默认配置的Servlet处理静态资源
当前工程的web.xml 配置的前端控制器 DispatcherServlet 的 url-pattern 是 /
Tomcat 的 web.xml 配置的 DefaultServlet 的url-pattern 也是 /
此时，浏览器发送的请求会优先被 DispatcherServlet 进行处理，但是 DispatcherServlet 无法处理静态资源
若配置了 <mvc:default-servlet-handler /> ，则所有请求都会被 DefaultServlet 处理。
若配置了<mvc:default-servlet-handler /> 和 <mvc:annotation-driven />（和是否使用试图控制器无关），则浏览器发送的请求会先被 DispatcherServlet 处理，无法处理的在交给 DefaultServlet .

<mvc:default-servlet-handler />
<mvc:annotation-driven />

11. Ajax 请求（重点）

在这里插入图片描述

11.1 @RequestBody

@RequestBody可以获取请求体信息，使用@RequestBody注解标识控制器方法的形参，当前请求的请求体就会为当前注解所标识的形参赋值

<!--此时必须使用post请求方式，因为get请求没有请求体-->
<form th:action="@{/test/RequestBody}" method="post">
    用户名：<input type="text" name="username"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit">
</form>

@RequestMapping("/test/RequestBody")
public String testRequestBody(@RequestBody String requestBody){
    System.out.println("requestBody:"+requestBody);
    return "success";
}

输出结果：

requestBody:username=admin&password=123456

11.2 @RequestBody获取json格式的请求参数

在使用了axios发送ajax请求之后，浏览器发送到服务器的请求参数有两种格式：

1、name=value&name=value…，此时的请求参数可以通过request.getParameter()获取，对应SpringMVC中，可以直接通过控制器方法的形参获取此类请求参数

2、{key:value,key:value,…}，此时无法通过request.getParameter()获取，之前我们使用操作json的相关jar包gson或jackson处理此类请求参数，可以将其转换为指定的实体类对象或map集合。在SpringMVC中，直接使用@RequestBody注解标识控制器方法的形参即可将此类请求参数转换为java对象

使用@RequestBody获取json格式的请求参数的条件：

1、导入jackson的依赖:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.1</version>
</dependency>

2、SpringMVC的配置文件中设置开启mvc的注解驱动:

<!--开启mvc的注解驱动-->
<mvc:annotation-driven />

3、在控制器方法的形参位置，设置json格式的请求参数要转换成的java类型（实体类或map）的参数，并使用@RequestBody注解标识:

<input type="button" value="测试@RequestBody获取json格式的请求参数"@click="testRequestBody()"><br>
<script type="text/javascript" th:src="@{/js/vue.js}"></script>
<script type="text/javascript" th:src="@{/js/axios.min.js}"></script>
<script type="text/javascript">
    var vue = new Vue({
        el:"#app",
        methods:{
            testRequestBody(){
                axios.post(
                    "/SpringMVC/test/RequestBody/json",
                    {username:"admin",password:"123456"}
                ).then(response=>{
                    console.log(response.data);
                });
            }
        }
    });
</script>

//将json格式的数据转换为map集合
@RequestMapping("/test/RequestBody/json")
public void testRequestBody(@RequestBody Map<String, Object> map,HttpServletResponse response) throws IOException {
    System.out.println(map);
    //{username=admin, password=123456}
    response.getWriter().print("hello,axios");
}
//将json格式的数据转换为实体类对象
@RequestMapping("/test/RequestBody/json")
public void testRequestBody(@RequestBody User user, HttpServletResponseresponse) throws IOException {
    System.out.println(user);
    //User{id=null, username='admin', password='123456', age=null,gender='null'}
	response.getWriter().print("hello,axios");
}

11.3 @ResponseBody

@ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器

@RequestMapping("/testResponseBody")
public String testResponseBody(){
    //此时会跳转到逻辑视图success所对应的页面
    return "success";
}
@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
    //此时响应浏览器数据success(不跳转，返回值是success)
    return "success";
}

11.4 @ResponseBody响应浏览器json数据

服务器处理ajax请求之后，大多数情况都需要向浏览器响应一个java对象，此时必须将java对象转换为json字符串才可以响应到浏览器，之前我们使用操作json数据的jar包gson或jackson将java对象转换为json字符串。在SpringMVC中，我们可以直接使用@ResponseBody注解实现此功能

@ResponseBody响应浏览器json数据的条件：

1、导入jackson的依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.1</version>
</dependency>

2、SpringMVC的配置文件中设置开启mvc的注解驱动:

<!--开启mvc的注解驱动-->
<mvc:annotation-driven />

3、使用@ResponseBody注解标识控制器方法，在方法中，将需要转换为json字符串并响应到浏览器的java对象作为控制器方法的返回值（此时SpringMVC就可以将此对象直接转换为json字符串并响应到浏览器）:

<input type="button" value="测试@ResponseBody响应浏览器json格式的数据"@click="testResponseBody()"><br>
<script type="text/javascript" th:src="@{/js/vue.js}"></script>
<script type="text/javascript" th:src="@{/js/axios.min.js}"></script>
<script type="text/javascript">
    var vue = new Vue({
        el:"#app",
        methods:{
            testResponseBody(){
                axios.post("/SpringMVC/test/ResponseBody/json").then(response=>{
                    console.log(response.data);
                });
            }
        }
    });
</script>

//响应浏览器list集合
@RequestMapping("/test/ResponseBody/json")
@ResponseBody
public List<User> testResponseBody(){
    User user1 = new User(1001,"admin1","123456",23,"男");
    User user2 = new User(1002,"admin2","123456",23,"男");
    User user3 = new User(1003,"admin3","123456",23,"男");
    List<User> list = Arrays.asList(user1, user2, user3);
    return list;
}
//响应浏览器map集合
@RequestMapping("/test/ResponseBody/json")
@ResponseBody
public Map<String, Object> testResponseBody(){
    User user1 = new User(1001,"admin1","123456",23,"男");
    User user2 = new User(1002,"admin2","123456",23,"男");
    User user3 = new User(1003,"admin3","123456",23,"男");
    Map<String, Object> map = new HashMap<>();
    map.put("1001", user1);
    map.put("1002", user2);
    map.put("1003", user3);
    return map;
}
//响应浏览器实体类对象
@RequestMapping("/test/ResponseBody/json")
@ResponseBody
public User testResponseBody(){
    return user;
}

map结果：
在这里插入图片描述
list结果：（外面有方括号）

常用的Java对象转换成json的结果：
实体类——>json对象
map——>json对象
List——>json数组

11.5 @RestController注解

@RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解

12. 文件处理

下载：服务器——>浏览器
上传：浏览器——>服务器

12.1 文件下载(小文件)

‼️文件下载只能发同步请求，不能发异步请求

使用ResponseEntity实现下载文件的功能

ResponseEntity 表示控制方法返回的完整报文，其泛型就是返回报文里面的数据类型：

下载别的可以用这个模板，改改下载的路径就行

@RequestMapping("/test-download")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
    // 1. 获得文件的真实路径 : webapp/ 开始
    String filePath = session.getServletContext().getRealPath("/static/1.png");

    // 2. 创建输入流
    InputStream inputStream = new FileInputStream(filePath);

    // 3. 创建字节数组, 并读取 todo: 为什么要一次读取到内存里面
    byte[] bytes = new byte[inputStream.available()];
    inputStream.read(bytes);

    // 4. 创建 HttpHeaders 对象设置响应头信息
    MultiValueMap<String, String> headers = new HttpHeaders();

    // 5. 设置下载方式以及下载文件的名字
    headers.add("Content-Disposition", "attachement;filename=1.jpg");

    // 6. 设置响应状态码
    HttpStatus statusCode = HttpStatus.OK;

    // 7. 创建ResponseEndity对象 : 响应体，响应头，响应状态码
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);

    // 8. 关闭输入流
    inputStream.close();
    return responseEntity;
}

如果方法没有返回值，即void，那么这个方法会直接将请求的地址作为逻辑视图，在这个例子中，就是会找test.download.html这个页面

12.2文件上传

文件上传要求form表单的请求方式必须为post，并且添加属性enctype=“multipart/form-data”
SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息

上传步骤：

①添加依赖：

<!-- 文件上传 -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>

②在SpringMVC的配置文件中添加配置：

<!-- 
文件上传解析器 :
  此类负责将文件类型的数据形成 MultipartFile 参数，其底层依赖 commins-fileupload 
  这里一定要写id，因为这时的文件解析器是通过id获取的
-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="defaultEncoding" value="UTF-8"></property>

    <!-- 设置文件的上传限制大小 -->
<!--        <property name="maxUploadSize" value=""></property>-->
</bean>

③测试页面：

文件上传的要求：
form表单的请求方式必须是：post
form表单必须设置属性：enctype=“multipart/form-data”

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>文件上传测试</title>
</head>
<body>
    <!-- 请求方式必须是POST, multipart/form-data是将表单中的数据以二进制的方式提交到服务器中 -->
    <form action="/ssm_war/employee/test-upload" method="POST" enctype="multipart/form-data">
        <input type="file" name="photo"></br>
        <input type="submit" value="上传">
    </form>
</body>
</html>

④接收上传代码
参数名和表单中name 要保持一致。

@RequestMapping("/testUp")
public String testUp(MultipartFile photo, HttpSession session) throws IOException {
    //获取上传的文件的文件名
    String fileName = photo.getOriginalFilename();
    //处理文件重名问题
    String hzName = fileName.substring(fileName.lastIndexOf("."));
    fileName = UUID.randomUUID().toString() + hzName;
    //获取服务器中photo目录的路径
    ServletContext servletContext = session.getServletContext();
    String photoPath = servletContext.getRealPath("photo");
    File file = new File(photoPath);
    if(!file.exists()){
        file.mkdir();
    }
    String finalPath = photoPath + File.separator + fileName;
    //实现上传功能
    photo.transferTo(new File(finalPath));
    return "success";
}

如果不解决重命名的问题，上传两个重名的对象，只会保留最后上传的那个文件，前面上传的就找不到了，因为覆盖了文件中的内容，这里是通过使用UUID将每个文件的名字设置为不一样的

13、拦截器

13.1 拦截器的配置

SpringMVC中的拦截器用于拦截控制器方法的执行

SpringMVC中的拦截器需要实现HandlerInterceptor

SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置：

<bean class="com.atguigu.interceptor.FirstInterceptor"></bean>
<ref bean="firstInterceptor"></ref>
<!-- 以上两种配置方式都是对DispatcherServlet所处理的所有的请求进行拦截 -->
<mvc:interceptor>
    <mvc:mapping path="/**"/>
    <mvc:exclude-mapping path="/abc"/><!-- 可拦截到 /abc/.... 后面的所有的请求 -->
    <ref bean="firstInterceptor"></ref>
</mvc:interceptor>
<!--
    以上配置方式可以通过ref或bean标签设置拦截器，通过mvc:mapping设置需要拦截的请求，
    通过mvc:exclude-mapping设置需要排除的请求，即不需要拦截的请求
-->

13.2 拦截器的三个抽象方法

SpringMVC中的拦截器有三个抽象方法：

preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法

postHandle：控制器方法执行之后执行postHandle()

afterCompletion：处理完视图和模型数据，渲染视图完毕之后执行afterCompletion()

13.3多个拦截器的执行顺序

①若每个拦截器的preHandle()都返回true

此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：

preHandle()会按照配置的顺序执行，而postHandle()和afterCompletion()会按照配置的反序执行

②若某个拦截器的preHandle()返回了false

preHandle()返回false和它之前的拦截器的preHandle()都会执行，之后的 preHandle 方法不会执行了；postHandle()都不执行；afterCompletion 会从返回false的拦截器之前的拦截器开始逆序执行。

14 异常处理器

14.1 基于配置的异常处理

SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResolver

HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver

SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，使用方式：

<bean  class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <!--
                properties的键表示处理器方法执行过程中出现的异常，如下：java.lang.ArithmeticException
                properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面，如下：error
			-->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--
		exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享
	-->
    <property name="exceptionAttribute" value="ex"></property>
</bean>

@Controller
@RequestMapping("/test")
public class TestController {
    @RequestMapping("/hello")
    public String hello() {
        System.out.println(1/0);   // 发生 java.lang.ArithmeticException, 交给 SimpleMappingExceptionResolver
        return "error";
    }
}

14.2 基于注解的异常处理

//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {
    //@ExceptionHandler用于设置所标识方法处理的异常
    @ExceptionHandler(ArithmeticException.class)
    //ex表示当前请求处理中出现的异常对象
    public String handleArithmeticException(Exception ex, Model model){
        model.addAttribute("ex", ex);
        return "error";
    }
}

14.3 两者区别

视图控制器抛出的异常，只能用基于 XML的异常处理方式。

在这里插入图片描述

15. 注解配置SpringMVC(非常重要)

使用配置类的方式代替 springmvc.xml 和 web.xml 的配置，后续SpringBoot的零配置就是基于这种方式实现，因此非常重要。

抛弃web.xml 的原理：（发现机制）
在 servlet3.0 环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer 接口类，如果找到就用它来配置Servlet容器，否则就查找 web.xml 进行配置。
而 Spring 提供了这个接口的实现类，名为SpringServletContainerInitializer的类，并将配置任务交给它们来完成，此时就可以抛弃掉web.xml 。
SpringServletContainerInitializer又会查找实现了 WebApplicationInitializer 的类，并将配置任务交给它们来完成。
Spring3.2 又提供了一个便利的 WebApplicationInitializer 的基础实现（抽象类），名为 AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了**AbstractAnnotationConfigDispatcherServletInitializer **并将其部署到 Servlet3.0容器的时候，容器会自动发现他，并用来配置Servlet 上下文。

由 AbstractAnnotationConfigDispatcherServletInitializer的实现类带动 Spring的IOC配置和SpringMVC的IOC配置，进而消灭了Spring 和 SpringMVC 的核心配置文件

WebInit 实现了AbstractAnnotationConfigDispatcherServletInitializer，用于代替 web.xml

package com.atguigu.springmvc.config;

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;

/**
 * AbstractAnnotationConfigDispatcherServletInitializer 内部配置了 DispatcherServlet
 *
 * 此类用来代替 web.xml.
 */
public class webInit extends AbstractAnnotationConfigDispatcherServletInitializer {

    

    /**
     * 设置一个多个配置类 代替Spring的配置文件, 按照功能划分出来多个配置类
     * 比如 Spring 配置普通组件、Spring管理Redis、Spring管理Bybaits
     * @return
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    /**
     * 设置一个配置类 代替SpringMVC的配置文件
     * @return
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    /**
     * 设置 DispatcherServlet 的 url-pattern
     * @return
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 设置过滤器
     * @return
     */
    @Override
    protected Filter[] getServletFilters() {

        // 创建编码过滤器
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceEncoding(true);  // 请求和响应都设置为 utf-8

        // 创建 处理请求方式的过滤器
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();

        // 注册 filter
        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

创建SpringConfig配置类，代替spring的配置文件：

@Configuration
public class SpringConfig {
    //ssm整合之后，spring的配置信息写在此类中
}

创建WebConfig配置类，代替SpringMVC的配置文件：

@Configuration
//扫描组件（下方代码）
@ComponentScan("com.atguigu.mvc.controller")
//开启MVC注解驱动（下方代码）
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    //使用默认的servlet处理静态资源
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
    //配置文件上传解析器
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        return new CommonsMultipartResolver();
    }
    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
    }
    //配置视图控制
    /*@Override
	public void addViewControllers(ViewControllerRegistry registry) {
		registry.addViewController("/").setViewName("index");
	}*/
    //配置异常映射
    /*@Override
	public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
		SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
		Properties prop = new Properties();
		prop.setProperty("java.lang.ArithmeticException", "error");
		//设置异常映射
		exceptionResolver.setExceptionMappings(prop);
		//设置共享异常信息的键
		exceptionResolver.setExceptionAttribute("ex");
		resolvers.add(exceptionResolver);
	}*/
    //配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext =ContextLoader.getCurrentWebApplicationContext();
            // ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext 的方法获得
            ServletContextTemplateResolver templateResolver = new
                ServletContextTemplateResolver(webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }
    //生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }
    //生成视图解析器并未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }
}

16 SpringMVC执行流程

16.1 SpringMVC常用组件

DispatcherServlet：前端控制器，不需要工程师开发，由框架提供
作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求

HandlerMapping：处理器映射器，不需要工程师开发，由框架提供
作用：根据请求的url、method等信息查找Handler，即控制器方法

Handler：处理器，需要工程师开发
作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理

HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供
作用：通过HandlerAdapter对处理器（控制器方法）进行执行

ViewResolver：视图解析器，不需要工程师开发，由框架提供
作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView、

RedirectView
作用：将模型数据通过页面展示给用户

16.2 DispatcherServlet初始化过程

DispatcherServlet 本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。所以宏观上是 Servlet生命周期来进行调度。

17 SSM整合

17.1 配置spring

导入依赖：

<packaging>war</packaging>
<properties>
    <spring.version>5.3.1</spring.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!--springmvc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- Mybatis核心 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <!--mybatis和spring的整合包-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    <!-- 连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.9</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>
    <!-- log4j日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->   
    <dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
    </dependency>
    <!-- 日志 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
    <!-- ServletAPI -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.12.1</version>
    </dependency>
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.3.1</version>
    </dependency>
    <!-- Spring5和Thymeleaf整合包 -->
    <dependency>
        <groupId>org.thymeleaf</groupId>
        <artifactId>thymeleaf-spring5</artifactId>
        <version>3.0.12.RELEASE</version>
    </dependency>
</dependencies>

创建表：

CREATE TABLE `t_emp` (
    `emp_id` int(11) NOT NULL AUTO_INCREMENT,
    `emp_name` varchar(20) DEFAULT NULL,
    `age` int(11) DEFAULT NULL,
    `sex` char(1) DEFAULT NULL,
    `email` varchar(50) DEFAULT NULL,
    PRIMARY KEY (`emp_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

配置web.xml

<!-- 配置Spring的编码过滤器 -->
<filter>
    <filter-name>CharacterEncodingFilter</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>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 配置处理请求方式PUT和DELETE的过滤器 -->
<filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filterclass>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 配置SpringMVC的前端控制器 -->
<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servletclass>
    <!-- 设置SpringMVC的配置文件的位置和名称 -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:SpringMVC.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 设置Spring的配置文件的位置和名称 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:Spring.xml</param-value>
</context-param>
<!-- 配置Spring的监听器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

创建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:util="http://www.springframework.org/schema/util"
       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-4.0.xsd
       http://www.springframework.org/schema/util
       https://www.springframework.org/schema/util/spring-util.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">

    <!-- 包扫描 -->
    <context:component-scan base-package="com.atguigu.ssm.controller"></context:component-scan>

    
    <!-- 配置 Thymeleaf 视图解析器 配置完毕后可以使用MVC的方式完成视图渲染和跳转了 -->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">

                        <!-- 视图前缀 -->
                        <property name="prefix" value="/WEB-INF/templates/"/>

                        <!-- 视图后缀 -->
                        <property name="suffix" value=".html"/>

                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

    <!-- 处理静态资源 -->
    <mvc:default-servlet-handler />

    <!-- 开启注解驱动 
         @ControllerAdvice
         @ResponseBody
         @RequestBody
         ....
    -->
    <mvc:annotation-driven />

    <!-- 配置视图控制器 -->
    <mvc:view-controller path="/" view-name="index"></mvc:view-controller>
</beans>

17.2 配置MyBatis

创建属性文件jdbc.properties：

jdbc.user=root
jdbc.password=atguigu
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver

创建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>
    <settings>
        <!--将下划线映射为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <plugins>
        <!--配置分页插件-->
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>
</configuration>

创建Mapper接口和映射文件：

public interface EmployeeMapper {
List<Employee> getEmployeeList();
}

<?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.atguigu.ssm.mapper.EmployeeMapper">
    <select id="getEmployeeList" resultType="Employee">
        select * from t_emp
    </select>
</mapper>

创建日志文件log4j.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

创建Spring的配置文件并配置：

<?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">
    <!--扫描组件-->
    <context:component-scan base-package="com.atguigu.ssm">
        <context:exclude-filter type="annotation"expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <!-- 引入jdbc.properties -->
    <context:property-placeholder location="classpath:jdbc.properties">
    </context:property-placeholder>
    <!-- 配置Druid数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
     <!-- 注册 事务管理器 ： 是个切面类（因为使用到了jdbc，所以前面引入了jdbc的依赖） -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <!-- 注入数据源：链接均从数据源当中获取（事务管理都是针对连接对象，
     而连接对象当前都是交给数据源管理） -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 开启事务的注解驱动 ： 将环绕通知作用到连接点上，即 @Transactional 标记的类 或 方法（连接点）使用事务管理 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    <!-- 配置用于创建SqlSessionFactory的工厂bean -->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 设置MyBatis配置文件的路径（可以不设置） -->
        <property name="configLocation" value="classpath:mybatis-config.xml">
        </property>
        
        <!-- 设置数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 设置类型别名所对应的包 -->
        <property name="typeAliasesPackage" value="com.atguigu.ssm.pojo">
        </property>
        <!--
            设置映射文件的路径
            若映射文件所在路径和mapper接口所在包一致，则不需要设置
            （前提是在已经设置了MapperScannerConfigurer这个bean的前提下
            ，如果没有写MapperScannerConfigurer，不管一样不一样，都必须要写这个标签）
        -->
        <!--
            <property name="mapperLocations" value="classpath:mapper/*.xml">
            </property>
        -->
    </bean>
    <!--
        配置mapper接口的扫描配置
        由mybatis-spring提供，可以将指定包下所有的mapper接口通过前面设置的
        SqlSessionFactoryBean创建的sqlsession获得相应的代理实现类对象
        并将这些对象交给IOC容器管理
        -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.atguigu.ssm.mapper"></property>
    </bean>
</beans>

测试：
创建实体类Employee：

public class Employee {
    private Integer empId;
    private String empName;
    private Integer age;
    private String sex;
    private String email;
    public Employee() {
    }
    public Employee(Integer empId, String empName, Integer age, String sex,
                    String email) {
        this.empId = empId;
        this.empName = empName;
        this.age = age;
        this.sex = sex;
        this.email = email;
    }
    public Integer getEmpId() {
        return empId;
    }
    public void setEmpId(Integer empId) {
        this.empId = empId;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
}

创建控制层组件EmployeeController：

@Controller
public class EmployeeController {
    @Autowired
    private EmployeeService employeeService;
    @RequestMapping(value = "/employee/page/{pageNum}", method = RequestMethod.GET)
    public String getEmployeeList(Model model, @PathVariable("pageNum") Integer pageNum){
        PageInfo<Employee> page = employeeService.getEmployeeList(pageNum);
        model.addAttribute("page", page);
        return "employee_list";
    }
}

创建接口EmployeeService：

public interface EmployeeService {
	PageInfo<Employee> getEmployeeList(Integer pageNum);
}

创建实现类EmployeeServiceImpl：

@Service
public class EmployeeServiceImpl implements EmployeeService {
    @Autowired
    private EmployeeMapper employeeMapper;
    @Override
    public PageInfo<Employee> getEmployeeList(Integer pageNum) {
        PageHelper.startPage(pageNum, 4);
        List<Employee> list = employeeMapper.getEmployeeList();
        PageInfo<Employee> page = new PageInfo<>(list, 5);
        return page;
    }
}

创建页面：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Employee Info</title>
        <link rel="stylesheet" th:href="@{/static/css/index_work.css}">
    </head>
    <body>
        <table>
            <tr>
                <th colspan="6">Employee Info</th>
            </tr>
            <tr>
                <th>emp_id</th>
                <th>emp_name</th>
                <th>age</th>
                <th>sex</th>
                <th>email</th>
                <th>options</th>
            </tr>
            <tr th:each="employee : ${page.list}">
                <td th:text="${employee.empId}"></td>
                <td th:text="${employee.empName}"></td>
                <td th:text="${employee.age}"></td>
                <td th:text="${employee.sex}"></td>
                <td th:text="${employee.email}"></td>
                <td>
                    <a href="">delete</a>
                    <a href="">update</a>
                </td>
            </tr>
            <tr>
                <td colspan="6">
                    <span th:if="${page.hasPreviousPage}">
                        <a th:href="@{/employee/page/1}">首页</a>
                        <a th:href="@{'/employee/page/'+${page.prePage}}">上一页</a><!--注意这里的写法！！！-->
                    </span>
                    <span th:each="num : ${page.navigatepageNums}">
                        <a th:if="${page.pageNum==num}"
                           th:href="@{'/employee/page/'+${num}}" th:text="'['+${num}+']'" style="color:red;"></a>
   <!--上面的代码设置的是在下方的导航栏显示页码，并将当前页的页码在导航栏
   中设置为红色，并在页码外面加上[]-->
                        <a th:if="${page.pageNum!=num}"
                           th:href="@{'/employee/page/'+${num}}" th:text="${num} "></a>
                    </span>
                    <span th:if="${page.hasNextPage}">
                        <a th:href="@{'/employee/page/'+${page.nextPage}}">下一页</a>
                        <a th:href="@{'/employee/page/'+${page.pages}}">末页</a><!--pages代表总页数-->
                    </span>
                </td>
            </tr>
        </table>
    </body>
</html>