SpringMVC学习笔记——2

一、SpringMVC的拦截器

1.1、拦截器Interceptor简介

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

	Filter技术	lnterceptor技术
技术范畴	Javaweb原生技术	SpringMVC框架技术
拦截/过滤资源	可以对所有请求都过滤，包括任何servlet、Jsp、其他资源等	只对进入了SpringMVc管辖范围的才拦截，主要拦截Controller请求
执行时机	早于任何Servlet执行	晚于DispatcherServlet执行

实现了HandlerInterceptor接口，且被Spring管理的Bean都是拦截器，接口定义如下:

public interface HandlerInterceptor {
	default boolean preHandle (HttpServletRequest request，HttpServletResponse response，Objecthandler)throws Exception {
		return true;
	}
	default void postHandle (HttpServletRequest request，HttpServletResponse response，Objecthandler，@Nullable ModelAndView modelAndView) throws Exception {
	}
	default void afterCompletion (HttpServletRequest request，HttpServletResponse response,0bject handler,@Nullable Exception ex) throws Exception{
	}

Handlerlnterceptor接口方法的作用及其参数、返回值详解如下:

	作用	参数	返回值
preHandle	对拦截到的请求进行预处理，返回true放行执行处理器方法，false不放行	Handler是拦截到的Controller方法处理器	—旦返回false，代表终止向后执行，所有后置方法都不执行，最终方法只执行对应preHandle返回了true的
postHandle	在处理器的方法执行后，对拦截到的请求进行后处理，可以在方法中对模型数据和视图进行修改	Handler是拦截到的Controller方无法处理器;modelAndView是返回的模型视图对象	无
afterCompletion	视图渲染完成后(整个流程结束之后)，进行最后的处理，如果请求流程中有异常，可以处理异常对象	Handler是拦截到的Controller方法处理器;ex是异常对象	无

1.2、拦截器快速入门

1. 实现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;//true放行 false不放行
    }

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

    }

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

2. 配置Interceptor的相关的bean

<!--向容器中注入静态资源处理器-->
<mvc:default-servlet-handler/>

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--要对那些请求路径进行拦截-->
        <mvc:mapping path="/**"/>
        <bean class="com.Smulll.interceptors.MyInterceptor1"></bean>
    </mvc:interceptor>
</mvc:interceptors>

1.3、拦截器执行顺序

拦截器执行顺序取决于interceptor的配置顺序

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--要对那些请求路径进行拦截-->
        <mvc:mapping path="/**"/>
        <bean class="com.Smulll.interceptors.MyInterceptor1"></bean>
    </mvc:interceptor>
        <mvc:interceptor>
        <!--要对那些请求路径进行拦截-->
        <mvc:mapping path="/**"/>
        <bean class="com.Smulll.interceptors.MyInterceptor2"></bean>
    </mvc:interceptor>
</mvc:interceptors>

拦截器三个方法的执行顺序

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

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

1.4、拦截器执行原理

二、SpringMVC的全注解开发

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

2.1.1、消除spring-mvc.xml

<!--组件扫描-->
<context:component-scan base-package="com.Smulll.Controller"/>

<!--非自定义的Bean-->
<bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver" >
    <property name="defaultEncoding" value="UTF-8"/>
    <property name="maxUploadSize" value="5000000"/>
</bean>

@Configuration
@ComponentScan("com.Smulll.Controller")
public class SpringMVCConfig {
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
        commonsMultipartResolver.setDefaultEncoding("UTF-8");
        commonsMultipartResolver.setMaxUploadSize(5000000);
        return commonsMultipartResolver;
    }
}

<mvc:annotation-driven>、<mvc:default-servlet-handler />和<mvc:interceptor>怎么办呢? SpringMVC提
供了一个注解 @EnableWebMvc，我们看一下源码，内部通过@Import 导入了DelegatingWebMvcConfiguration类

@Retention (RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({DelegatingWebMvcConfiguration.class})
public @interface EnablewebMvc {}

@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);
	}}
	//省略其他代码}

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

public interface webMvcConfigurer {
	//配置默认servet处理器
	default void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer)( )
	//添加拦截器
	default void addInterceptors(InterceptorRegistry registry){ }
	//添加资源处理器
	default void addResourceHandlers(ResourceHandlerRegistry registry){ }
	//添加视图控制器
	default void addViewControllers(ViewControllerRegistry registry){ }
	//配置视图解析器
	default void configureViewResolvers(ViewResolverRegistry registry) { }
	//添加参数解析器
	default void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers){ }
	// ...省略其他代码...
}

创建MyWebMvcConfigurer实现WebMvcConfigurer接口，实现addInterceptors和configureDefaultServletHandling方法

@Component
public class MywWebMvcConfigurer implements webMvcConfigurer {
	@Override
	public void configureDefaultServletHandling (DefaultServletHandlerConfigurer configurer) {
		//开启Defaultservlet，可以处理静态资源了
		configurer.enable ();
	}
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		//创建拦截器对象，进行注册
		//Interceptor的执行顺序也取决于添加顺序
		registry.addInterceptor(new MyInterceptor01()).addPathPatterns("/*");
	}
}

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

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

<!--加载SpringMVC核心配置文件-->
<init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mvc.xml</param-value>
</init-param>

<!--加载SpringMVC核心配置类-->
<init-param>
    <param-name>contextClass</param-name>
    <param-value>com.Smulll.Config.MyAnnotationConfigWebApplicationContext</param-value>
</init-param>

2.1.2、消除web.xml

• Servlet3.0环境中，web容器提供了javax.servlet.ServletContainerlnitializer接口，实现了该接口后，在对应的类加载路径的META-INF/services目录创建一个名为javax.servlet.ServletContainerlnitializer的文件，文件内容指定具体的ServletContainerInitializer实现类，那么，当web容器启动时就会运行这个初始化器做一些组件内的初始化工作;
• 基于这个特性，Spring就定义了一个SpringServletContainerInitializer实现了ServletContainerInitializer接口;
• 而SpringServletContainerlnitializer会查找实现了WebApplicationInitializer的类，Spring又提供了一个WebApplicationInitializer的基础实现类AbstractAnnotationConfigDispatcherServletInitializer，当我们编写类继承AbstractAnnotationConfigDispatcherServletlnitializer时，容器就会自动发现我们自己的类，在该类中我们就可以配置Spring和SpringMVC的入口了。

public class MyAbstractAnnotationConfigDispatcherServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        //提供spring容器的核心配置类
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        //提供springMVC容器的核心配置类
        return new Class[]{SpringMVCConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        //提供前端控制器的映射路径
        return new String[]{"/"};
    }
}

三、SpringMVC的组件原理剖析

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

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

• 获得了一个SpringMVC的 ApplicationContext容器;
• 注册了SpringMVC的九大组件。

四、SpringMVC的异常处理机制

4.1、SpringMVC异常的处理流程

异常分为编译时异常和运行时异常，编译时异常我们try-cache进行捕获，捕获后自行处理，而运行时异常是不可预期的，就需要规范编码来避免，在SpringMVC中，不管是编译异常还是运行时异常，都可以最终由
SpringMVC提供的异常处理器进行统一处理，这样就避免了随时随地捕获处理的繁琐性。

当然除了繁琐之外，我们在进行前后端分离异步开发时，往往返回统一格式的结果给客户端，例如:
{'code" :200," message " " ",“data”:[“username” “haohao” “age”:null}，即使报异常了，也不能把状态码500直接扔给客户端丢给用户，需要将异常转换成符合上面格式的数据响应给客户端更友好。

SpringMVC处理异常的思路是，一路向上抛，都抛给前端控制器DispatcherServlet ，DispatcherServlet在调用异常处理器ExceptionResolver进行处理，如下图:

4.2、SpringMVC的异常处理方式

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

• 简单异常处理器：使用SpringMVC内置的异常处理器处理SimpleMappingExceptionResolver;
• 自定义异常处理器：实现HandlerExceptionResolver接口，自定义异常进行处理
• 注解方式：使用 @ControllerAdvice+@ExceptionHandler来处理

4.2.1、简单异常处理器

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

@Bean
public SimpleMappingExceptionResolver simpleMappingExceptionResolver(){
    SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
    //不管什么异常，统一响应友好页面
    simpleMappingExceptionResolver.setDefaultErrorView("/error.jsp");

    Properties properties = new Properties();//键值对，key：异常对象的全限定名，value：你要跳转的视图名
    properties.setProperty("java.lang.RuntimeException","/error.jsp");
    properties.setProperty("java.io.FileNotFoundException","/error2.jsp");
    simpleMappingExceptionResolver.setExceptionMappings(properties);
    return simpleMappingExceptionResolver;
}

4.2.2、自定义异常处理器

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

@Component
public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {

        //简单的相应一个友好提示页面
        /*ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/error.jsp");*/

        //前后端分离开发，响应json格式的字符串{"code":0,"message":"","data":""}
        String resultJson = "{\"code\":0,\"message\":\"\",\"data\":\"\"}";
        try {
            httpServletResponse.getWriter().write(resultJson);
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
        return null;
    }
}

4.2.3、注解方式

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public ModelAndView runtimeExceptionResolverMethod(RuntimeException ex){
        System.out.println(ex);
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/error.jsp");
        return modelAndView;
    }

    @ExceptionHandler(IOException.class)
    @ResponseBody
    public Result IOExceptionResolverMethod(IOException ex){
        System.out.println(ex);

        Result result = new Result(0,"","");
        return result;
    }
}

4.3、SpringMVC常用的异常解析器

接口或类	说明
HandlerExceptionResolver	异常处理器类的顶级接口，实现了该接口的类都会作为异常处理器类
MyHandlerExceptionResolver	自定义的处理器类，实现了HandlerExceptionResolver接口
HandlerExceptionResolverComposite	异常解析器混合器，内部存在集合存储多种异常解析器
SimpleMappingExceptionResolver	简单映射异常处理器，可以配置异常与对应的错误视图
ExceptionHandlerExceptionResolver	异常处理器异常解析器，默认会被注册到spring容器中，@ExceptionHandler方式异常处理就是该解析器解析的
DefaultHandlerExceptionResolver	默认处理器异常解析器，所有异常处理器都不匹配时，最后执行的异常处理器
ResponseStatusExceptionResolver	响应状态异常解析器，结合使用@ResponseStatus标注的异常使用

HandlerExceptionResolverComposite 内部包含ExceptionHandlerExceptionResolver，DefaultHandlerExceptionResolver ，ResponseStatusExceptionResolver