一文入门SpringMVC

生命无罪，健康万岁，我是laity。

我曾七次鄙视自己的灵魂：
第一次，当它本可进取时，却故作谦卑；
第二次，当它在空虚时，用爱欲来填充；
第三次，在困难和容易之间，它选择了容易；
第四次，它犯了错，却借由别人也会犯错来宽慰自己；
第五次，它自由软弱，却把它认为是生命的坚韧；
第六次，当它鄙夷一张丑恶的嘴脸时，却不知那正是自己面具中的一副；
第七次，它侧身于生活的污泥中，虽不甘心，却又畏首畏尾。

一、Spring MVC入门

1.1 Web环境集成

• 配置ContextLoaderListener监听器
• 使用WebApplicationContextUtils获得应用上下文

1.1.1 导入Spring集成web的坐标

<dependency> 
    <groupId>org.springframeworkgroupId> 
    <artifactId>spring-webartifactId> 
    <version>5.0.5.RELEASEversion>
dependency>

1.1.2 Spring提供获取应用上下文的工具

在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标） – 1.1.1

使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

• web.xml

<context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext.xmlparam-value>
context-param>

<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    listener-class>
listener>

• 通过工具获得应用上下文对象 在 servlet层代码中

ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
Object obj = applicationContext.getBean("id");

1.2 MVC简介

• SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于SpringFrameWork 的后续产品，已经融合在 Spring Web Flow 中。

• SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。

• Spring MVC开发步骤
  • 导入SpringMVC相关坐标
  • 配置SpringMVC核心控制器DispathcerServlet
  • 创建Controller类和视图页面
  • 使用注解配置Controller类中业务方法的映射地址
  • 配置SpringMVC核心文件 spring-mvc.xml
  • 客户端发起请求测试

1.2.1 导入Spring和SpringMVC的坐标

<dependencies>
    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.11version>
      <scope>testscope>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webartifactId>
      <version>5.0.5.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.0.5.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>5.0.5.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>servlet-apiartifactId>
      <version>2.5version>
    dependency>
    
    <dependency>
      <groupId>javax.servlet.jspgroupId>
      <artifactId>jsp-apiartifactId>
      <version>2.0version>
    dependency>

    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.32version>
    dependency>
    <dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.10version>
    dependency>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>5.2.10.RELEASEversion>
      <scope>testscope>
    dependency>
    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatis-springartifactId>
      <version>1.3.2version>
    dependency>
  dependencies>

1.2.2 配置SpringMVC核心控制器DispathcerServlet

DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<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">
    <display-name>Archetype Created Web Applicationdisplay-name>

    
    <servlet>
        <servlet-name>DispatcherServletservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:spring-mvc.xmlparam-value>
        init-param>
        <load-on-startup>1load-on-startup>  
    servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServletservlet-name>
        <url-pattern>/url-pattern>  
    servlet-mapping>

    
    <context-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:applicationContext.xmlparam-value>
    context-param>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    listener>
web-app>

1.2.3 创建Controller和业务方法 并 创建视图页面index.jsp

package com.web.servlet;

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

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.web.servlet.UserController
 * @Date: 2022年05月27日 14:35
 * @Description: web层
 */

@Controller  // 放到容器中
public class UserController {

    @RequestMapping("/quick")  // 设置路由
    public String save() {
        System.out.println("Controller save running...");
        return "success.jsp";  // 跳转路由
    }
}

1.2.4 配置注解

• 1.2.3

1.2.5 创建spring-mvc.xml

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

    
    <context:component-scan base-package="com.web"/>
beans>

1.2.6 访问测试地址

1.3 MVC组件解析

1.3.1 SpringMVC的执行流程

1、用户发送请求至前端控制器DispatcherServlet(前端控制器)。

2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、DispatcherServlet调用HandlerAdapter(处理器映射器)处理器适配器。

5、HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。

6、Controller执行完成返回ModelAndView。

7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

9、ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户。

1.3.2 SpringMVC组件解析

1. 前端控制器：DispatcherServlet

用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性。

2. 处理器映射器：HandlerMapping

HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3. 处理器适配器：HandlerAdapter

通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

4. 处理器：Handler

它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由Handler 对具体的用户请求进行处理。

5. 视图解析器：View Resolver

View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

6. 视图：View

SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面.

1.3.3 SpringMVC注解解析

• 原始注解

• 新注解

注解	说明
@Configuration	用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定Spring在初始化容器时要扫描的包。作用和在 Spring 的 xml 配置文件中的一样
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource	用于加载.properties 文件中的配置
@Import	用于导入其他配置类

• Spring MVC注解

@RequestMapping

作用：用于建立请求 URL 和处理请求方法之间的对应关系,设置路由

位置：

• 类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录

• 方法上，请求 URL 的第二级访问目录，与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径

属性：

• value：用于指定请求的URL。它和path属性的作用是一样的(设置路由)

• method：用于指定请求的方式(RequestMethed.POST/GET)

• params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样

例如：

• params = {“accountName”}，表示请求参数必须有accountName

• params = {“moeny!100”}，表示请求参数中money不能是100

1. mvc命名空间引入

命名空间：xmlns:context=“http://www.springframework.org/schema/context”

​ xmlns:mvc=“http://www.springframework.org/schema/mvc”

约束地址：http://www.springframework.org/schema/context

​ http://www.springframework.org/schema/context/spring-context.xsd

​ http://www.springframework.org/schema/mvc

​ http://www.springframework.org/schema/mvc/spring-mvc.xsd

2. 组件扫描

SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使

用@Controller注解标注的话，就需要使用<context:component-scan base-package=“com.itheima.controller"/>进行组件扫描。

1.3.4 SpringMVC的XML配置解析

SpringMVC有默认组件配置，默认组件都是DispatcherServlet.properties配置文件中配置的，该配置文件地址org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器1.3.5 知识总结

 	
	
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/">property>  
        <property name="suffix" value=".jsp">property>
    bean>

@Controller  // 放到容器中
@RequestMapping("/user")
public class UserController {

    @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username"})  // 设置路由
    public String save() {
        System.out.println("Controller save running...");
        return "success";
    }
}  // 访问 http:localhost/user/quick?username=xxx  ==>  访问的是 /jsp/success.jsp 文件

二、Spring MVC数据响应

2.1 Spring MVC的数据响应

2.1.1 SpringMVC的数据响应方式

2.1.1.1 页面跳转

• 直接返回字符串

  • 此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转。

  •  	
      	
        <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/jsp/">property>  
            <property name="suffix" value=".jsp">property>
        bean>
    

  • @Controller  // 放到容器中
    @RequestMapping("/user")
    public class UserController {
    
        @RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"username"})  // 设置路由
        public String save() {
            System.out.println("Controller save running...");
            return "success";
        }
    }  // 访问 http:localhost/user/quick?username=xxx  ==>  访问的是 /jsp/success.jsp 文件
    

• 通过ModelAndView对象返回

  • 第一种

    • <%@ page contentType="text/html;charset=UTF-8" language="java" %>
      <%@ page language="java" pageEncoding="utf-8" isELIgnored="false" %>
      <html>
      <head>
          <title>Titletitle>
      head>
      <body>
      <h1> success ${username} h1>
      body>
      html>
      

    •     @RequestMapping(value = "/quick2")  // 设置路由
          public ModelAndView save2() {
              /**
               * model ：模型 用于封装数据
               * view ：视图 用于展示数据
               */
              ModelAndView Mv = new ModelAndView();
              // 设置模型数据
              Mv.addObject("username", "laity");
              // 设置视图
              Mv.setViewName("success");
              return Mv;
          }
      

  • 第二种

    •     /**
           * spring mvc 可以 注入ModelAndView
           *
           * @param Mv
           * @return
           */
          @RequestMapping(value = "/quick3")  // 设置路由
          public ModelAndView save3(ModelAndView Mv) {
              Mv.addObject("username", "Jge");
              Mv.setViewName("success");
              return Mv;
          }
      

    •     @RequestMapping(value = "/quick4")  // 设置路由
          public String save4(Model model) {
              model.addAttribute("username", "呼啦啦");
              return "success";
          }
      

    •     @RequestMapping(value = "/quick5")  // 设置路由
          public String save5(Model model, HttpServletRequest request, HttpServletResponse response) {
              request.setAttribute("username", "quick5");
              return "success";  // 访问 http://localhost/user/quick5 一样返回数据
          }
      

2.1.1.2 回写数据

• 直接返回字符串

  • Web基础阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使用response.getWriter().print(“hello world”) 即可。

  •     @RequestMapping(value = "/quick6")  // 设置路由
        public void save6(Model model, HttpServletRequest request, HttpServletResponse response) throws Exception {
            response.getWriter().print("hello world");
        }  // 访问 http://localhost/user/quick6  页面展示 hello world
    

  • 那么Controller中怎样向request域中存储数据呢？

    将需要回写的字符串直接返回，但此时需要通过**@ResponseBody**注解告知SpringMVC框架，方法返回的字符串不是跳转是直接在http响应体中返回。

  •     @RequestMapping(value = "/quick7")  // 设置路由
        @ResponseBody  // 告诉mvc框架该方法不进行视图跳转
        public String save7() {
            return "hello world";
        }
    

  • 开发中往往要将复杂的java对象转换成json格式的字符串，我们可以使用web阶段学习过的json转换工具jackson进行转换，导入jackson坐标

  •  
    <dependency> 
        <groupId>com.fasterxml.jackson.coregroupId> 
        <artifactId>jackson-coreartifactId> 
        <version>2.9.0version>
    dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.coregroupId>
        <artifactId>jackson-databindartifactId>
        <version>2.9.0version>
    dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.coregroupId>
        <artifactId>jackson-annotationsartifactId>
        <version>2.9.0version>
    dependency>
    

  •     @RequestMapping(value = "/quick8")
        @ResponseBody
        public String save8() throws Exception {
            User user = new User();
            user.setName("laity");
            user.setAge(18);
            ObjectMapper objectMapper = new ObjectMapper();
            String json = objectMapper.writeValueAsString(user);
            return json;
        }
    

• 返回对象或集合

  • 通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写，为处理器适配器配置消息转换参数，指定使用jackson进行对象或集合的转换，因此需要在spring-mvc.xml中进行配置：

  • 	
        
        <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
            <property name="messageConverters">
                <list>
                    <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                    bean>
                list>
            property>
        bean>
    

  •     /**
         * 期望SpringMVC自动将User转换成json格式的字符串
         *
         * @return
         * @throws Exception
         */
        @RequestMapping(value = "/quick9")
        @ResponseBody
        public User save9() throws Exception {
            User user = new User();
            user.setName("laity");
            user.setAge(18);
            return user;
        }
    

  • 在方法上添加**@ResponseBody**就可以返回json格式的字符串，但是这样配置比较麻烦，配置的代码比较多，因此，我们可以使用mvc的注解驱动代替上述配置。 – 配置注解驱动

  • 
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           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
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        
        <context:component-scan base-package="com.web"/>
    
        
        <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/jsp/">property>
            <property name="suffix" value=".jsp">property>
        bean>
    
        
        
        
        
        
        
        
        
        
        
    
        
        <mvc:annotation-driven/>
    beans>
    

2.2 SpringMVC获得请求数据

2.2.1 获得请求参数

• 基本类型参数
• POJO类型参数
• 数组类型参数
• 集合类型参数

2.2.1.1 获得基本类型参数

Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配。

    /*
     * 获取请求参数
     * */
    @RequestMapping(value = "/quick10")
    @ResponseBody
    public void save10(String username, int age) throws Exception {
        System.out.println(username);
        System.out.println(age);
        // http://localhost/user/quick10?username=laity&age=18
    }

2.2.1.2 获得POJO类型参数

Controller中的业务方法的POJO参数的属性名与请求参数的name一致，参数值会自动映射匹配。

    /*
     * 获取请求参数 POJO类型
     * */
    @RequestMapping(value = "/quick11")
    @ResponseBody
    public void save11(User user) throws Exception {
        System.out.println(user);  // User{name='laity', age=18}
        // http://localhost/user/quick11?name=laity&age=18
    }

2.2.1.3 获得数组类型参数

Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配。

    /*
     * 获取请求参数 数组类型
     * */
    @RequestMapping(value = "/quick12")
    @ResponseBody
    public void save12(String[] strs) throws Exception {
        System.out.println(Arrays.toString(strs));  // [laity, aaa, bbb]
        // http://localhost/user/quick12?strs=laity&strs=aaa&strs=bbb
    }

2.2.1.4 获得集合类型参数

获得集合参数时，要将集合参数包装到一个POJO中才可以。

…

当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装。

    /*
     * 获取请求参数 数组类型
     * */
    @RequestMapping(value = "/quick14")
    @ResponseBody
    public void save14(@RequestBody List<User> userList) throws Exception {
        System.out.println(userList);  // [User{name='laity', age=18}, User{name='zhangsan', age=20}]
        // 访问 http://localhost/jsp/ajax.jsp
    }

2.2.1.5 静态资源的访问开启

spring-mvc.xml

    
    
    
    
    <mvc:default-servlet-handler/>

2.2.2 请求数据乱码问题

当post请求时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤。 – web.xml

    
    <filter>
        <filter-name>CharacterEncodingFilterfilter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
        <init-param>
            <param-name>encodingparam-name>
            <param-value>UTF-8param-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>

2.2.3 参数绑定注解@requestParam

当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定。

value：与请求参数名称

required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错

defaultValue：当没有指定请求参数时，则使用指定的默认值赋值

    @RequestMapping(value = "/quick15")
    @ResponseBody
    public void save15(@RequestParam(value = "name", required = false, defaultValue = "小帅") String username) throws Exception {
        System.out.println(username);
        // http://localhost/user/quick15?name=laity
    }

2.2.8 获得Restful风格的参数

Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。

Restful风格的请求是使用**“url+请求方式”**表示一次请求目的的，HTTP 协议里面四个表示操作方式的动词如下： – 增删改查

GET：用于获取资源

POST：用于新建资源

PUT：用于更新资源

DELETE：用于删除资源

在SpringMVC中可以使用占位符进行参数绑定。地址/user/1可以写成/user/{id}，占位符{id}对应的就是1的值。在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作。

    /**
     * required:指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
     *
     * @param username
     * @throws Exception
     */
    @RequestMapping(value = "/quick16/{name}", method = RequestMethod.GET)  // {name} 占位
    @ResponseBody
    public void save16(@PathVariable(value = "name", required = false) String username) throws Exception {
        System.out.println(username);
        // http://localhost/user/quick16/laity
    }

2.2.9 自定义类型转换器

SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置.

但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。

自定义类型转换器的开发步骤：

• 定义转换器类实现Converter接口

package com.converter;

import org.springframework.core.convert.converter.Converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.converter.DateConverter
 * @Date: 2022年05月28日 18:37
 * @Description: 自定义日期转化器
 */
public class DateConverter implements Converter<String, Date> {

    @Override
    public Date convert(String s) {
        // 将日期字符串 转换成 日期对象
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

• 在配置文件中声明转换器 – spring-xml

    
    <bean id="converterService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.converter.DateConverter">bean>
            list>
        property>
    bean>

• 在中引用转换器

    
    
    
    <mvc:annotation-driven conversion-service="converterService"/>

• 测试代码

    /**
     * 自定义日期转换器 DateConverter
     *
     * @param date
     * @throws Exception
     */
    @RequestMapping(value = "/quick17", method = RequestMethod.GET)  // {name} 占位
    @ResponseBody
    public void save17(Date date) throws Exception {
        System.out.println(date);  // Sat May 28 00:00:00 CST 2022
        // http://localhost/user/quick17?date=2022/5/28  -- 增加了日期转换器后，你的日期就要按你写的规则来写，否则直接报错
        // http://localhost/user/quick17?date=2022-5-28  -- Sat May 28 00:00:00 CST 2022
    }

2.2.10 获得Servlet相关API

SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象有：

HttpServletRequest

HttpServletResponse

HttpSession

2.2.11 获得请求头

使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name)

@RequestHeader注解的属性如下：

value：请求头的名称

required：是否必须携带此请求头

    @RequestMapping(value = "/quick18", method = RequestMethod.GET)  // {name} 占位
    @ResponseBody
    public void save18(@RequestHeader(value = "user-agent", required = false) String headerValue) throws Exception {
        System.out.println(headerValue);
        // Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.67 Safari/537.36
    }

@CookieValue

使用@CookieValue可以获得指定Cookie的值 @CookieValue注解的属性如下：

value：指定cookie的名称

required：是否必须携带此cookie

    /**
     * 请求 Cookie 值
     *
     * @param CookieValue
     * @throws Exception
     */
    @RequestMapping(value = "/quick19", method = RequestMethod.GET)  // {name} 占位
    @ResponseBody
    public void save19(@CookieValue(value = "JSESSIONID", required = false) String CookieValue) throws Exception {
        System.out.println(CookieValue);  // 11DF4DBD0D5FDD53334D5FB20D5025B1
    }

2.2.12 文件上传

文件上传客户端三要素

• 表单项type=“file”

• 表单的提交方式是post

• 表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data”

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件上传title>
head>
<body>
<form action="${pageContext.request.contextPath}/user/quick20" method="post" enctype="multipart/form-data">
    名称：<input type="text" name="name"><br>
    文件：<input type="file" name="file"><br>
    <input type="submit" value="提交"><br>
    <%----%>

form>
body>
html>

2.2.13 单文件上传步骤

① 导入fileupload和io坐标

② 配置文件上传解析器

③ 编写文件上传代码

2.2.14 单文件上传实现

• 导入fileupload和io坐标

        
        <dependency>
            <groupId>commons-fileuploadgroupId>
            <artifactId>commons-fileuploadartifactId>
            <version>1.2.2version>
        dependency>
        <dependency>
            <groupId>commons-iogroupId>
            <artifactId>commons-ioartifactId>
            <version>2.4version>
        dependency>

• 配置文件上传解析器 – springmvc.xml

    
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        
        <property name="maxUploadSize" value="5242800"/>
        
        <property name="maxUploadSizePerFile" value="5242800"/>
        
        <property name="defaultEncoding" value="UTF-8"/>
    bean>

• 编写文件上传代码

    /**
     * 单文件上传
     *
     * @param
     * @throws Exception
     */
    @RequestMapping(value = "/quick20", method = RequestMethod.POST)  // {name} 占位
    @ResponseBody
    public void save20(String name, MultipartFile file) throws Exception {
        System.out.println(name + ":" + file);
        String filename = file.getOriginalFilename();
        file.transferTo(new File("D:\\WorkSpace\\SpringStudy\\Spring-mvc\\src\\main\\webapp\\file\\" + filename));
    }

2.2.15 多文件上传实现

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page language="java" pageEncoding="utf-8" isELIgnored="false" %>
<html>
<head>
    <title>多文件上传title>
head>
<body>
<h1>多文件上传测试h1>
<form action="${pageContext.request.contextPath}/user/quick21" method="post" enctype="multipart/form-data">
    名称：<input type="text" name="name"><br>
    文件1：<input type="file" name="uploadFiles"><br>
    文件2：<input type="file" name="uploadFiles"><br>
    文件3：<input type="file" name="uploadFiles"><br>
    <input type="submit" value="提交"><br>
form>
body>
html>

    /**
     * 多文件上传
     *
     * @param
     * @throws Exception
     */
    @RequestMapping(value = "/quick21", method = RequestMethod.POST)  // {name} 占位
    @ResponseBody
    public void save21(String name, MultipartFile[] uploadFiles) throws Exception {
        for (MultipartFile uploadFile : uploadFiles) {
            System.out.println(name + ":" + uploadFiles);
            String filename = uploadFile.getOriginalFilename();
            uploadFile.transferTo(new File("D:\\WorkSpace\\SpringStudy\\Spring-mvc\\src\\main\\webapp\\file\\" + filename));
        }
    }

三、Spring JDBC Template

1.1 JdbcTemplate概述

它是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。

1.2 JdbcTemplate开发步骤

① 导入spring-jdbc和spring-tx坐标

② 创建数据库表和实体

③ 创建JdbcTemplate对象

④ 执行数据库操作

1.3 JdbcTemplate快速入门

1.3.1 导入spring-jdbc和spring-tx坐标

    <dependencies>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webartifactId>
            <version>5.0.5.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.0.5.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.0.5.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>servlet-apiartifactId>
            <version>2.5version>
        dependency>
        
        <dependency>
            <groupId>javax.servlet.jspgroupId>
            <artifactId>jsp-apiartifactId>
            <version>2.0version>
        dependency>

        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.32version>
        dependency>
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>1.1.10version>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-testartifactId>
            <version>5.0.5.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatis-springartifactId>
            <version>1.3.2version>
        dependency>
        
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-coreartifactId>
            <version>2.9.0version>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-databindartifactId>
            <version>2.9.0version>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-annotationsartifactId>
            <version>2.9.0version>
        dependency>

        
        <dependency>
            <groupId>commons-fileuploadgroupId>
            <artifactId>commons-fileuploadartifactId>
            <version>1.2.2version>
        dependency>
        <dependency>
            <groupId>commons-iogroupId>
            <artifactId>commons-ioartifactId>
            <version>2.4version>
        dependency>

        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-jdbcartifactId>
            <version>5.0.5.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-txartifactId>
            <version>5.0.5.RELEASEversion>
        dependency>
    dependencies>

1.3.2 创建accout表和Accout实体

略

1.3.3 创建JdbcTemplate对象

package com.domain;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.domain.Account
 * @Date: 2022年05月29日 17:19
 * @Description:
 */
public class Account {
    private String name;
    private Double money;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

1.3.4 执行数据库操作

package com.test;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.test.accountTest
 * @Date: 2022年05月29日 17:26
 * @Description: account测试
 */
public class accountTest {
    /**
     * 测试JDBC模板的开发步骤
     */
    @org.junit.Test
    public void test1() {
        // 创建一个数据源对象
        DruidDataSource druid = new DruidDataSource();
        druid.setDriverClassName("com.mysql.jdbc.Driver");
        druid.setUrl("jdbc:mysql:///java");
        druid.setUsername("root");
        druid.setPassword("wang9264");
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        // 设置数据源对象，知道数据库在哪
        jdbcTemplate.setDataSource(druid);
        // 执行操作
        int row = jdbcTemplate.update("insert into account values(?,?)", "laity101", "2000");
        System.out.println(row);
    }
}

1.4 Spring产生JdbcTemplate对象

我们可以将JdbcTemplate的创建权交给Spring，将数据源DataSource的创建权也交给Spring，在Spring容器内部将数据源DataSource注入到JdbcTemplate模版对象中，配置如下：

• 创建JDBCTemplate对象，依赖于DataSource
• 调用JdbcTemplate的方法来完成CRUD操作
  • update()：执行DML语句，增删改操作
  • queryForMap()：查询结果将结果集封装为map集合
  • queryForList()：查询结果将结果封装为list集合
  • query()：查询结果，将结果封装成JavaBean对象
  • queryForObject()：查询结果，将结果封装成对象。

    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="DriverClassName" value="com.mysql.jdbc.Driver">property>
        <property name="Url" value="jdbc:mysql:///java">property>
        <property name="Username" value="root">property>
        <property name="Password" value="wang9264">property>
    bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">property>
    bean>

• 从容器中获得JdbcTemplate进行添加操作

    /**
     * 测试 spring产生jdbcTemplate对象
     */
    @Test
    public void test2() {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        JdbcTemplate jdbcTemplate = app.getBean(JdbcTemplate.class);
        int row = jdbcTemplate.update("insert into account values(?,?)", "laity102", "4000");
        System.out.println(row);
    }

• 修改操作

    /**
     * 修改 操作
     */
    @Test
    public void test3() {
        int row = jdbcTemplate.update("update account set money=? where name=?", 4444, "laity102");
        System.out.println(row);
    }

• 删除和查询全部操作

    /**
     * 删除
     */
    @Test
    public void test4() {
        int row = jdbcTemplate.update("delete from account where name=?", "laity103");
        System.out.println(row);
    }
    /**
     * 查询全部
     */
    @Test
    public void test5() {
        List<Map<String, Object>> allList = jdbcTemplate.queryForList("select * from account");
        for (Map<String, Object> stringObjectMap : allList) {
            System.out.println(stringObjectMap);
        }
    }

• 查询单个数据操作操作

    /**
     * 查询单一
     */
    @Test
    public void test6() {
        Scanner sc = new Scanner(System.in);
        String name = "laity102";
        Account account = jdbcTemplate.queryForObject("select * from account where name=?", new BeanPropertyRowMapper<Account>(Account.class), name);
        System.out.println(account);
    }

• 聚合查询

    /**
     * 聚合查询
     */
    @Test
    public void test7() {
        String name = "laity102";
        Long aLong = jdbcTemplate.queryForObject("select count(*) from account", Long.class);
        System.out.println(aLong);
    }

四、Spirng MVC拦截器

4.1 拦截器（interceptor）的作用

Spring MVC 的拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。

将拦截器按一定的顺序联结成一条链，这条链称为拦截器链（Interceptor Chain）。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

4.2 拦截器和过滤器区别

4.3 拦截器的快速入门

自定义拦截器很简单，只有如下三步：

① 创建拦截器类实现HandlerInterceptor接口

② 配置拦截器

③ 测试拦截器的拦截效果

4.3.1 创建拦截器类实现HandlerInterceptor接口

package com.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.interceptor.MyInterceptor1
 * @Date: 2022年05月30日 20:24
 * @Description: 拦截器
 */
public class MyInterceptor1 implements HandlerInterceptor {

    // 该方法在目标方法 执行之前
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        System.out.println("preHandler");
        return false; // true表示放行 ，false表示不放行
    }

    // 该方法在目标方法执行之后，视图对象返回之前执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        System.out.println("postHandler");
    }

    // 该方法在 整个流程执行完毕后，执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        System.out.println("afterHandler");
    }
}

4.3.2 配置拦截器 – spring-mvc.xml

    
    <mvc:interceptors>
        <mvc:interceptor>
            
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor1"/>
        mvc:interceptor>
    mvc:interceptors>

4.3.3 测试拦截器的拦截效果（编写目标方法）

    @RequestMapping(value = "/quick2")  // 设置路由
    public ModelAndView save2() {
        /**
         * model ：模型 用于封装数据
         * view ：视图 用于展示数据
         */
        System.out.println("目标资源执行");
        ModelAndView Mv = new ModelAndView();
        // 设置模型数据
        Mv.addObject("username", "laity");
        // 设置视图
        Mv.setViewName("success");
        return Mv;
    }

4.4 多拦截器操作

创建多个 拦截器实现类，再配置spring-mvc.xml

    
    <mvc:interceptors>
        <mvc:interceptor>
            
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor1"/>
        mvc:interceptor>
        <mvc:interceptor>
            
            <mvc:mapping path="/**"/>
            <bean class="com.interceptor.MyInterceptor2"/>
        mvc:interceptor>
    mvc:interceptors>

执行顺序 – 和配置文件的顺序有关

• 1pre
• 2pre
• 方法
• 2post
• 1post
• 2after
• 1after

4.5 拦截器方法说明

方法名	说明
preHandle()	方法将在请求处理之前进行调用，该方法的返回值是布尔值Boolean类型的，当它返回为false 时，表示请求结束，后续的Interceptor 和Controller 都不会再执行；当返回值为true 时就会继续调用下一个Interceptor 的preHandle 方法
postHandle()	该方法是在当前请求进行处理之后被调用，前提是preHandle 方法的返回值为true 时才能被调用，且它会在DispatcherServlet 进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller 处理之后的ModelAndView 对象进行操作
afterCompletion()	该方法将在整个请求结束之后，也就是在DispatcherServlet 渲染了对应的视图之后执行，前提是preHandle 方法的返回值为true 时才能被调用

4.6 案例

需求：用户没有登录的情况下，不能对后台菜单进行访问操作，点击菜单跳转到登录页面，只有用户登录成功后才能进行后台功能的操作

package interceptor;

import domain.User;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: interceptor.privilegeInterceptor
 * @Date: 2022年05月30日 21:19
 * @Description:
 */
public class privilegeInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 逻辑：判断用户是否登录  -- session有没有user
        HttpSession session = request.getSession();
        User user = (User) session.getAttribute("user");
        if (user == null) {
            // 没有登录
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return false;
        }
        // 放行==访问目标资源
        return true;
    }
}

五、Spring MVC异常处理机制

5.1 异常处理的思路

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试等手段减少运行时异常的发生。

系统的Dao、Service、Controller出现都通过throws Exception向上抛出，最后由SpringMVC前端控制器交由异常处理器进行异常处理

5.2 异常处理两种方式

• 使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver

• 实现Spring的异常处理接口HandlerExceptionResolver 自定义自己的异常处理器

5.3 简单异常处理器SimpleMappingExceptionResolver

SpringMVC已经定义好了该类型转换器，在使用时可以根据项目情况进行相应异常与视图的映射配置

    
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="defaultErrorView" value="error"/>
        <property name="exceptionMappings">
            <map>
                <entry key="java.lang.ClassCastException" value="error页面"/>
            map>
        property>
    bean>

5.4 自定义异常处理步骤

① 创建异常处理器类实现HandlerExceptionResolver

② 配置异常处理器

③ 编写异常页面

④ 测试异常跳转

5.4.1 创建异常处理器类实现HandlerExceptionResolver

package com.resolver;

import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: com.resolver.MyExceptionResolver
 * @Date: 2022年05月30日 22:29
 * @Description:
 */
public class MyExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        //处理异常的代码实现
        //创建ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("exceptionPage");
        return modelAndView;
    }
}

5.4.2 配置异常处理器

<bean id="exceptionResolver" class="异常处理类"/>

5.4.3 编写异常页面

。。。