第六章：SpringMVC上

6.1：SpringMVC简介

1. 什么是MVC

   MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分。

   • M：Model，模型层，指工程中的JavaBean，作用是处理数据。

     一类称为实体类Bean，专门存储业务数据的。一类称为业务处理Bean，专门用于处理业务逻辑和数据访问。

   • V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据。

   • C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器。

   MVCC的工作流程：

   ​ 用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器。

2. 什么是SpringMVC

   ​ SpringMVC是Spring的一个后续产品，是Spring的一个子项目。SpringMVC是Spring为表述层开发提供的一整套完备的解决方案。在表述层框架历经Strust、WebWork、Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC作为JavaEE项目表述层开发的首选方案。

3. SpringMVC的特点

   • Spring家族原生产品，与IOC容器等基础设施无缝衔接。
   • 基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理。
   • 表述层各细分领域要解决的问题全方位覆盖，提供全面解决方案。
   • 代码清新简洁，大幅度提升开发效率。
   • 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可。
   • 性能卓著，尤其适合现代大型、超大型互联网项目要求。

6.2：入门案例

1. 创建maven工程

   创建一个新的模块，spring_mvc_helloworld_13。

   • 添加web模块

     <packaging>war</packaging>
     

     点击旁边的+号，添加一个web.xml的路径。
     

   • 引入依赖

     <dependencies>
         <!-- SpringMVC -->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>5.3.1</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>
         <!-- Spring5和Thymeleaf整合包 -->
         <dependency>
             <groupId>org.thymeleaf</groupId>
             <artifactId>thymeleaf-spring5</artifactId>
             <version>3.0.12.RELEASE</version>
         </dependency>
     </dependencies>
     

2. 配置web.xml

   <!-- 
   	配置SpringMVC的前端控制器DispatcherServlet 
   	url-pattern中/和/*的区别：
   		/: 匹配浏览器向服务器发送的所有请求(不包括.jsp)
   		/*: 匹配浏览器向服务器发送的所有请求(包括.jsp)
   -->
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
   </servlet>
   
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>
   

3. 创建请求控制器

   ​ 由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器。请求控制器中每一个处理请求的方法成为控制器方法。

   ​ 因为SpringMVC的控制器由一个POJO(普通的Java类)担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring组件的IOC容器管理，此时SpringMVC才能够识别控制器的存在。

   package com.wang.controller;
   
   @Controller
   public class HelloController {
   }
   

4. 创建SpringMVC的配置文件

   <!--
   	SpringMVC的配置文件默认的位置和名称：
   		位置: WEB-INF下
   		名称：<servlet-name>-servlet.xml, 当前配置下的配置文件名为SpringMVC-servlet.xml。
   -->
   <!-- 扫描控制层组件 -->
   <context:component-scan base-package="com.wang.controller"></context:component-scan>
   
   <!-- 配置Thymeleaf视图解析器 -->
   <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>
   

5. 配置tomcat
   
   

6. 测试HelloWorld

   • 实现对首页的访问

     // 在请求控制器中创建处理请求的方法
     @RequestMapping("/")
     public String protal() {
         // 将逻辑视图返回
         return "index";
     }
     

   • 通过超链接跳到执行页面

     在WEB-INF/templates/index.html和success.html

     <!DOCTYPE html>
     <html lang="en" xmlns:th="http://www.thymeleaf.org">
         <head>
             <meta charset="UTF-8">
             <title>首页</title>
         </head>
         <body>
             <h1>index.html</h1>
         </body>
     </html>
     

     <!DOCTYPE html>
     <html lang="en" xmlns:th="http://www.thymeleaf.org">
         <head>
             <meta charset="UTF-8">
             <title>成功</title>
         </head>
         <body>
         	<h1>success.html</h1>
         </body>
     </html>
     

7. 扩展配置：在web.xml添加如下配置

   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!-- 设置SpringMVC配置文件的位置和名称, 这样就可以把springmvc.xml放在resources文件夹下 -->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc.xml</param-value>
       </init-param>
       <!-- 将DispatcherServlet的初始化时间提前到服务器启动时 -->
       <load-on-startup>1</load-on-startup>
   </servlet>
   
   <servlet-mapping>
       <servlet-name>SpringMVC</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>
   

8. 总结

   ​ 浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapper注解的value属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应的页面。

6.3：@RequestMapping注解

创建一个新的模块，spring_mvc_demo_14，复用spring_mvc_helloworld_13的依赖、web.xml、springmvc.xml配置文件、html页面。

1. @RequestMapping注解的功能

   ​ 从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理的控制器方法关联起来，建立映射关系。SpringMVC接收到指定的请求，就会来找到映射关系中对应的控制器方法来处理这个请求。

2. @RequestMapping注解的位置

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

   package com.wang.controller;
   
   @Controller
   @RequestMapping("/test")
   public class TestRequestMappingController {
       // 此时请求映射所映射的请求的请求路径为：/test/hello
       @RequestMapping("/hello")
       public String hello() {
           return "success";
       }
   }
   

3. @RequestMapping注解的value属性

   ​ @RequestMapping注解的value属性通过请求的请求路径匹配请求映射，value属性是一个字符串类型的数组，即当前浏览器所发送的请求路径匹配value属性中的任何一个值，则当前请求就会被注解所标识的方法进行处理，@RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射。

   @RequestMapping({"/hello", "/abc"})
   public String hello() {
       return "success";
   }
   

4. @RequestMapping注解的method属性

   ​ @RequestMapping注解的method属性通过请求的请求方式匹配请求映射，method属性是RequestMethod类型的数组，即当前浏览器所发送请求的请求方法匹配method属性中的任何一种请求方式，则当前请求就会被注解所标识的方法进行处理。

   ​ 若浏览器所发送的请求的请求路径和@RequestMapping注解value属性匹配，但是请求方式不匹配，此时页面报错：405 - Request method 'xxx' not supported。

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

   在@RequestMapping的基础上，结合请求方式的一些派生注解：@GetMapping、@PostMapping、@DeleteMapping、PutMapping。

5. @RequestMapping注解的params属性

   ​ @RequestMapping注解的params属性通过请求的请求参数匹配请求映射，params属性是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系。

   • "param"：要求请求映射所匹配的请求必须携带param请求参数。
   • "!param"：要求请求映射所匹配的请求必须不能携带param请求参数。
   • "param=value"：要求请求映射所匹配的请求必须携带param请求参数且param=value。
   • param!=value：要求请求映射所匹配的请求必须携带param请求参数但是param!=value。

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

   ​ 若浏览器所发送的请求的请求路径和@RequestMapping注解value属性匹配，但是请求参数不匹配，此时页面报错：400 - Parameter conditions "username" not met for actual request parameters:。

6. @RequestMapping注解的headers属性

   ​ @RequestMapping注解的headers属性通过请求的请求头匹配请求映射，headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头和请求映射的匹配关系【匹配规则与params很相近】。

   ​ 若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面显示404错误，即资源未找到。

   @RequestMapping(
       value = {"/hello", "/abc"},
       method = {RequestMethod.POST, RequestMethod.GET},
       headers = {"referer"}
   )
   public String hello() {
       return "success";
   }
   

7. SpingMVC支持ant风格的路径

   在@RequestMapping注解的value属性值中设置一些特殊字符。

   • ?：表示任意的单个字符(不包括?)。
   • *：表示任意个数的任意字符(不包括?和/)。
   • **：表示任意层数的任意目录，注意使用方式只能/**/，前后不能有任何的其他字符。

8. SpringMVC支持路径中的占位符

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

   <a th:href="@{/test/rest/admin/1}">测试@RequestMapping注解的value属性中的占位符</a><br>
   

   @RequestMapping("/test/rest/{username}/{id}")
   public String testRest(@PathVariable("id") Integer id, @PathVariable("username") String username) {
       System.out.println("id: " + id + ", username: " + username);
       return "success";
   }
   

6.4：SpringMVC获取请求参数

1. 通过ServletAPI获取

   ​ 将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象。

   package com.wang.controller;
   
   @Controller
   public class TestParamController {
       @RequestMapping("/param/servletAPI")
       public String getParamByServletAPI(HttpServletRequest request) {
           String username = request.getParameter("username");
           String password = request.getParameter("password");
           System.out.println("username: " + username + ", password: " + password);
           return "success";
       }
   }
   

2. 通过控制器方法的形参获取请求参数

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

   <form th:action="@{/param}" method="post">
       用户名: <input type="text" name="username"><br>
       密码: <input type="password" name="password"><br>
       <input type="submit" value="登录"><br>
   </form>
   

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

   注意：

   ​ 若请求所传输的参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串数组或者字符串类型的形参接收此请求参数。若使用字符串数组类型的形参，此参数的数组中包含了每一个数组，若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果。

3. @RequestParam

   @RequestParam是将请求参数和控制器方法的形参创建映射关系，@RequestParam注解一个有三个属性：

   • value：指定为形参赋值的请求参数的参数名。

   • required：设置是否必须传输此请求参数，默认值为true。

     ​ 若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter 'xxx' is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null。

   • defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为""时，则使用默认值为形参赋值。

   // 将之前form表单的username属性该为userName
   @RequestMapping("/param")
   public String getParam(
       @RequestParam(value = "userName", required = false, defaultValue = "hello") String username, 
       String password
   ){
       System.out.println("username: " + username + ", password: " + password);
       return "success";
   }
   

4. @RequestHeader

   ​ @RequestHeader是将请求头信息和控制器方法的形参创建映射关系，@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam。

5. @CookieValue

   ​ @CookieValue是将请cookic数据和控制器方法的形参创建映射关系，@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam。

   // 在getParamByServletAPI方法添加下面代码，测试的时候先访问这个这个请求，在访问/param请求
   HttpSession session = request.getSession();
   

   @RequestMapping("/param")
   public String getParam(
       @RequestParam(value = "userName", required = false, defaultValue = "hello") String username,
       String password,
       @RequestHeader("referer") String referer,
       @CookieValue("JSESSIONID") String jsessionId
   ){
       System.out.println("referer: " + referer + ", jsessionId: " + jsessionId);
       System.out.println("username: " + username + ", password: " + password);
       return "success";
   }
   

6. 通过POJO获取请求参数

   需要在控制器方法的形参位置设置实体类型类型的参数，要保证实体类中的属性的属性名和请求参数的名字一致。

   package com.wang.pojo;
   
   public class User {
       private Integer id;
       private String username;
       private String password;
   
       // 如下省略空参构造、全参构造、get/set方法、toString方法
   }
   

   @RequestMapping("/param/pojo")
   public String getParamByPojo(User user) {
       System.out.println(user);
       return "success";
   }
   

7. 解决获取请求参数的乱码问题

   解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在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>
   

6.5：域对象共享数据

1. 使用ServletAPI向request域对象共享数据

   @RequestMapping("/test/servletAPI")
   public String getParamByServletAPI(HttpServletRequest request) {
       request.setAttribute("testServletAPI", "hello,servletAPI");
       return "success";
   }
   

2. 使用ModelAndView向request域对象共享数据

   ModelAndView包含Model和View的功能，Model向请求域中共享数据，View设置逻辑视图实现页面跳转。

   @RequestMapping("/test/mav")
   public ModelAndView testMAV() {
       ModelAndView mav = new ModelAndView();
       // 向请求域中共享数据
       mav.addObject("testRequestScope", "hello,ModelAndView");
       // 设置逻辑视图
       mav.setViewName("success");
       return mav;
   }
   

3. 使用Model向request域对象共享数据

   @RequestMapping("/test/model")
   public String testModel(Model model) {
       // org.springframework.validation.support.BindingAwareModelMap
       System.out.println(model.getClass().getName());
       model.addAttribute("testRequestScope", "hello, Model");
       return "success";
   }
   

4. 使用ModelMap向request域对象共享数据

   @RequestMapping("/test/modelMap")
   public String testModelMap(ModelMap modelMap) {
       // org.springframework.validation.support.BindingAwareModelMap
       System.out.println(modelMap.getClass().getName());
       modelMap.addAttribute("testRequestScope", "hello, ModelMap");
       return "success";
   }
   

5. 使用map向request域对象共享数据

   @RequestMapping("/test/map")
   public String testModelMap(Map<String, Object> map) {
       // org.springframework.validation.support.BindingAwareModelMap
       System.out.println(map.getClass().getName());
       map.put("testRequestScope", "hello, Map");
       return "success";
   }
   

6. Model、ModelMap、Map的关系

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

   public class BindingAwareModelMap extends ExtendedModelMap {}
   public class ExtendedModelMap extends ModelMap implements Model {}
   public class ModelMap extends LinkedHashMap<String, Object> {}
   public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> {}
   

7. 向Session域共享数据

   @RequestMapping("/test/session")
   public String testSession(HttpSession session) {
       session.setAttribute("testRequestScope", "hello, session");
       return "success";
   }
   

8. 向application域共享数据

   @RequestMapping("/test/application")
   public String testApplication(HttpSession session) {
       ServletContext servletContext = session.getServletContext();
       servletContext.setAttribute("testApplicationScope", "hello, application");
       return "success";
   }