一、SpringMVC简介 1、什么是MVC MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分
M：Model ，模型层 ，指工程中的JavaBean，作用是处理数据
JavaBean分为两类：
一类称为实体类Bean：专门存储业务数据的，如 Student、User 等
一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。
V：View ，视图层 ，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
C：Controller ，控制层 ，指工程中的servlet，作用是接收请求和响应浏览器
MVC的工作流程：
2、什么是SpringMVC SpringMVC是Spring的一个后续产品，是Spring的一个子项目
SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为 Java EE 项目表述层开发的首选方案 。
注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台servlet
3、SpringMVC的特点
Spring 家族原生产品 ，与 IOC 容器等基础设施无缝对接基于原生的Servlet ，通过了功能强大的前端控制器DispatcherServlet ，对请求和响应进行统一处理表述层各细分领域需要解决的问题全方位覆盖 ，提供全面解决方案
代码清新简洁 ，大幅度提升开发效率内部组件化程度高，可插拔式组件即插即用 ，想要什么功能配置相应组件即可
性能卓著 ，尤其适合现代大型、超大型互联网项目要求
二、HelloWorld 1、开发环境 IDE：idea 2021.2.3
构建工具：maven3.5.4
服务器：tomcat8.5
Spring版本：5.3.1
jdk版本：1.8
2、创建maven工程 a>添加web模块 b>打包方式：war c>引入依赖 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 <dependencies > <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 > <dependency > <groupId > javax.servlet</groupId > <artifactId > javax.servlet-api</artifactId > <version > 3.1.0</version > <scope > provided</scope > </dependency > <dependency > <groupId > org.thymeleaf</groupId > <artifactId > thymeleaf-spring5</artifactId > <version > 3.0.12.RELEASE</version > </dependency > </dependencies >
注：由于 Maven 的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠传递性导入。
3、配置web.xml 注册SpringMVC的前端控制器DispatcherServlet
a>默认配置方式 此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为<servlet-name>-servlet.xml，例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC-servlet.xml
1 2 3 4 5 6 7 8 9 10 11 12 13 14 <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 >
b>扩展配置方式 可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置SpringMVC前端控制器DispatcherServlet的初始化时间
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 <servlet > <servlet-name > springMVC</servlet-name > <servlet-class > org.springframework.web.servlet.DispatcherServlet</servlet-class > <init-param > <param-name > contextConfigLocation</param-name > <param-value > classpath:springMVC.xml</param-value > </init-param > <load-on-startup > 1</load-on-startup > </servlet > <servlet-mapping > <servlet-name > springMVC</servlet-name > <url-pattern > /</url-pattern > </servlet-mapping >
注：
标签中使用/和/*的区别：
/所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请求
因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面
/*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写法
4、创建请求控制器 由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器
请求控制器中每一个处理请求的方法成为控制器方法
因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在
1 2 3 4 @Controller public class HelloController { }
5、创建springMVC的配置文件 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 <context:component-scan base-package ="com.atguigu.mvc.controller" /> <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 /> <mvc:annotation-driven > <mvc:message-converters > <bean class ="org.springframework.http.converter.StringHttpMessageConverter" > <property name ="defaultCharset" value ="UTF-8" /> <property name ="supportedMediaTypes" > <list > <value > text/html</value > <value > application/json</value > </list > </property > </bean > </mvc:message-converters > </mvc:annotation-driven >
6、测试HelloWorld a>实现对首页的访问 在请求控制器中创建处理请求的方法
1 2 3 4 5 6 7 8 @RequestMapping("/") public String index () { return "index" ; }
b>通过超链接跳转到指定页面 在主页index.html中设置超链接
1 2 3 4 5 6 7 8 9 10 11 <!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 ="@{/target}" > HelloWorld</a > <br /> </body > </html >
在请求控制器中创建处理请求的方法
1 2 3 4 @RequestMapping("/target") public String HelloWorld () { return "target" ; }
7、总结 浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，将请求地址 和控制器中@RequestMapping注解的value属性值 进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应页面
三、@RequestMapping注解 1、@RequestMapping注解的功能 从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。
SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。
2、@RequestMapping注解的位置 @RequestMapping标识一个类：设置映射请求的请求路径的初始信息
@RequestMapping标识一个方法：设置映射请求请求路径的具体信息
1 2 3 4 5 6 7 8 9 10 11 @Controller @RequestMapping("/test") public class RequestMappingController { @RequestMapping("/testRequestMapping") public String testRequestMapping () { return "success" ; } }
3、@RequestMapping注解的value属性 @RequestMapping注解的value属性通过请求的请求地址匹配请求映射
@RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求
@RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射
1 2 <a th:href ="@{/testRequestMapping}" > 测试@RequestMapping的value属性-->/testRequestMapping</a > <br > <a th:href ="@{/test}" > 测试@RequestMapping的value属性-->/test</a > <br >
1 2 3 4 5 6 @RequestMapping( value = {"/testRequestMapping", "/test"} ) public String testRequestMapping () { return "success" ; }
4、@RequestMapping注解的method属性 @RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射
@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求
若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错405 ：Request method ‘POST’ not supported
1 2 3 4 <a th:href ="@{/test}" > 测试@RequestMapping的method属性-->GET</a > <br > <form th:action ="@{/test}" method ="post" > <input type ="submit" > </form >
1 2 3 4 5 6 7 @RequestMapping( value = {"/testRequestMapping", "/test"}, method = {RequestMethod.GET, RequestMethod.POST} ) public String testRequestMapping () { return "success" ; }
注：
1、对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解
处理get请求的映射–>@GetMapping
处理post请求的映射–>@PostMapping
处理put请求的映射–>@PutMapping
处理delete请求的映射–>@DeleteMapping
2、常用的请求方式有get（查），post（增），put（改），delete（删）
但是目前浏览器只支持get和post，若在form表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理
若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter，在RESTful部分会讲到
5、@RequestMapping注解的params属性（了解） @RequestMapping注解的params属性通过请求的请求参数匹配请求映射
@RequestMapping注解的params属性是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系
“param”：要求请求映射所匹配的请求必须携带param请求参数
“!param”：要求请求映射所匹配的请求必须不能携带param请求参数
“param=value”：要求请求映射所匹配的请求必须携带param请求参数且param=value
“param!=value”：要求请求映射所匹配的请求必须携带param请求参数但是param!=value
1 <a th:href ="@{/test(username='admin',password=123456)" > 测试@RequestMapping的params属性-->/test</a > <br >
1 2 3 4 5 6 7 8 @RequestMapping( value = {"/testRequestMapping", "/test"} ,method = {RequestMethod.GET, RequestMethod.POST} ,params = {"username","password!=123456"} ) public String testRequestMapping () { return "success" ; }
注：
若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面回报错400：Parameter conditions “username, password!=123456” not met for actual request parameters: username={admin}, password={123456}
@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射
@RequestMapping注解的headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头信息和请求映射的匹配关系
“header”：要求请求映射所匹配的请求必须携带header请求头信息
“!header”：要求请求映射所匹配的请求必须不能携带header请求头信息
“header=value”：要求请求映射所匹配的请求必须携带header请求头信息且header=value
“header!=value”：要求请求映射所匹配的请求必须携带header请求头信息且header!=value
若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面显示404 错误，即资源未找到
7、SpringMVC支持ant风格的路径 模糊匹配
？：表示任意的单个字符
*：表示任意的0个或多个字符
**：表示任意的一层或多层目录
注意：在使用时，只能使用/**/xxx的方式
8、SpringMVC支持路径中的占位符（重点） 原始方式：/deleteUser?id=1
rest方式：/deleteUser/1
SpringMVC路径中的占位符常用于RESTful风格 中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过**占位符{xxx}表示传输的数据，在通过 @PathVariable**注解，将占位符所表示的数据赋值给控制器方法的形参
1 <a th:href ="@{/testRest/1/admin}" > 测试路径中的占位符-->/testRest</a > <br >
1 2 3 4 5 6 @RequestMapping("/testRest/{id}/{username}") public String testRest (@PathVariable("id") String id, @PathVariable("username") String username) { System.out.println("id:" +id+",username:" +username); return "success" ; }
四、SpringMVC获取请求参数 1、通过ServletAPI获取 该方法由DispatcherServlet调用，它会根据当前Controller方法的形参注入不一样的值
将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象
1 2 3 4 5 6 7 @RequestMapping("/testParam") public String testParam (HttpServletRequest request) { String username = request.getParameter("username" ); String password = request.getParameter("password" ); System.out.println("username:" +username+",password:" +password); return "success" ; }
2、通过控制器方法的形参获取请求参数 在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参
1 <a th:href ="@{/testParam(username='admin',password=123456)}" > 测试获取请求参数-->/testParam</a > <br >
1 2 3 4 5 @RequestMapping("/testParam") public String testParam (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所指定的请求参数没有传输或传输的值为**””**时，则使用默认值为形参赋值
@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam
5、@CookieValue @CookieValue是将cookie数据和控制器方法的形参创建映射关系
@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam
6、通过POJO获取请求参数 可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值
1 2 3 4 5 6 7 8 <form th:action ="@{/testpojo}" method ="post" > 用户名：<input type ="text" name ="username" > <br > 密码：<input type ="password" name ="password" > <br > 性别：<input type ="radio" name ="sex" value ="男" > 男<input type ="radio" name ="sex" value ="女" > 女<br > 年龄：<input type ="text" name ="age" > <br > 邮箱：<input type ="text" name ="email" > <br > <input type ="submit" > </form >
1 2 3 4 5 6 @RequestMapping("/testpojo") public String testPOJO (User user) { System.out.println(user); return "success" ; }
7、解决获取请求参数的乱码问题 解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 <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 > forceResponseEncoding</param-name > <param-value > true</param-value > </init-param > </filter > <filter-mapping > <filter-name > CharacterEncodingFilter</filter-name > <url-pattern > /*</url-pattern > </filter-mapping >
注：
SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效
五、域对象共享数据 1、使用ServletAPI向request域对象共享数据 1 2 3 4 5 @RequestMapping("/testServletAPI") public String testServletAPI (HttpServletRequest request) { request.setAttribute("testScope" , "hello,servletAPI" ); return "success" ; }
2、使用ModelAndView向request域对象共享数据 1 2 3 4 5 6 7 8 9 10 11 12 13 14 @RequestMapping("/testModelAndView") public ModelAndView testModelAndView () { ModelAndView mav = new ModelAndView (); mav.addObject("testScope" , "hello,ModelAndView" ); mav.setViewName("success" ); return mav; }
注 ：当在一个RequestMapping方法中创建了一个ModelAndView对象后，最终必须将其作为方法的返回值返回（返回给DispatcherServlet前端控制器）
以下的Model、map、ModelMap在交给DispatcherServlet处理时都会被封装为ModelAndView 。
3、使用Model向request域对象共享数据 1 2 3 4 5 @RequestMapping("/testModel") public String testModel (Model model) { model.addAttribute("testScope" , "hello,Model" ); return "success" ; }
4、使用map向request域对象共享数据 1 2 3 4 5 @RequestMapping("/testMap") public String testMap (Map<String, Object> map) { map.put("testScope" , "hello,Map" ); return "success" ; }
5、使用ModelMap向request域对象共享数据 1 2 3 4 5 @RequestMapping("/testModelMap") public String testModelMap (ModelMap modelMap) { modelMap.addAttribute("testScope" , "hello,ModelMap" ); return "success" ; }
6、Model、ModelMap、Map的关系 Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的
1 2 3 4 public interface Model {}public class ModelMap extends LinkedHashMap <String, Object> {}public class ExtendedModelMap extends ModelMap implements Model {}public class BindingAwareModelMap extends ExtendedModelMap {}
7、向session域共享数据 1 2 3 4 5 @RequestMapping("/testSession") public String testSession (HttpSession session) { session.setAttribute("testSessionScope" , "hello,session" ); return "success" ; }
8、向application域共享数据 1 2 3 4 5 6 @RequestMapping("/testApplication") public String testApplication (HttpSession session) { ServletContext application = session.getServletContext(); application.setAttribute("testApplicationScope" , "hello,application" ); return "success" ; }
六、SpringMVC的视图 SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户
SpringMVC视图的种类很多，默认有转发视图和重定向视图
当工程引入jstl的依赖，转发视图会自动转换为JstlView
若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView
1、ThymeleafView 当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发 的方式实现跳转
1 2 3 4 @RequestMapping("/testHello") public String testHello () { return "hello" ; }
2、转发视图 SpringMVC中默认的转发视图是InternalResourceView
SpringMVC中创建转发视图的情况：
当控制器方法中所设置的视图名称以”forward:”为前缀时，创建InternalResourceView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”forward:”去掉，剩余部分作为最终路径通过转发的方式实现跳转
例如”forward:/“，“forward:/employee”
1 2 3 4 @RequestMapping("/testForward") public String testForward () { return "forward:/testHello" ; }
3、重定向视图 SpringMVC中默认的重定向视图是RedirectView
当控制器方法中所设置的视图名称以”redirect:”为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”redirect:”去掉，剩余部分作为最终路径通过重定向的方式实现跳转
例如”redirect:/“，“redirect:/employee”
1 2 3 4 @RequestMapping("/testRedirect") public String testRedirect () { return "redirect:/testHello" ; }
注：
重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自动拼接上下文路径
4、转发和重定向的区别
对于浏览器：转发是一次请求；重定向是两次请求
对于浏览器地址栏的地址：转发是第一次请求的地址；重定向是最终跳转到的地址
对于第一次请求域对象的数据：转发可以获取；重定向不能获取
对于WEB-INF下的资源：转发可以访问，重定向不能访问，因为WEB-INF下的资源具有安全性和隐藏性，只能通过服务器内部访问，不能通过浏览器访问。
对于跨域：转发不能跨域，因为转发是发生在服务器内部的，只能访问服务器内部的资源；重定向可以跨域，因为重定向是浏览器发送了两次请求，通过浏览器可以访问任意资源
5、视图控制器view-controller 当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示
1 2 3 4 5 <mvc:view-controller path ="/testView" view-name ="success" > </mvc:view-controller >
注：
当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签：
<mvc:annotation-driven />
七、RESTful 1、RESTful简介 REST：Re presentational S tate T ransfer，表现层资源状态转移。
a>资源 资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词。一个资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址。对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互。
b>资源的表述 资源的表述是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务器端之间转移（交换）。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等。资源的表述格式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式。
c>状态转移 状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述。通过转移和操作资源的表述，来间接实现操作资源的目的。
2、RESTful的实现 具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。
它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。
REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性。
操作
传统方式
REST风格
查询操作
getUserById?id=1
user/1–>get请求方式
保存操作
saveUser
user–>post请求方式
删除操作
deleteUser?id=1
user/1–>delete请求方式
更新操作
updateUser
user–>put请求方式
3、HiddenHttpMethodFilter 由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？
SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求
HiddenHttpMethodFilter 处理put和delete请求的条件：
a>当前请求的请求方式必须为post
b>当前请求必须传输请求参数_method
满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数_method的值才是最终的请求方式
在web.xml中注册HiddenHttpMethodFilter
1 2 3 4 5 6 7 8 <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 >
注：
目前为止，SpringMVC中提供了两个过滤器：CharacterEncodingFilter和HiddenHttpMethodFilter
在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter
原因：
在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字符集的
request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作
而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作：
String paramValue = request.getParameter(this.methodParam);
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ### 源码分析 为什么**HiddenHttpMethodFilter** 处理put和delete请求的条件是：当前请求的请求方式必须为**post**；当前请求必须传输请求参数**_method**？ HiddenHttpMethodFilter类的doFilterInternal方法 ```java @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { HttpServletRequest requestToUse = request; if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) { String paramValue = request.getParameter(this.methodParam); if (StringUtils.hasLength(paramValue)) { String method = paramValue.toUpperCase(Locale.ENGLISH); if (ALLOWED_METHODS.contains(method)) { requestToUse = new HttpMethodRequestWrapper(request, method); } } } filterChain.doFilter(requestToUse, response); }
先将请求request赋给变量requestToUse。
该方法判断如果请求方法为POST 时，进行下列操作：
根据键this.methodParam获取其对应的值，根据定义可以看到键methodParam为**_method**
1 2 3 4 public static final String DEFAULT_METHOD_PARAM = "_method" ;private String methodParam = DEFAULT_METHOD_PARAM;
因此我们需要在html页面的表单中提交对应的键值对，以PUT为例：
1 2 3 4 5 6 <form th:action ="@{/user}" method ="post" > <input type ="hidden" name ="_method" value ="put" > <br /> 用户名：<input type ="text" name ="username" > <br /> 密码：<input type ="password" name ="password" > <br /> <input type ="submit" value ="修改" > <br /> </form >
doFilterInternal方法中获取到键**_method**对应的值put，将其转换为大写的PUT后赋给method变量
最后将request和method变量传递给（装饰器）HttpMethodRequestWrapper构造器，并赋值给变量requestToUse。
最终对requestToUse请求进行放行。
总结：当form表单的method属性为post时，若提交的数据有_method键值对，则创建一个以 _method键对应的值为请求方法的新请求，并将这个新请求进行放行。否则仍然放行以post为请求方法的请求
此为偷天换日 。
八、RESTful案例 1、准备工作 和传统 CRUD 一样，实现对员工信息的增删改查。
搭建环境
准备实体类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 package com.atguigu.mvc.bean;public class Employee { private Integer id; private String lastName; private String email; private Integer gender; public Integer getId () { return id; } public void setId (Integer id) { this .id = id; } public String getLastName () { return lastName; } public void setLastName (String lastName) { this .lastName = lastName; } public String getEmail () { return email; } public void setEmail (String email) { this .email = email; } public Integer getGender () { return gender; } public void setGender (Integer gender) { this .gender = gender; } public Employee (Integer id, String lastName, String email, Integer gender) { super (); this .id = id; this .lastName = lastName; this .email = email; this .gender = gender; } public Employee () { } }
准备dao模拟数据
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 package com.atguigu.mvc.dao;import java.util.Collection;import java.util.HashMap;import java.util.Map;import com.atguigu.mvc.bean.Employee;import org.springframework.stereotype.Repository;@Repository public class EmployeeDao { private static Map<Integer, Employee> employees = null ; static { employees = new HashMap <Integer, Employee>(); employees.put(1001 , new Employee (1001 , "E-AA" , "aa@163.com" , 1 )); employees.put(1002 , new Employee (1002 , "E-BB" , "bb@163.com" , 1 )); employees.put(1003 , new Employee (1003 , "E-CC" , "cc@163.com" , 0 )); employees.put(1004 , new Employee (1004 , "E-DD" , "dd@163.com" , 0 )); employees.put(1005 , new Employee (1005 , "E-EE" , "ee@163.com" , 1 )); } private static Integer initId = 1006 ; public void save (Employee employee) { if (employee.getId() == null ){ employee.setId(initId++); } employees.put(employee.getId(), employee); } public Collection<Employee> getAll () { return employees.values(); } public Employee get (Integer id) { return employees.get(id); } public void delete (Integer id) { employees.remove(id); } }
2、功能清单
功能
URL 地址
请求方式
访问首页√
/
GET
查询全部数据√
/employee
GET
删除√
/employee/2
DELETE
跳转到添加数据页面√
/toAdd
GET
执行保存√
/employee
POST
跳转到更新数据页面√
/employee/2
GET
执行更新√
/employee
PUT
3、具体功能：访问首页 a>配置view-controller 1 <mvc:view-controller path ="/" view-name ="index" />
b>创建页面 1 2 3 4 5 6 7 8 9 10 11 <!DOCTYPE html > <html lang ="en" xmlns:th ="http://www.thymeleaf.org" > <head > <meta charset ="UTF-8" > <title > Title</title > </head > <body > <h1 > 首页</h1 > <a th:href ="@{/employee}" > 访问员工信息</a > </body > </html >
4、具体功能：查询所有员工数据 a>控制器方法 1 2 3 4 5 6 @RequestMapping(value = "/employee", method = RequestMethod.GET) public String getEmployeeList (Model model) { Collection<Employee> employeeList = employeeDao.getAll(); model.addAttribute("employeeList" , employeeList); return "employee_list" ; }
b>创建employee_list.html 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 <!DOCTYPE html > <html lang ="en" xmlns:th ="http://www.thymeleaf.org" > <head > <meta charset ="UTF-8" > <title > Employee Info</title > <script type ="text/javascript" th:src ="@{/static/js/vue.js}" > </script > </head > <body > <table border ="1" cellpadding ="0" cellspacing ="0" style ="text-align: center;" id ="dataTable" > <tr > <th colspan ="5" > Employee Info</th > </tr > <tr > <th > id</th > <th > lastName</th > <th > email</th > <th > gender</th > <th > options(<a th:href ="@{/toAdd}" > add</a > )</th > </tr > <tr th:each ="employee : ${employeeList}" > <td th:text ="${employee.id}" > </td > <td th:text ="${employee.lastName}" > </td > <td th:text ="${employee.email}" > </td > <td th:text ="${employee.gender}" > </td > <td > <a class ="deleteA" @click ="deleteEmployee" th:href ="@{'/employee/'+${employee.id}}" > delete</a > <a th:href ="@{'/employee/'+${employee.id}}" > update</a > </td > </tr > </table > </body > </html >
5、具体功能：删除 a>创建处理delete请求方式的表单 1 2 3 4 5 <form id ="delete_form" method ="post" > <input type ="hidden" name ="_method" value ="delete" /> </form >
b>删除超链接绑定点击事件 引入vue.js
1 <script type ="text/javascript" th:src ="@{/static/js/vue.js}" > </script >
删除超链接
1 <a class ="deleteA" @click ="deleteEmployee" th:href ="@{'/employee/'+${employee.id}}" > delete</a >
通过vue处理点击事件
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 <script type ="text/javascript" > var vue = new Vue ({ el :"#dataTable" , methods :{ deleteEmployee :function (event ) { var delete_form = document .getElementById ("delete_form" ); delete_form.action = event.target .href ; delete_form.submit (); event.preventDefault (); } } }); </script >
c>控制器方法 1 2 3 4 5 @RequestMapping(value = "/employee/{id}", method = RequestMethod.DELETE) public String deleteEmployee (@PathVariable("id") Integer id) { employeeDao.delete(id); return "redirect:/employee" ; }
6、具体功能：跳转到添加数据页面 a>配置view-controller 1 <mvc:view-controller path ="/toAdd" view-name ="employee_add" > </mvc:view-controller >
b>创建employee_add.html 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 <!DOCTYPE html > <html lang ="en" xmlns:th ="http://www.thymeleaf.org" > <head > <meta charset ="UTF-8" > <title > Add Employee</title > </head > <body > <form th:action ="@{/employee}" method ="post" > lastName:<input type ="text" name ="lastName" > <br > email:<input type ="text" name ="email" > <br > gender:<input type ="radio" name ="gender" value ="1" > male <input type ="radio" name ="gender" value ="0" > female<br > <input type ="submit" value ="add" > <br > </form > </body > </html >
7、具体功能：执行保存 a>控制器方法 1 2 3 4 5 @RequestMapping(value = "/employee", method = RequestMethod.POST) public String addEmployee (Employee employee) { employeeDao.save(employee); return "redirect:/employee" ; }
8、具体功能：跳转到更新数据页面 a>修改超链接 1 <a th:href ="@{'/employee/'+${employee.id}}" > update</a >
b>控制器方法 1 2 3 4 5 6 @RequestMapping(value = "/employee/{id}", method = RequestMethod.GET) public String getEmployeeById (@PathVariable("id") Integer id, Model model) { Employee employee = employeeDao.get(id); model.addAttribute("employee" , employee); return "employee_update" ; }
c>创建employee_update.html 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 <!DOCTYPE html > <html lang ="en" xmlns:th ="http://www.thymeleaf.org" > <head > <meta charset ="UTF-8" > <title > Update Employee</title > </head > <body > <form th:action ="@{/employee}" method ="post" > <input type ="hidden" name ="_method" value ="put" > <input type ="hidden" name ="id" th:value ="${employee.id}" > lastName:<input type ="text" name ="lastName" th:value ="${employee.lastName}" > <br > email:<input type ="text" name ="email" th:value ="${employee.email}" > <br > gender:<input type ="radio" name ="gender" value ="1" th:field ="${employee.gender}" > male <input type ="radio" name ="gender" value ="0" th:field ="${employee.gender}" > female<br > <input type ="submit" value ="update" > <br > </form > </body > </html >
9、具体功能：执行更新 a>控制器方法 1 2 3 4 5 @RequestMapping(value = "/employee", method = RequestMethod.PUT) public String updateEmployee (Employee employee) { employeeDao.save(employee); return "redirect:/employee" ; }
八、HttpMessageConverter HttpMessageConverter，报文信息转换器，将请求报文转换为Java对象，或将Java对象转换为响应报文
HttpMessageConverter提供了两个注解和两个类型：@RequestBody，@ResponseBody，RequestEntity，
ResponseEntity
1、@RequestBody @RequestBody可以获取请求体，需要在控制器方法设置一个形参，使用@RequestBody进行标识，当前请求的请求体就会为当前注解所标识的形参赋值
1 2 3 4 5 <form th:action ="@{/testRequestBody}" method ="post" > 用户名：<input type ="text" name ="username" > <br > 密码：<input type ="password" name ="password" > <br > <input type ="submit" > </form >
1 2 3 4 5 @RequestMapping("/testRequestBody") public String testRequestBody (@RequestBody String requestBody) { System.out.println("requestBody:" +requestBody); return "success" ; }
输出结果：
requestBody:username=admin&password=123456
2、RequestEntity RequestEntity封装请求报文的一种类型，需要在控制器方法的形参中设置该类型的形参，当前请求的请求报文就会赋值给该形参，可以通过getHeaders()获取请求头信息，通过getBody()获取请求体信息
1 2 3 4 5 6 @RequestMapping("/testRequestEntity") public String testRequestEntity (RequestEntity<String> requestEntity) { System.out.println("requestHeader:" +requestEntity.getHeaders()); System.out.println("requestBody:" +requestEntity.getBody()); return "success" ; }
输出结果：http://localhost:8080” , user-agent:“Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 Safari/537.36”]
3、@ResponseBody @ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器
1 2 3 4 5 @RequestMapping("/testResponseBody") @ResponseBody public String testResponseBody () { return "success" ; }
结果：浏览器页面显示success
4、SpringMVC处理json @ResponseBody处理json的步骤：
a>导入jackson的依赖
1 2 3 4 5 <dependency > <groupId > com.fasterxml.jackson.core</groupId > <artifactId > jackson-databind</artifactId > <version > 2.12.1</version > </dependency >
b>在SpringMVC的核心配置文件中开启mvc的注解驱动，此时在HandlerAdaptor中会自动装配一个消息转换器：MappingJackson2HttpMessageConverter，可以将响应到浏览器的Java对象转换为Json格式的字符串
1 <mvc:annotation-driven />
c>在处理器方法上使用@ResponseBody注解进行标识
d>将Java对象直接作为控制器方法的返回值返回，就会自动转换为Json格式的字符串
1 2 3 4 5 @RequestMapping("/testResponseUser") @ResponseBody public User testResponseUser () { return new User (1001 ,"admin" ,"123456" ,23 ,"男" ); }
浏览器的页面中展示的结果：
{“id”:1001,“username”:“admin”,“password”:“123456”,“age”:23,“sex”:“男”}
5、SpringMVC处理ajax a>请求超链接：
1 2 3 <div id ="app" > <a th:href ="@{/testAjax}" @click ="testAjax" > testAjax</a > <br > </div >
b>通过vue和axios处理点击事件：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 <script type ="text/javascript" th:src ="@{/static/js/vue.js}" > </script > <script type ="text/javascript" th:src ="@{/static/js/axios.min.js}" > </script > <script type ="text/javascript" > var vue = new Vue ({ el :"#app" , methods :{ testAjax :function (event ) { axios ({ method :"post" , url :event.target .href , params :{ username :"admin" , password :"123456" } }).then (function (response ) { alert (response.data ); }); event.preventDefault (); } } }); </script >
c>控制器方法：
1 2 3 4 5 6 @RequestMapping("/testAjax") @ResponseBody public String testAjax (String username, String password) { System.out.println("username:" +username+",password:" +password); return "hello,ajax" ; }
6、@RestController注解 @RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解
7、ResponseEntity ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文
九、文件上传和下载 1、文件下载 使用ResponseEntity实现下载文件的功能
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 @RequestMapping("/testDown") public ResponseEntity<byte []> testResponseEntity(HttpSession session) throws IOException { ServletContext servletContext = session.getServletContext(); String realPath = servletContext.getRealPath("/static/img/1.jpg" ); InputStream is = new FileInputStream (realPath); byte [] bytes = new byte [is.available()]; is.read(bytes); MultiValueMap<String, String> headers = new HttpHeaders (); headers.add("Content-Disposition" , "attachment;filename=1.jpg" ); HttpStatus statusCode = HttpStatus.OK; ResponseEntity<byte []> responseEntity = new ResponseEntity <>(bytes, headers, statusCode); is.close(); return responseEntity; }
2、文件上传 文件上传要求form表单的请求方式必须为post，并且添加属性enctype=“multipart/form-data”
SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息
上传步骤：
a>添加依赖：
1 2 3 4 5 6 <dependency > <groupId > commons-fileupload</groupId > <artifactId > commons-fileupload</artifactId > <version > 1.3.1</version > </dependency >
b>在SpringMVC的配置文件中添加配置：
这个bean是通过id获取的，因为MultipartFile接口下有多个实现类，若是通过类型获取，则无法判断到底是哪一个实现类。
1 2 <bean id ="multipartResolver" class ="org.springframework.web.multipart.commons.CommonsMultipartResolver" > </bean >
c>控制器方法：
MultipartFile类型的参数名必须与form表单中提交的文件的name属性值一致。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 @RequestMapping("/testUp") public String testUp (MultipartFile photo, HttpSession session) throws IOException { String fileName = photo.getOriginalFilename(); String suffix = fileName.substring(fileName.lastIndexOf("." )); String uuid= UUID.randomUUID().toString().replaceAll("-" ,"" ); fileName = uuid+suffix; 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" ; }
十、拦截器
1、拦截器的配置 SpringMVC中的拦截器用于拦截控制器方法的执行
SpringMVC中的拦截器需要实现HandlerInterceptor
若使用ref属性配置拦截器，则必须在对应的拦截器类上加**@Component**
SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置：
1 2 3 4 5 6 7 8 9 10 11 <bean class ="com.atguigu.interceptor.FirstInterceptor" > </bean > <ref bean ="firstInterceptor" > </ref > <mvc:interceptor > <mvc:mapping path ="/**" /> <mvc:exclude-mapping path ="/testRequestEntity" /> <ref bean ="firstInterceptor" > </ref > </mvc:interceptor >
注：/*匹配所有上下文路径下的第一层目录，/**匹配所有上下文路径的所有目录。
2、拦截器的三个抽象方法 SpringMVC中的拦截器有三个抽象方法：
preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法
postHandle：控制器方法执行之后执行postHandle()
afterComplation：处理完视图和模型数据，渲染视图完毕之后执行afterComplation()
3、多个拦截器的执行顺序 a>若每个拦截器的preHandle()都返回true
此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：
preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行
b>若某个拦截器的preHandle()返回了false
preHandle()返回false和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false的拦截器之前的拦截器的afterComplation()会执行
十一、异常处理器 1、基于配置的异常处理 SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResolver
HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver
SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，使用方式：
1 2 3 4 5 6 7 8 9 10 11 12 13 <bean class ="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver" > <property name ="exceptionMappings" > <props > <prop key ="java.lang.ArithmeticException" > error</prop > </props > </property > <property name ="exceptionAttribute" value ="ex" > </property > </bean >
2、基于注解的异常处理 1 2 3 4 5 6 7 8 9 10 11 12 13 @ControllerAdvice public class ExceptionController { @ExceptionHandler(ArithmeticException.class) public String handleArithmeticException (Exception ex, Model model) { model.addAttribute("ex" , ex); return "error" ; } }
十二、注解配置SpringMVC 使用配置类和注解代替web.xml和SpringMVC配置文件的功能
1、创建初始化类，代替web.xml 在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果找到的话就用它来配置Servlet容器。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer { @Override protected Class<?>[] getRootConfigClasses() { return new Class []{SpringConfig.class}; } @Override protected Class<?>[] getServletConfigClasses() { return new Class []{WebConfig.class}; } @Override protected String[] getServletMappings() { return new String []{"/" }; } @Override protected Filter[] getServletFilters() { CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter (); encodingFilter.setEncoding("UTF-8" ); encodingFilter.setForceRequestEncoding(true ); HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter (); return new Filter []{encodingFilter, hiddenHttpMethodFilter}; } }
2、创建SpringConfig配置类，代替spring的配置文件 1 2 3 4 @Configuration public class SpringConfig { }
3、创建WebConfig配置类，代替SpringMVC的配置文件 @Bean注解标识的方法，其返回值将会被放入IOC容器
其他方法中有形参时，将根据形参的类型在IOC容器中找到对应的Bean组件，并注入到该形参中。
此为AutoWire自动装配 。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 @Configuration @ComponentScan("com.yumo.mvc.controller") @EnableWebMvc public class WebConfig implements WebMvcConfigurer { @Bean public SpringResourceTemplateResolver templateResolver () { SpringResourceTemplateResolver springResourceTemplateResolver = new SpringResourceTemplateResolver (); springResourceTemplateResolver.setApplicationContext(ContextLoader.getCurrentWebApplicationContext()); springResourceTemplateResolver.setPrefix("/WEB-INF/templates/" ); springResourceTemplateResolver.setSuffix(".html" ); springResourceTemplateResolver.setCharacterEncoding("UTF-8" ); springResourceTemplateResolver.setTemplateMode(TemplateMode.HTML); return springResourceTemplateResolver; } @Bean public SpringTemplateEngine templateEngine (SpringResourceTemplateResolver 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; } @Override public void addInterceptors (InterceptorRegistry registry) { TestInterceptor testInterceptor = new TestInterceptor (); registry.addInterceptor(testInterceptor) .addPathPatterns("/**" ) .excludePathPatterns("/" ); } @Override public void configureHandlerExceptionResolvers (List<HandlerExceptionResolver> resolvers) { SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver (); Properties properties = new Properties (); properties.setProperty("java.lang.ArithmeticException" ,"error" ); simpleMappingExceptionResolver.setExceptionMappings(properties); simpleMappingExceptionResolver.setExceptionAttribute("exception" ); resolvers.add(simpleMappingExceptionResolver); } @Override public void addViewControllers (ViewControllerRegistry registry) { registry.addViewController("/hello" ) .setViewName("hello" ); } @Bean public MultipartResolver multipartResolver () { CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver (); return commonsMultipartResolver; } @Override public void configureDefaultServletHandling (DefaultServletHandlerConfigurer configurer) { configurer.enable(); } }
4、测试功能 1 2 3 4 @RequestMapping("/") public String index () { return "index" ; }
十三、SpringMVC执行流程 1、SpringMVC常用组件
DispatcherServlet：前端控制器 ，不需要工程师开发，由框架提供
作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求
HandlerMapping：处理器映射器 ，不需要工程师开发，由框架提供
作用：根据请求的url、method等信息查找Handler，即控制器方法。
具体体现为@RequestMapping。
Handler：处理器 ，也就是控制器 Controller，需要工程师开发
作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理
HandlerAdapter：处理器适配器 ，不需要工程师开发，由框架提供
作用：通过HandlerAdapter对处理器（控制器方法）进行执行，会进行参数解析，返回值内容协商。
ViewResolver：视图解析器 ，不需要工程师开发，由框架提供
作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView、RedirectView。根据不同的视图名称，使用不同的视图解析器进行页面渲染。
作用：将模型数据通过页面展示给用户
2、DispatcherServlet初始化过程 DispatcherServlet 本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。所以宏观上是 Servlet 生命周期来进行调度。
a>初始化WebApplicationContext 所在类：org.springframework.web.servlet.FrameworkServlet
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 protected WebApplicationContext initWebApplicationContext () { WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext()); WebApplicationContext wac = null ; if (this .webApplicationContext != null ) { wac = this .webApplicationContext; if (wac instanceof ConfigurableWebApplicationContext) { ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac; if (!cwac.isActive()) { if (cwac.getParent() == null ) { cwac.setParent(rootContext); } configureAndRefreshWebApplicationContext(cwac); } } } if (wac == null ) { wac = findWebApplicationContext(); } if (wac == null ) { wac = createWebApplicationContext(rootContext); } if (!this .refreshEventReceived) { synchronized (this .onRefreshMonitor) { onRefresh(wac); } } if (this .publishContext) { String attrName = getServletContextAttributeName(); getServletContext().setAttribute(attrName, wac); } return wac; }
b>创建WebApplicationContext 所在类：org.springframework.web.servlet.FrameworkServlet
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 protected WebApplicationContext createWebApplicationContext (@Nullable ApplicationContext parent) { Class<?> contextClass = getContextClass(); if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) { throw new ApplicationContextException ( "Fatal initialization error in servlet with name '" + getServletName() + "': custom WebApplicationContext class [" + contextClass.getName() + "] is not of type ConfigurableWebApplicationContext" ); } ConfigurableWebApplicationContext wac = (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass); wac.setEnvironment(getEnvironment()); wac.setParent(parent); String configLocation = getContextConfigLocation(); if (configLocation != null ) { wac.setConfigLocation(configLocation); } configureAndRefreshWebApplicationContext(wac); return wac; }
注：在ssm整合中，spring和springMVC各自管理一个容器，其中springMVC的IOC容器是子容器 ，spring的IOC容器是父容器 。
c>DispatcherServlet初始化策略 FrameworkServlet创建WebApplicationContext后，刷新容器，调用onRefresh(wac)，此方法在DispatcherServlet中进行了重写，调用了initStrategies(context)方法，初始化策略，即初始化DispatcherServlet的各个组件
所在类：org.springframework.web.servlet.DispatcherServlet
1 2 3 4 5 6 7 8 9 10 11 protected void initStrategies (ApplicationContext context) { initMultipartResolver(context); initLocaleResolver(context); initThemeResolver(context); initHandlerMappings(context); initHandlerAdapters(context); initHandlerExceptionResolvers(context); initRequestToViewNameTranslator(context); initViewResolvers(context); initFlashMapManager(context); }
3、DispatcherServlet调用组件处理请求 a>processRequest() FrameworkServlet重写HttpServlet中的service()和doXxx()，这些方法中调用了processRequest(request, response)
所在类：org.springframework.web.servlet.FrameworkServlet
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 protected final void processRequest (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { long startTime = System.currentTimeMillis(); Throwable failureCause = null ; LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext(); LocaleContext localeContext = buildLocaleContext(request); RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes(); ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes); WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request); asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor ()); initContextHolders(request, localeContext, requestAttributes); try { doService(request, response); } catch (ServletException | IOException ex) { failureCause = ex; throw ex; } catch (Throwable ex) { failureCause = ex; throw new NestedServletException ("Request processing failed" , ex); } finally { resetContextHolders(request, previousLocaleContext, previousAttributes); if (requestAttributes != null ) { requestAttributes.requestCompleted(); } logResult(request, response, failureCause, asyncManager); publishRequestHandledEvent(request, response, startTime, failureCause); } }
b>doService() 所在类：org.springframework.web.servlet.DispatcherServlet
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 @Override protected void doService (HttpServletRequest request, HttpServletResponse response) throws Exception { logRequest(request); Map<String, Object> attributesSnapshot = null ; if (WebUtils.isIncludeRequest(request)) { attributesSnapshot = new HashMap <>(); Enumeration<?> attrNames = request.getAttributeNames(); while (attrNames.hasMoreElements()) { String attrName = (String) attrNames.nextElement(); if (this .cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) { attributesSnapshot.put(attrName, request.getAttribute(attrName)); } } } request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext()); request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this .localeResolver); request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this .themeResolver); request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource()); if (this .flashMapManager != null ) { FlashMap inputFlashMap = this .flashMapManager.retrieveAndUpdate(request, response); if (inputFlashMap != null ) { request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap)); } request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap ()); request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this .flashMapManager); } RequestPath requestPath = null ; if (this .parseRequestPath && !ServletRequestPathUtils.hasParsedRequestPath(request)) { requestPath = ServletRequestPathUtils.parseAndCache(request); } try { doDispatch(request, response); } finally { if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) { if (attributesSnapshot != null ) { restoreAttributesAfterInclude(request, attributesSnapshot); } } if (requestPath != null ) { ServletRequestPathUtils.clearParsedRequestPath(request); } } }
c>doDispatch() 所在类：org.springframework.web.servlet.DispatcherServlet
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 protected void doDispatch (HttpServletRequest request, HttpServletResponse response) throws Exception { HttpServletRequest processedRequest = request; HandlerExecutionChain mappedHandler = null ; boolean multipartRequestParsed = false ; WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request); try { ModelAndView mv = null ; Exception dispatchException = null ; try { processedRequest = checkMultipart(request); multipartRequestParsed = (processedRequest != request); mappedHandler = getHandler(processedRequest); if (mappedHandler == null ) { noHandlerFound(processedRequest, response); return ; } HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); String method = request.getMethod(); boolean isGet = "GET" .equals(method); if (isGet || "HEAD" .equals(method)) { long lastModified = ha.getLastModified(request, mappedHandler.getHandler()); if (new ServletWebRequest (request, response).checkNotModified(lastModified) && isGet) { return ; } } if (!mappedHandler.applyPreHandle(processedRequest, response)) { return ; } mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); if (asyncManager.isConcurrentHandlingStarted()) { return ; } applyDefaultViewName(processedRequest, mv); mappedHandler.applyPostHandle(processedRequest, response, mv); } catch (Exception ex) { dispatchException = ex; } catch (Throwable err) { dispatchException = new NestedServletException ("Handler dispatch failed" , err); } processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException); } catch (Exception ex) { triggerAfterCompletion(processedRequest, response, mappedHandler, ex); } catch (Throwable err) { triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException ("Handler processing failed" , err)); } finally { if (asyncManager.isConcurrentHandlingStarted()) { if (mappedHandler != null ) { mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response); } } else { if (multipartRequestParsed) { cleanupMultipart(processedRequest); } } } }
d>processDispatchResult() 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 private void processDispatchResult (HttpServletRequest request, HttpServletResponse response, @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv, @Nullable Exception exception) throws Exception { boolean errorView = false ; if (exception != null ) { if (exception instanceof ModelAndViewDefiningException) { logger.debug("ModelAndViewDefiningException encountered" , exception); mv = ((ModelAndViewDefiningException) exception).getModelAndView(); } else { Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null ); mv = processHandlerException(request, response, handler, exception); errorView = (mv != null ); } } if (mv != null && !mv.wasCleared()) { render(mv, request, response); if (errorView) { WebUtils.clearErrorRequestAttributes(request); } } else { if (logger.isTraceEnabled()) { logger.trace("No view rendering, null ModelAndView returned." ); } } if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) { return ; } if (mappedHandler != null ) { mappedHandler.triggerAfterCompletion(request, response, null ); } }
4、SpringMVC的执行流程
