SpringMVC框架-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_51787352/article/details/132338647

SpringMVC简介

SpringMVC概述

SpringMVC是一个基于Spring开发的MVC轻量级框架，Spring3.0后发布的组件，SpringMVC和Spring可以无缝整合，使用DispatcherServlet作为前端控制器，且内部提供了处理器映射器、处理器适配器、视图解析器等组件，可以简化JavaBean封装，Json转化、文件上传等操作。

SpringMVC快速入门

1.导入坐标

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>

2.配置SpringMVC的前端控制器ServletDispatcher

新建web.xml文件

    <!--配置DispatcherServlet-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

3.编写controller

@Controller
public class QuickController {

    @RequestMapping("/show")
    public String show(){
        System.out.println("show running...");
        return "/index.jsp";
    }

}

4.创建springMVC的核心配置文件 spring-mvc.xml，并配置组件扫描web层

<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/xmlSchema-instance"
 xmlns: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">
 <!-- 组件扫描web层 -->
 <context:component-scan base-package="com.itheima.controller"/>
 </beans>

本来不想用xml方式，想用注解开发，于是配置了SpringConfig类，结果报错

javax.servlet.ServletException: Servlet[DispatcherServlet]的Servlet.init（）引发异常
org.springframework.context.ApplicationContextException: Fatal initialization error in servlet with name 'DispatcherServlet': custom WebApplicationContext class[com.itheima.config.SpringConfig] is not of type ConfigurableWebApplicationContext

百度之后发现需要继承AbstractAnnotationConfigDispatcherServletInitializer类，结果继承之后还是出现一样的错误。改用xml方式就没事，不知道为什么。。。

@Configuration
@ComponentScan("com.itheima")
public class SpringConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }


}

Controller中访问容器中的Bean

DispatcherServlet在进行初始化时，加载的spring-mvc.xml配置文件创建的SpringMVC容器，那么web层Controller被扫描进入到了容器中，而之前Spring容器中的Service是否可以获取到呢？下面搭建Spring的web环境进行验证

创建一个applicationContext.xml文件

<!-- 组件扫描非web层 -->
<context:component-scan base-package="com.itheima">
 <!--排除com.itheima包下使用@Controller注解的类-->
 <context:exclude-filter type="annotation" 
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

在web.xml中配置ContextLoaderListener

<!--配置ContextLoaderListener-->
<context-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:applictionContext.xml</param-value>
</context-param>
<listener>
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

编写UserService和UserServiceImpl

public interface UserService {
 public void show();}
@Service("userService")
public class UserServiceImpl implements UserService {
 @Override
 public void show() {
 System.out.println("UserServiceImpl show running ... ...");
 }}

修改UserController，从Spring容器中匹配Service进行注入

@Controller
public class UserController {
 @Autowired
 private UserService userService;
 @RequestMapping("/show")
 public String show(){
 System.out.println("show 执行....");
 //调用userService的show方法
 userService.show();
 //视图跳转到index.jsp
 return "/index.jsp";
 }
}

测试结果

注：

Spring容器和Spring MVC容器是两个不同的容器

Spring容器（也称为应用程序上下文）：Spring容器负责管理和实例化应用程序中的所有Bean。它负责加载和管理应用程序的业务类、数据访问类、服务类等。Spring容器可以使用XML配置文件、注解或Java配置类进行配置。
Spring MVC容器：Spring MVC容器是基于Spring的Web框架，用于构建Web应用程序。它包含了与Web相关的组件，如控制器、视图解析器、处理器映射器等。Spring MVC容器使用自己的配置文件或注解来配置，并管理Web请求处理流程。

这两个容器在使用上有一定的联系：

Spring容器可以加载所有的Bean（包括服务类、数据访问类）和配置文件，提供应用程序级别的依赖注入和管理功能。
Spring MVC容器可以加载Web相关的组件，如控制器、视图解析器，以及处理Web请求和响应的流程。

通常情况下，Spring容器是Spring MVC容器的父容器。Spring容器负责应用程序中的通用Bean管理，而Spring MVC容器则负责处理Web请求和与Web相关的组件。这种层次结构的设计可以使应用程序更好地组织和管理不同层次的组件，并提供灵活和可扩展的架构。

SpringMVC关键组件浅析

当请求到达服务器时，是哪个组件接收的请求，是哪个组件帮我们找到的Controller，是哪个组件

帮我们调用的方法，又是哪个组件最终解析的视图？

当我们在Spring容器中配置了HandlerMapping，则就不会在加载默认的HandlerMapping策略了，原理比较简单，DispatcherServlet 在进行HandlerMapping初始化时，先从SpringMVC容器中找是否存在HandlerMapping，如果存在直接取出容器中的HandlerMapping，在存储到 DispatcherServlet 中的handlerMappings集合中去。

SpringMVC的请求处理

请求映射路径的配置

配置映射路径，映射器处理器才能找到Controller的方法资源，目前主流映射路径配置方式就是@RequestMapping

@RequestMapping注解，主要使用在控制器的方法上，用于标识客户端访问资源路径

@RequestMapping 在类上使用后，该类所有方法都公用该@RequestMapping设置的属性，访问路径则为类上的映射地址+方法上的映射地址

请求数据的接收

注解方式接收参数

1.接收普通请求数据，当请求参数的名称与方法参数名不一致时，可以使用@RequestParam注解进行标注

@GetMapping("/show")
public String show(@RequestParam(name = "username",required = true) String name, int age){
 System.out.println(name+"=="+age);
 return "/index.jsp";
}

2.接收实体JavaBean属性数据，单个JavaBean数据：提交的参数名称只要与Java的属性名一致，就可以进行自动封装

3.接收数组或集合数据，客户端传递多个同名参数时，可以用数组接收。也可以使用单列集合接收，但是需要使用@RequestParam告知框架传递的参数是要同名设置的，不是对象属性设置的

@GetMapping("/show")
public String show(@RequestParam List<String> hobbies){
 for (String hobby : hobbies) {
 System.out.println(hobby);}
 return "/index.jsp";}

4.接收数组或集合数据，客户端传递多个不同命参数时，也可以使用Map<String,Object> 进行接收，同样需要用@RequestParam 进行修饰

配置RequestMappingHandlerAdapter，指定消息转换器，就不用手动转换json格式字符串了

Restful风格

Restful风格的请求，常见的规则有如下三点：

1. 用URI表示某个模块资源，资源名称为名词；

2. 用请求方式表示模块具体业务动作，例如：GET表示查询、POST表示插入、PUT表示更新、DELETE表示删除

3.用HTTP响应状态码表示结果，国内常用的响应包括三部分：状态码、状态信息、响应数据

{
 "code":200,
 "message":"成功",
 "data":{
 "username":"haohao",
 "age":18
 }
}
{
 "code":300,
 "message":"执行错误",
 "data":"",
}

文件上传

接收文件上传的数据，文件上传的表单需要一定的要求，如下：

⚫ 表单的提交方式必须是POST

⚫ 表单的enctype属性必须是multipart/form-data

⚫ 文件上传项需要有name属性

<form action="" enctype="multipart/form-data">
 <input type="file" name="myFile">
</form>

服务器端，由于映射器适配器需要文件上传解析器，而该解析器默认未被注册，所以手动注册

<!--配置文件上传解析器，注意：id的名字是固定写法-->
<bean id="multipartResolver" 
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
 <property name="defaultEncoding" value="UTF-8"/><!--文件的编码格式 默认是ISO8859-1-->
 <property name="maxUploadSizePerFile" value="1048576"/><!--上传的每个文件限制的大小 单位字节-->
 <property name="maxUploadSize" value="3145728"/><!--上传文件的总大小-->
 <property name="maxInMemorySize" value="1048576"/><!--上传文件的缓存大小-->
</bean>

而CommonsMultipartResolver底层使用的Apache的是Common-fileuplad等工具API进行的文件上传

<dependency>
 <groupId>commons-fileupload</groupId>
 <artifactId>commons-fileupload</artifactId>
 <version>1.4</version>
</dependency>
<dependency>
 <groupId>commons-io</groupId>
 <artifactId>commons-io</artifactId>
 <version>2.7</version>
</dependency>

文件保存

    @PostMapping("/param2")
    public String param2(@RequestBody MultipartFile myFile) throws IOException {

        //将上传的文件进行保存
        // 1.获取当前上传文件的输入流
        InputStream inputStream = myFile.getInputStream();
        // 2.获得当前上传文件位置的输出流
        OutputStream outputStream = new FileOutputStream("E:\\"+myFile.getOriginalFilename());
        // 3.执行文件拷贝
        IOUtils.copy(inputStream, outputStream);

        // 4.关闭资源
        inputStream.close();
        outputStream.close();
        
        return "/index.jsp";
    }

获取http请求头信息

接收Http请求头数据，接收指定名称的请求头

    @GetMapping("/param3")
    public String param3(@RequestHeader("Accept-Encoding") String requestHeader){
        System.out.println("requestHeader = " + requestHeader);
        return "/index.jsp";
    }

接收所有的请求头信息

@GetMapping("/headersMap")
public String headersMap(@RequestHeader Map<String,String> map){
 map.forEach((k,v)->{
 System.out.println(k+":"+v);
 });
 return "/index.jsp";
}

获得客户端携带的Cookie数据

@GetMapping("/cookies")
public String cookies(@CookieValue(value = "JSESSIONID",defaultValue = "") String jsessionid){
 System.out.println(jsessionid);
 return "/index.jsp";
}

获得转发Request域中数据，在进行资源之间转发时，有时需要将一些参数存储到request域中携带给下一个资源

@GetMapping("/request1")
public String request1(HttpServletRequest request){
 //存储数据
 request.setAttribute("username","haohao");
 return "forward:/request2";
}
@GetMapping("/request2")
public String request2(@RequestAttribute("username") String username){
 System.out.println(username);
 return "/index.jsp";
}

参数注解的区别

@PathVariable用于从URL路径中提取参数值，适用于RESTful风格的URL。

@GetMapping("/users/{id}")
public ResponseEntity<User> getUser(@PathVariable("id") int id) {
    // 根据id获取用户信息
}

@RequestParam用于从查询参数中获取参数值，适用于传递较少的参数或需要可选参数。
- 如有一个URL为/users?id=123

@GetMapping("/users")
public ResponseEntity<User> getUser(@RequestParam("id") int id) {
    // 根据id获取用户信息
}

@RequestBody用于接收请求体中的数据，适用于接收复杂的数据类型。
- POST方式便为接收请求体中的数据

@PostMapping("/users")
public ResponseEntity<User> createUser(@RequestBody User user) {
    // 创建用户
}

Javaweb常用对象获取

获得Javaweb常见原生对象，有时在我们的Controller方法中需要用到Javaweb的原生对象，例如：Request、Response等，我们只需要将需要的对象以形参的形式写在方法上，SpringMVC框架在调用Controller方法时，会自动传递实参：

@GetMapping("/javawebObject")
public String javawebObject(HttpServletRequest request, HttpServletResponse response, 
HttpSession session){
 System.out.println(request);
 System.out.println(response);
 System.out.println(session);
 return "/index.jsp";
}

请求静态资源

静态资源请求失效的原因，当DispatcherServlet的映射路径配置为 / 的时候，那么就覆盖的Tomcat容器默认的缺省Servlet， url-pattern配置为 / 的Servlet我们称其为缺省的Servlet，作用是当其他Servlet都匹配不成功时，就找缺省的Servlet ，静态资源由于没有匹配成功的Servlet，所以会找缺省的DefaultServlet，该DefaultServlet具备二次去匹配静态资源的功能。

但是我们配置DispatcherServlet后就将其覆盖掉了，而DispatcherServlet会将请求的静态资源的名称当成Controller的映射路径去匹配，即静态资源访问不成功了

静态资源请求的三种解决方案：

第一种方案，可以再次激活Tomcat的DefaultServlet，Servlet的url-pattern的匹配优先级是：精确匹配>目录匹配>扩展名匹配>缺省匹配，所以可以指定某个目录下或某个扩展名的资源使用DefaultServlet进行解析：

<servlet-mapping>
 <servlet-name>default</servlet-name>
 <url-pattern>/img/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
 <servlet-name>default</servlet-name>
 <url-pattern>*.html</url-pattern>
</servlet-mapping>

第二种方式，在spring-mvc.xml中去配置静态资源映射，匹配映射路径的请求到指定的位置去匹配资源

<!-- mapping是映射资源路径，location是对应资源所在的位置 -->
<mvc:resources mapping="/img/*" location="/img/"/>
<mvc:resources mapping="/css/*" location="/css/"/>
<mvc:resources mapping="/css/*" location="/js/"/>
<mvc:resources mapping="/html/*" location="/html/"/>

第三种方式，在spring-mvc.xml中去配置< mvc:default-servlet-handler >，该方式是注册了一个

DefaultServletHttpRequestHandler 处理器，静态资源的访问都由该处理器去处理，这也是开发中使用最多的

<mvc:default-servlet-handler/>

注解驱动 <mvc:annotation-driven> 标签

但我们采用上述的第二种或第三种方式时，会发现Controller无法访问了。

原因是第二种方式是通过SpringMVC去解析mvc命名空间下的resources标签完成的静态资源解析，第三种方式式通过SpringMVC去解析mvc命名空间下的default-servlet-handler标签完成的静态资源解析，根据前面所学习的自定义命名空间的解析的知识，可以发现不管是以上哪种方式，最终都会注册SimpleUrlHandlerMapping

而根据前面学过的内容，一旦SpringMVC容器中存在HandlerMapping 类型的组件时，前端控制器 DispatcherServlet在进行初始化时，就会从容器中获得HandlerMapping ，不在加载 dispatcherServlet.properties 中默认处理器映射器策略，那也就意味着RequestMappingHandlerMapping不会被加载到了

解决方法：手动注册 RequestMappingHandlerMapping

或者使用mvc注解驱动

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

该标签内部会帮我们注册RequestMappingHandlerMapping、注册 RequestMappingHandlerAdapter并注入Json消息转换器等

SpringMVC的响应处理

传统同步业务数据响应

传统同步业务在数据响应时，SpringMVC又涉及如下四种形式：

⚫ 请求资源转发；

⚫ 请求资源重定向；

⚫ 响应模型数据；

⚫ 直接回写数据给客户端；

区别：

转发是服务器内部实现的，浏览器对转发是无感知的，URL保持不变，共享原始请求信息。而重定向是浏览器发起的新的请求，URL会变化，并且不会共享原始请求的信息。
转发的处理是服务器端完成的，而重定向的处理是浏览器端完成的。
转发相对于重定向更加高效，因为它避免了浏览器的额外请求和重定向的性能消耗。但重定向更加灵活，可以处理跨域和跨服务器的请求等情况。
转发适用于服务器内部资源的调用和请求处理链的处理。重定向适用于跳转和处理不同的请求。

响应模型数据，响应模型数据本质也是转发，在转发时可以准备模型数据

    @RequestMapping("/res3")
    public ModelAndView res3(ModelAndView modelAndView){
        //ModelAndView封装模型数据和视图名
        //
        User user = new User();
        user.setUsername("qianqian");
        user.setAge("18");
        modelAndView.addObject("user",user);
        //
        modelAndView.setViewName("/index.jsp");

        return modelAndView;
    }

直接回写数据，直接通过方法的返回值返回给客户端的字符串，但是SpringMVC默认的方法返回值是视图，可以通过@ResponseBody 注解显示的告知此处的返回值不要进行视图处理，是要以响应体的方式处理的

    //直接回写字符串
    @RequestMapping("/res4")
    @ResponseBody//告诉springMVC，返回的字符串不是视图名，而是以响应体方式响应的数据
    public String res4(){
        return "hello world";
    }

前后端分离异步业务数据响应

其实此处的会写数据，跟上面回写数据给客户端的语法方式一样，只不过有如下一些区别：

⚫ 同步方式回写数据，是将数据响应给浏览器进行页面展示的，而异步方式回写数据一般是回写给Ajax引擎的，即谁访问服务器端，服务器端就将数据响应给谁

⚫ 同步方式回写的数据，一般就是一些无特定格式的字符串，而异步方式回写的数据大多是Json格式字符串

在讲解SringMVC接收请求数据时，客户端提交的Json格式的字符串，也是使用Jackson进行的手动转换成JavaBean，可以当我们使用了@RequestBody时，直接用JavaBean就接收了Json格式的数据，原理其实就是SpringMVC底层帮我们做了转换，此处@ResponseBody也可以将JavaBean自动给我们转换成Json格式字符串回响应

@GetMapping("/response5")
@ResponseBody
public User response5() throws JsonProcessingException {
 //创建JavaBean
 User user = new User();
 user.setUsername("haohao");
 user.setAge(18);
 //直接返回User对象
 return user;
}

注：@RestController注解结合了@Controller和@ResponseBody

SpringMVC的拦截器

拦截器 Interceptor 简介

SpringMVC的拦截器Interceptor规范，主要是对Controller资源访问时进行拦截操作的技术，当然拦截后可以进行权限控制，功能增强等都是可以的。拦截器有点类似 Javaweb 开发中的Filter，拦截器与Filter的区别如下图：

实现了HandlerInterceptor接口，且被Spring管理的Bean都是拦截器。HandlerInterceptor接口方法的作用及其参数、返回值详解如下：

拦截器快速入门

编写MyInterceptor01实现HandlerInterceptor接口：

public class MyInterceptor1 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor1...preHandle");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor1.postHandle");
        //HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor1.afterCompletion");
        //HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

在spring-mvc.xml中配置Interceptor

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

拦截器执行顺序

当每个拦截器都是放行状态时，三个方法的执行顺序如下：

Interceptor1,2,3之间，先配置的拦截器先执行

当Interceptor1和Interceptor2处于放行，Interceptor3处于不放行时，三个方法的执行顺序如下：

拦截器执行原理

SpringMVC的全注解开发

spring-mvc.xml 中组件转化为注解形式

利用注解配置<mvc:default-servlet-handler /> 和 <mvc:interceptor >

SpringMVC 提供了一个注解叫做 @EnableWebMvc，内部通过@Import 导入了DelegatingWebMvcConfiguration类

@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
 private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
 //从容器中注入WebMvcConfigurer类型的Bean
 @Autowired(required = false)
 public void setConfigurers(List<WebMvcConfigurer> configurers) {
 if (!CollectionUtils.isEmpty(configurers)) {
 this.configurers.addWebMvcConfigurers(configurers);
 }}
 //省略其他代码}

WebMvcConfigurer类型的Bean会被注入进来，然后被自动调用，所以可以实现WebMvcConfigurer接口，完成一些解析器、默认Servlet等的指定

创建MyWebMvcConfigurer实现WebMvcConfigurer接口，实现addInterceptors 和

configureDefaultServletHandling方法

@Component
public class MyWebMvcConfigurer implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加一个拦截器，并配置拦截路径
        registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**");
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        //开启默认的servlet处理器
        configurer.enable();
    }
}

最后，在SpringMVC核心配置类上添加@EnableWebMvc注解

DispatcherServlet加载核心配置类

DispatcherServlet在进行SpringMVC配置文件加载时，使用的是以下方式：

<!--配置springMVC前端控制器-->
<servlet>
 <servlet-name>DispatcherServlet</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <!--指定springMVC配置文件位置-->
 <init-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:spring-mvc.xml</param-value>
 </init-param>
 <!--服务器启动就创建-->
 <load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
 <servlet-name>DispatcherServlet</servlet-name>
 <url-pattern>/</url-pattern>
</servlet-mapping>

在使用SpringMVCConfig核心配置类提替代的spring-mvc.xml之后，参照Spring的 ContextLoaderListener加载核心配置类的做法，定义了一个AnnotationConfigWebApplicationContext，通过代码注册核心配置类

public class MyAnnotationConfigWebApplicationContext extends 
AnnotationConfigWebApplicationContext {
 public MyAnnotationConfigWebApplicationContext(){
 //注册核心配置类
 super.register(SpringMVCConfig.class);
 }
}

<!--指定springMVC的applicationContext全限定名 -->
<init-param>
 <param-name>contextClass</param-name>
 <param-value>com.itheima.config.MyAnnotationConfigWebApplicationContext</param-value>
</init-param>

消除web.xml

目前，几乎消除了配置文件，但是web工程的入口还是使用的web.xml进行配置的，如下：

<!--配置springMVC前端控制器-->
<servlet>
 <servlet-name>DispatcherServlet</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 <!--指定springMVC的applicationContext全限定名 -->
 <init-param>
 <param-name>contextClass</param-name>
 <param-value>com.itheima.config.MyAnnotationConfigWebApplicationContext</param-value>
 </init-param>
 <!--服务器启动就创建-->
 <load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
 <servlet-name>DispatcherServlet</servlet-name>
 <url-pattern>/</url-pattern>
</servlet-mapping>

⚫ Servlet3.0环境中，web容器提供了javax.servlet.ServletContainerInitializer接口，实现了该接口后，在对应的类加载路径的META-INF/services 目录创建一个名为javax.servlet.ServletContainerInitializer的文件，文件内容指定具体的ServletContainerInitializer实现类，那么，当web容器启动时就会运行这个初始化器做一些组件内的初始化工作；

⚫ 基于这个特性，Spring就定义了一个SpringServletContainerInitializer实现了ServletContainerInitializer接口;

⚫ 而SpringServletContainerInitializer会查找实现了WebApplicationInitializer的类，Spring又提供了一个WebApplicationInitializer的基础实现类AbstractAnnotationConfigDispatcherServletInitializer，当我们编写类继承AbstractAnnotationConfigDispatcherServletInitializer时，容器就会自动发现我们自己的类，在该类中我们就可以配置Spring和SpringMVC的入口了。

按照下面的配置就可以完全省略web.xml

public class MyAnnotationConfigDispatcherServletInitializer extends 
AbstractAnnotationConfigDispatcherServletInitializer {
 //返回的带有@Configuration注解的类用来配置ContextLoaderListener
 protected Class<?>[] getRootConfigClasses() {
 System.out.println("加载核心配置类创建ContextLoaderListener");
 return new Class[]{ApplicationContextConfig.class};
 }
 //返回的带有@Configuration注解的类用来配置DispatcherServlet
 protected Class<?>[] getServletConfigClasses() {
 System.out.println("加载核心配置类创建DispatcherServlet");
 return new Class[]{SpringMVCConfig.class};
 }
 //将一个或多个路径映射到DispatcherServlet上
 protected String[] getServletMappings() {
 return new String[]{"/"};
 }
}

SpringMVC的组件原理剖析

前端控制器初始化

前端控制器DispatcherServlet是SpringMVC的入口，也是SpringMVC的大脑，主流程的工作都是在此完成的，梳理一下DispatcherServlet 代码。DispatcherServlet 本质是个Servlet，当配置了 load-on-startup 时，会在服务器启动时就执行创建和执行初始化init方法，每次请求都会执行service方法

DispatcherServlet 的初始化主要做了两件事：

⚫ 获得了一个 SpringMVC 的 ApplicationContext容器；

⚫ 注册了 SpringMVC的九大组件。

父容器和子容器概念和关系：

⚫ 父容器：Spring 通过ContextLoaderListener为入口产生的applicationContext容器，内部主要维护的是applicationContext.xml（或相应配置类）配置的Bean信息；

⚫ 子容器：SpringMVC通过DispatcherServlet的init() 方法产生的applicationContext容器，内部主要维护的是spring-mvc.xml（或相应配置类）配置的Bean信息，且内部还通过parent属性维护这父容器的引用。

⚫ Bean的检索顺序：根据上面子父容器的概念，可以知道Controller存在与子容器中，而Controller中要注入Service时，会先从子容器本身去匹配，匹配不成功时在去父容器中去匹配，于是最终从父容器中匹配到的UserService，这样子父容器就可以进行联通了。但是父容器只能从自己容器中进行匹配，不能从子容器中进行匹配。

前端控制器执行主流程

SpringMVC的异常处理机制

SpringMVC 异常的处理流程

SpringMVC 的异常处理方式

SpringMVC 提供了以下三种处理异常的方式：

⚫ 简单异常处理器：使用SpringMVC 内置的异常处理器处SimpleMappingExceptionResolver；

⚫ 自定义异常处理器：实现HandlerExceptionResolver接口，自定义异常进行处理；

⚫ 注解方式：使用@ControllerAdvice + @ExceptionHandler 来处理。

注解方式配置简单映射异常处理器

@Bean
public SimpleMappingExceptionResolver simpleMappingExceptionResolver(){
 //创建SimpleMappingExceptionResolver
 SimpleMappingExceptionResolver resolver = new SimpleMappingExceptionResolver();
 //设置默认错误展示视图
 resolver.setDefaultErrorView("/error.html");
 //定义Properties设置特殊异常对应的映射视图
 Properties properties = new Properties();
 properties.setProperty("java.lang.RuntimeException","/error.html");
 properties.setProperty("java.io.FileNotFoundException","/io.html");
 resolver.setExceptionMappings(properties);
 return resolver;
}

自定义异常处理器，实现HandlerExceptionResolver接口自定义异常处理器，可以完成异常逻辑的处理

@Component
public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
 @Override
 //参数Object是当前目标方法处理器对象HandlerMethod
 public ModelAndView resolveException(HttpServletRequest httpServletRequest, 
HttpServletResponse httpServletResponse, Object o, Exception e) {
 ModelAndView modelAndView = new ModelAndView();
 modelAndView.setViewName("/error.html");
 return modelAndView;
 }
}

使用注解 @ControllerAdvice + @ExceptionHandler 配置异常，@ControllerAdvice 注解本质是一个@Component，也会被扫描到，与此同时，具备AOP功能，默认情况下对所有的Controller都进行拦截操作，拦截后干什么呢？就需要在结合@ExceptionHandler、@InitBinder、

@ModelAttribute 注解一起使用了，此处我们讲解的是异常，所以是@ControllerAdvice + @ExceptionHandler的组合形式。

编写全局异常处理器类，使用@ControllerAdvice标注，且@ExceptionHandler指定异常类型

@ControllerAdvice
public class GlobalExceptionHandler {
 @ExceptionHandler(RuntimeException.class)
 public ModelAndView runtimeHandleException(RuntimeException e){
 System.out.println("全局异常处理器执行...."+e);
 ModelAndView modelAndView = new ModelAndView("/error.html");
 return modelAndView;
 }
 @ExceptionHandler(IOException.class)
 @ResponseBody
 public ResultInfo ioHandleException(IOException e){
 //模拟一个ResultInfo
 ResultInfo resultInfo = new ResultInfo(0,"IOException",null);
 return resultInfo;
 }
}

如果全局异常处理器响应的数据都是Json格式的字符串的话，可以使用@RestControllerAdvice替代@ControllerAdvice 和 @ResponseBody