小黑子—springMVC：第二章 拦截器、全注解开发和异常处理机制

4、小黑子的springMVC拦截器

4.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是异常对象	无

4.2 拦截器快速入门

1. 实现HandlerInterceptor接口，并且重写方法

   public class MyInterceptor1 implements HandlerInterceptor {
   	@Override
   	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       	System.out.println("MyInterceptor1....preHandlew");
       	return true;
   	}
   
   	@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:interceptors>
      	 <mvc:interceptor>
   <!--            path代表对哪些请求路径进行拦截 -->
           	<mvc:mapping path="/**"/>
           	<bean class="com.itheima.interceptors.MyInterceptor1"/>
      	 </mvc:interceptor>
    </mvc:interceptors>
   

    @GetMapping("/ajax/req3")
//    @ResponseBody
    public User res3() throws JsonProcessingException {
        System.out.println("/ajax/req3执行");
        //设置模型数据
        User user = new User();
        user.setUsername("magua");
        user.setAge(20);

        return user;
    }

4.3 拦截器执行顺序

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

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

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

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

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

4.4 拦截器执行原理

拦截器执行原理

4.5 拦截器参数

5、小黑子的springMVC全注解开发

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

5.1.1 消除spring-mvc.xml

一

<!--    组件扫描-->
    <context:component-scan base-package="com.itheima.controller"/>
    <!--配置文件上传解析器，注意:id的名字是固定写法-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="UTF-8"/><!--文件的编码格式默认是Iso8859-1-->
        <property name="maxUploadSizePerFile" value="500000"/><!--上传的每个文件限制的大小单位字节-->
    </bean>

@Configuration
//表示这个类是Spring的一个配置类。@Configuration注解能够替代Spring的applicationContext.xml文件，并且被@Configuration注解标注的类，能够自动注册到IOC容器并进行实例化
@ComponentScan("com.itheima.config")
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 MyWebMvcConfigurer implements WebMvcConfigurer {
  	@Override
  	public void configureDefaultServletHandling (DefaultServletHandlerConfigurer configurer) {
      	//开启默认的Servlet处理器，Defaultservlet，可以处理静态资源了
      	configurer.enable ();
   }
  	@Override
  	public void addInterceptors(InterceptorRegistry registry) {
      	//创建拦截器对象，进行注册
      	//Interceptor的执行顺序也取决于添加顺序
      	//添加一个拦截器，并配置拦截路径
      	registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**");
   }
  }
  

三

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

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

web.xml

  <!--    配置DispatcherServlet-->
  <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>-->

    <!--加载SpringMVC核心配置类，指定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>

5.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的入口了。

使用前，先把web.xml文件删除，要不然tomcat会报错扫描多个包，无法运行

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

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

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

6、小黑子的springMVC组件原理刨析

6.1 前端控制器初始化

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

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

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

6.2 前端控制器执行主流程

前端控制器执行主流程

7、小黑子的springMVC异常处理机制

7.1 SpringMVC异常的处理流程

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

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

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

7.2 SpringMVC异常处理方式

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

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

7.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;
}

@RestController
public class ExceptionController {

    @RequestMapping("/ex1")
    public String exceptionMethod1(){
        int i =1/0;
        return "Hello Exception 1/0";
    }

    @RequestMapping("/ex2")
    public String exceptionMethod2() throws FileNotFoundException {
        FileInputStream fis = new FileInputStream("C:xxxx");
        return "Hello Exception C:xxxx";
    }

}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>对不起，网络繁忙，请稍后重试111111！！！！!</h2>
</body>
</html>

7.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;
    }
}

public class Result {
    private Integer code;
    private String message;
    private Object data;

    public Result() {
    }

    public Result(Integer code, String message, Object data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", message='" + message + '\'' +
                ", data=" + data +
                '}';
    }
}

7.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;
    }
}

这种方式在开发中用的是比较多的

7.3 异常处理方式原理刨析

异常处理方式原理刨析

7.4 SpringMVC常用的异常解析器

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

HandlerExceptionResolverComposite 内部包含ExceptionHandlerExceptionResolver，DefaultHandlerExceptionResolver ，ResponseStatusExceptionResolver