SpringMVC

一、介绍 

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

基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一 处理

内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可

二、入门案例

1、引入依赖

org.springframework
spring-webmvc
5.3.1



ch.qos.logback
logback-classic
1.2.3



javax.servlet
javax.servlet-api
3.1.0
provided



org.thymeleaf
thymeleaf-spring5
3.0.12.RELEASE

由于 Maven 的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠 传递性导入

 2、配置web.xml

因为SpringMvc本质上还是一个servlet，将servlet封装成了一个DispatcherServlet,而servlet是要配置在web.xml中对请求和响应进行统一处理

WEB-INF下创建web.xml

     springMVC
     org.springframework.web.servlet.DispatcherServlet

     

          contextConfigLocation

          classpath:springmvc.xml
     
     
     1



    springMVC
    /

注

上面设置springMVC的核心控制器所能处理的请求的请求路径，即DispatcherServlet处理的路径

/ 表示所匹配的请求可以是/login或.html或.js或.css方式的请求路径，不包括.jsp请求，因为jsp本质是一个servlet，需要经过jspServlet翻译成servlet然后响应给浏览器，DispatcherServlet是没法处理.jsp请求的
/*  匹配所有的请求，包括.jsp，但是.jspDispatcherServlet没法处理jsp，是通过tomcat自己的jspServlet处理，所以这里配置/就可以

如下tomcat的web.xml

    
        default
        org.apache.catalina.servlets.DefaultServlet
        
            debug
            0
        
        
            listings
            false
        
        1
    

    
        jsp
        org.apache.jasper.servlet.JspServlet
        
            fork
            false
        
        
            xpoweredBy
            false
        
        3
    


    
    
        default
        /
    

    
    
        jsp
        *.jsp
        *.jspx
    

当然如果模板引起用的不是jsp而是thmeleaf，那上面配置/*也是可以的 

 3、创建请求控制器

springMvc就是封装的servlet，所以我们不需要再创建servlet，只需要创建一个普通java类，在这个普通类上标上@Controller注解将其标识 为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在

主要每一个请求不能通过DispatcherServlet处理，DispatcherServlet可以处理一些共性问题，比如说获取请求参数、向域对象存储共享数据、页面跳转和重定向，具体请求如何处理还是通过上面的标有@Controller的普通java类

@Controller
public class UserController {

}

4、创建springMvc配置文件

如果web.xml配置内容如下

    springMVC
    org.springframework.web.servlet.DispatcherServlet


    springMVC
    /

此时SpringMVC的配置文件默认位于WEB-INF下，默认名称为- servlet.xml，例如，以下上面所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC-servlet.xml

    
    

    
    

    
    
        
        
        
            
                
                    
                        
                        
                        
                        
                    
                
            
        
    

    
    

    
    
        
            
            
                
                
                    
                        text/html
                        application/json
                    
                
            
        
    

    
    

上面 springMVC-servlet.xml文件是在WEB-INF下的，如果想修改位置以及文件名称，需要修改web.xml为如下

     springMVC
     org.springframework.web.servlet.DispatcherServlet

     
          contextConfigLocation
          classpath:springmvc.xml
     
     1


    springMVC
    /

注意：SpringMVC中文乱码的三种解决方案

1.get请求乱码 在Tomcat的server.xml文件夹下修改配置：

2.POST请求乱码解决方案是在web.xml中输入以下内容：

     
    
        encodingFilter
        org.springframework.web.filter.CharacterEncodingFilter
        
            encoding
            utf-8
        
        
            forceEncoding
            true
        
    
    
        encodingFilter
        /*
    

SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效 

3.Response响应请求乱码问题解决方案，是在applicationContext.xml文件中进行以下配置

    
        
            
            
                
                
                    
                        text/html
                        application/json
                    
                
            
        
    

5、部署测试

在上面定义的请求控制器定义方法

@RequestMapping("/hello")
public String hello() {
//设置视图名称
return "hello";
}


@RequestMapping("/index")
public String index() {
//设置视图名称
return "index";
}

index.html页面

首页
//下面的@表示thmeleaf会自动帮我们加上应用在tomcat的上下文路径，即可相当于localhost/demo/hello
HelloWorld

部署，使用tomcat部署web项目

点击Add Configuration->+

选择Tomcat Server下的Local，name自定义，选择Deployment,点击+

选择Artifacts下的exploded 部署

配置在tomcat服务器中的应用上下文路径，应为tomcat是一个服务器，里面可以部署多个应用，通过下面这个上下文路径就可以访问到指定的应用的路径

 选择server

上面的1处表示部署项目后点击刷新时候重新部署（Redploy,获取其他选项），如下点击刷新弹出出我们上面选中的Redploy,这里可以Do not ask again

 上面2处表示当前idea窗口失去焦点，时候更新类和资源

6、总结

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

三、RequestMapping

1、作用和位置

作用：将请求和处理请求的控制器方法关联 起来，建立映射关系

位置：

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

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

2、属性

查看RequestMapping注解源码，可以看到有如下属性

public @interface RequestMapping {
    String name() default "";

    @AliasFor("path")
    String[] value() default {};

    @AliasFor("value")
    String[] path() default {};

    RequestMethod[] method() default {};

    String[] params() default {};

    String[] headers() default {};

    String[] consumes() default {};

    String[] produces() default {};
}

2.1、value属性

是@RequestMapping注释的默认属性，因此如果只有唯一的属性，则可以省略该属性名，如果有超过一个属性，则必须写上value属性名称。即如下两个标注含义一样

@RequestMapping(value="getUser")

@RequestMapping("getUser")

value属性支持通配符匹配@RequestMapping(value="getUser/*")；即：http://localhost:8080/getUser/1或者http://localhost:8080/getUser/hahaha都能够正常访问
 

2.2、path属性

和value属性使用一致，两者都是用来作为映射使用的。

@RequestMapping(value="getUser")、@RequestMapping(path="getUser")，这两种情况都能对getUser()方法进行访问

path属性支持通配符匹配@RequestMapping(path="getUser/*")；即：http://localhost:8080/getUser/1或者http://localhost:8080/getUser/hahaha都能够正常访问
 

2.3、name属性

相当于方法的注释，使方法更易理解 

@RequestMapping(value = "getUser",name = "获取用户信息")

2.4、method属性

该属性用来表示该方法仅仅处理哪些HTTP请求方式

以上方法表示，该方法只支持GET请求。

此处也可以为@RequestMapping(value = "getUser",method = {RequestMethod.GET,RequestMethod.POST})，说明该方法可以同时支持GET和POST请求。

如果没有method属性，则说明该方法支持全部的HTTP请求。
 

2.5、params属性

该属性指定，请求中必须包含params属性规定的参数时，才能执行该请求

@RequestMapping(value = "getUser",params = "flag")

以上方法，说明请求中必须包含flag参数才能执行该请求，flag参数值不做要求

http://localhost:8080/getUser?flag=xxx     此URL能够正常访问getUser()方法

http://localhost:8080/getUser       此URL则不能正常访问getUser()方法

@RequestMapping(value = "getUser",params = "flag=true")

以上方法，说明请求中必须包含flag参数，而且参数值必须为true才能执行该请求

http://localhost:8080/getUser?flag=true    此URL能够正常访问getUser()方法

http://localhost:8080/getUser?flag=false    此URL不能正常访问getUser()方法

http://localhost:8080/getUser       此URL则不能正常访问getUser()方法

2.6、header属性

该属性指定，请求中必须包含某些指定的header值，才能够让该方法处理请求

@RequestMapping(value = "getUser",headers = "Referer=http://www.xxx.com")

以上方法 ，必须满足请求的header中包含了指定的"Referer"请求头和值为"http://www.xxx.com"时，才能执行该请求

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

"header"：要求请求映射所匹配的请求必须携带header请求头信息

"!header"：要求请求映射所匹配的请求必须不能携带header请求头信息

"header=value"：要求请求映射所匹配的请求必须携带header请求头信息且header=value "header!=value"：要求请求映射所匹配的请求必须携带header请求头信息且header!=value

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

2.7、consumers属性

@RequestMapping(value = "getUser",consumes = "application/json")

指定处理请求的提交内容类型（Content-Type），例如：application/json、text/html时，才能够让该方法处理请求

2.8、produces属性

@RequestMapping(value = "getUser",produces = "application/json")

指定返回的内容类型，返回的内容类型必须是request请求头（Accept）中所包含的类型

此外，produces属性还可以指定返回值的编码

@RequestMapping(value = "getUser",produces = "application/json，charset=utf-8")，则指明返回utf-8编码

3、SpringMVC支持ant风格的路径

？：表示任意的单个字符

*：表示任意的0个或多个字符

**：表示任意层数的任意目录

注意：在使用**时，只能使用/**/xxx的方式

4、SpringMVC支持路径中的占位符

原始方式：/deleteUser?id=1

rest方式：/user/delete/1

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

@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获取

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

@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中就会将请求参数赋值给相应的形参

如：请求地址http://localhost/testParam?username=admin&password=123456

控制器

@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所指定的请求参数没有传输或传输的值 为""时，则使用默认值为形参赋值

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

4、@RequestHeader

@RequestHeader是将请求头信息和控制器方法的形参创建映射关系

@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

5、@CookieValue

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

6、通过POJO获取请求参数

可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实 体类中的属性名一致，那么请求参数就会为此属性赋值

    用户名：

    密码：

    性别：男女

    年龄：

    邮箱：

    

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

7、接受/响应json数据

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

需要导入依赖

com.fasterxml.jackson.core

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

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

与其对应的响应json数据注解@ResponseBody

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

@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
//此时响应浏览器数据success
return "success";
}

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

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

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

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

五、域对象共享数据

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

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

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

@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
    /**
    * ModelAndView有Model和View的功能
    * Model主要用于向请求域共享数据
    * View主要用于设置视图，实现页面跳转
    */
    ModelAndView mav = new ModelAndView();
    //向请求域共享数据
    mav.addObject("testScope", "hello,ModelAndView");
    //设置视图，实现页面跳转
    mav.setViewName("success");
    return mav;
}

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

@RequestMapping("/testModel")
public String testModel(Model model){
    model.addAttribute("testScope", "hello,Model");
    return "success";
}

4、使用map向request域对象共享数据

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

5、使用ModelMap向request域对象共享数据

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

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

6、向session域共享数据

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

 7、向application域共享数据

@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

转发视图

SpringMVC中默认的转发视图是InternalResourceView

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

例如"forward:/"，"forward:/employee"

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

重定向视图 

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

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

例如"redirect:/"，"redirect:/employee"

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

重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自 动拼接上下文路径 

视图控制器view-controller

当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用viewcontroller标签进行表示

当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需 要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签

七、RESTful

springMvc也是支持RESTful风格请求方式

就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。

它们分别对应四种基本操作：

GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。

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

 

 由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？

SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求 HiddenHttpMethodFilter 处理put和delete请求的条件：

a>当前请求的请求方式必须为post

b>当前请求必须传输请求参数_method

满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数 _method的值，因此请求参数_method的值才是最终的请求方式 在web.xml中注册HiddenHttpMethodFilter

HiddenHttpMethodFilter
org.springframework.web.filter.HiddenHttpMethodFilter


HiddenHttpMethodFilter
/*

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

原因：

在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字 符集的

request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作 而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作： 

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

案例

前端链接请求

update

后端控制器

@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";
}

八、文件下载、上传

ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文

1、下载

@RequestMapping("/testDown")
public ResponseEntity testResponseEntity(HttpSession session) throws
IOException {
    //获取ServletContext对象
    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);
    //创建HttpHeaders对象设置响应头信息
    MultiValueMap headers = new HttpHeaders();
    //设置要下载方式以及下载文件的名字
    headers.add("Content-Disposition", "attachment;filename=1.jpg");
    //设置响应状态码
        HttpStatus statusCode = HttpStatus.OK;
    //创建ResponseEntity对象
    ResponseEntity responseEntity = new ResponseEntity<>(bytes, headers,
    statusCode);
    //关闭输入流
    is.close();
    return responseEntity;
}

2、上传

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

 

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

九、拦截器

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

SpringMVC中的拦截器需要实现HandlerInterceptor

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

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

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

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

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

多个拦截器的执行顺序

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

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

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

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

preHandle()返回false和它之前的拦截器的preHandle()都会执行，

postHandle()都不执行，返回false 的拦截器之前的拦截器的afterCompletion()会执行

十、异常处理器

我们每个控制器方法在执行过程中如果发生了异常，就可以通过springMvc提供的一个接口处理异常，这个接口就是HandlerExceptionResolver

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

springMvc默认使用的异常处理器就是DefaultHandlerExceptionResolver，如果我们要自定义异常处理器，就使用SimpleMappingExceptionResolver类

1、使用xml配置方式

springMvc.xml中配置

        
            
                
                    
                    error
                    error
                
            
            
            
        

2、注解方式

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

十一、注解配置SpringMvc

使用配置类和注解代替web.xml和SpringMVC配置文件的功能

在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类， 如果找到的话就用它来配置Servlet容器，就是替代web.xml。

Spring提供了这个接口的实现，名为 SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配 置的任务交给它们来完成。

Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为 AbstractAnnotationConfigDispatcherServletInitializer，当我们的类继承扩展了 AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自 动发现它，并用它来配置Servlet上下文，即替代web.xml文件

public class Webint extends AbstractAnnotationConfigDispatcherServletInitializer {
    //设置一个配置类代替spring配置文件
    @Override
    protected Class[] getRootConfigClasses() {
        //spring相关的配置 可以查看spring篇
        return new Class[]{SpringConfig.class};
    }

   //设置一个配置类代替Springmvc配置文件
    @Override
    protected Class[] getServletConfigClasses() {
        return new Class[0];
    }

    //设置Springmvc前端控制器url-pattern
    @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};
    }
}

spring配置类（查看ssm注解整合配置篇）

SpringMvc配置类

//标识配置类
@Configuration
//扫描组件
@ComponentScan("com.ssm.controller")
//开启MVC注解驱动
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {
    //使用默认的servlet处理静态资源
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    //配置视图控制
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }

    //配置文件上传解析器 将返回值作为bean（id是方法名）放入ioc容器中
    @Bean
    public CommonsMultipartResolver multipartResolver() {
        return new CommonsMultipartResolver();
    }

    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
    }

    //配置异常映射
    @Override
    public void configureHandlerExceptionResolvers(List resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new
                SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        //设置异常映射
        exceptionResolver.setExceptionMappings(prop);
        //设置共享异常信息的键
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }

    //配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext =
                ContextLoader.getCurrentWebApplicationContext();
        // ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext 的方法获得
        ServletContextTemplateResolver templateResolver = new
                ServletContextTemplateResolver(
                webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }

    //生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver
                                                       templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }

    //生成视图解析器并未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }

}

十二、springmvc执行流程

参考

Spring MVC执行流程_枫叶..的博客-CSDN博客_springmvc执行流程