Spring MVC添加拦截器和转换器

阅读数:0次 2022-05-09

字数统计: 2.1k字 | 阅读时长≈ 10分

目前Java的后端开发基本都会用Spring MVC，在SpringBoot的封装里，拦截器如何添加网上教程千篇一律，即使寻找官方的文档，也只有一种比较死板, 如何灵活添加拦截器呢？下面会介绍5种方式。

Spring MVC添加拦截器

目前Java的后端开发基本都会用Spring MVC，在SpringBoot的封装里，拦截器如何添加网上教程千篇一律，即使寻找官方的文档，也只有一种比较死板的添加方式，如下：

@EnableWebMvc
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LogInterceptor()).addPathPatterns("/**").order(1);
    }
}

当我要实现在项目启动加载配置时，灵活配置拦截器这种方法就没这么优雅了。所以为了本文提供多种方式注册拦截器。转换器思路一致所以本文仅仅介绍拦截器。

首先我们先来看下spring mvc拦截器原理是怎样的。

理解springMVC 拦截器设置原理

我们知道springMVC真正设置拦截器的时候是在AbstractHandlerMapping中执行的initApplicationContext方式（可查看看透springMVC-142页）所以我们跟一下该方法。方式一中也仅仅是把我们定义的拦截器设置到AbstractHandlerMapping的interceptors中。

public abstract class AbstractHandlerMapping extends WebApplicationObjectSupport
    implements HandlerMapping, Ordered, BeanNameAware {
    // initApplicationContext
    @Override
    protected void initApplicationContext() throws BeansException {
        // 扩展拦截器(是模饭方法 ，用于给子类提供-个添加 (或者修改) IÍ1terceptors 的人 口 ，不过在现有 Spring MVC 的实现中并没有使用 )
        extendInterceptors(this.interceptors);
        // 检测容器中 MappedInterceptor类型的bean，并添加到映射的拦截器列表
        detectMappedInterceptors(this.adaptedInterceptors);
        // 初始化拦截器（将所有的interceptors设置到adaptedInterceptors中）
        initInterceptors();
    }

    public void setInterceptors(Object... interceptors) {
        this.interceptors.addAll(Arrays.asList(interceptors));
    }

    // 将符合规范的拦截器interceptors添加到adaptedInterceptors
    protected void initInterceptors() {
        if (!this.interceptors.isEmpty()) {
            for (int i = 0; i < this.interceptors.size(); i++) {
                Object interceptor = this.interceptors.get(i);
                if (interceptor == null) {
                    throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");
                }
                this.adaptedInterceptors.add(adaptInterceptor(interceptor));
            }
        }
    }
}

通过initApplicationContext可以发现springMVC设置到interceptors中的拦截器最终都会存储在adaptedInterceptors中。springMVC可以从3个地方将拦截器设置到interceptors，并且最终通过initInterceptors方法将interceptors中拦截器设置到adaptedInterceptors中：

创建子类的时候通过setInterceptors方法将拦截器设置到interceptors中（方式一springMVC配置就是通过该机制）
子类实现的扩展拦截器extendInterceptors，允许子类将一些拦截器设置到interceptors中
从spring 容器中获取到所有的MappedInterceptor设置到interceptors中

所以这里就出现了方式2 向spring中注入MappedInterceptor类型的拦截器。

这里补充一点，spring是在哪里使用拦截器的：

public abstract class AbstractHandlerMapping extends WebApplicationObjectSupport
    implements HandlerMapping, Ordered, BeanNameAware {

    private final List<Object> interceptors = new ArrayList<>();

    private final List<HandlerInterceptor> adaptedInterceptors = new ArrayList<>();

    @Override
    @Nullable
    public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        Object handler = getHandlerInternal(request);
        if (handler == null) {
            handler = getDefaultHandler();
        }
        if (handler == null) {
            return null;
        }
        // Bean name or resolved handler?
        if (handler instanceof String) {
            String handlerName = (String) handler;
            handler = obtainApplicationContext().getBean(handlerName);
        }

        // 获取HandlerExecutionChain
        HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

        if (logger.isTraceEnabled()) {
            logger.trace("Mapped to " + handler);
        }
        else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
            logger.debug("Mapped to " + executionChain.getHandler());
        }

        if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
            CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
            CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
            config = (config != null ? config.combine(handlerConfig) : handlerConfig);
            executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
        }

        return executionChain;
    }

    protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
        HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
                                       (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

        String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, LOOKUP_PATH);
        // 查找拦截器是通过adaptedInterceptors，而不是interceptors
        for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
            if (interceptor instanceof MappedInterceptor) {
                MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
                if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
                    chain.addInterceptor(mappedInterceptor.getInterceptor());
                }
            }
            else {
                chain.addInterceptor(interceptor);
            }
        }
        return chain;
    }
    // 忽略后面
}

方式1

利用springMVC提供的WebMvcConfigurer，实现多个WebMvcConfigurer。利用的是创建handlerMapping的时候通过setInterceptors方法将拦截器设置到interceptors中

@EnableWebMvc
@Configuration
public class WebMvcConfigAddInterceptors implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestInterceptor3()).addPathPatterns("/**").order(1);
    }
}


@EnableWebMvc
@Configuration
public class WebMvcConfigAddInterceptors2 implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestInterceptor4()).addPathPatterns("/**").order(1);
    }
}

这种方式原理是：@EnableWebMvc当使用该注解后会Import DelegatingWebMvcConfiguration该类会扫描spring容器中所有的WebMvcConfigurer，然后调用所有的WebMvcConfigurer的addInterceptors方法将所有的拦截器注入到InterceptorRegistry中，之后在spring配置的WebMvcConfigurationSupport#requestMappingHandlerMapping中使用InterceptorRegistry并将其配置到相应的HandlerMapping上即可。（注册转换器原理一致）

所以这里注册转换器或者拦截器的方式一出现了，实现多个WebMvcConfigurer（控制WebMvcConfigurer顺序可以使用@Order或者Ordered接口）

方式2

向spring中注入MappedInterceptor类型的拦截器。利用的是AbstractHandlerMapping#detectMappedInterceptors方法

@Configuration
public class MappedInterceptorConfiguration implements ApplicationContextAware {

    @Bean
    @Order(value = 13)
    public MappedInterceptor test2() {
        final TestInterceptor2 testInterceptor = new TestInterceptor2();
        return new MappedInterceptor(StringUtils.toStringArray(Collections.singletonList("/**")), null, testInterceptor);
    }

    @Bean
    @Order(value = 1)
    public MappedInterceptor test1() {
        final TestInterceptor testInterceptor = new TestInterceptor();
        return new MappedInterceptor(StringUtils.toStringArray(Collections.singletonList("/**")), null, testInterceptor);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        final Collection<MappedInterceptor> values = BeanFactoryUtils.beansOfTypeIncludingAncestors(
                applicationContext, MappedInterceptor.class, true, false).values();
        System.out.println();
    }

    @Bean
    @Order(value = 1)
    public Integer test3(List<MappedInterceptor> list) {
        System.out.println();
        return 1;
    }

}

方式3

根据配置添加拦截器时.采用springBoot的@Conditional注解。同方式二，利用了springboot 特性

@Bean
@Order(value = 1)
@ConditionalOnProperty(value = {"interceptor.enable"}, havingValue = "false", matchIfMissing = true)
public MappedInterceptor test5() {
    final TestInterceptor5 testInterceptor = new TestInterceptor5();
    return new MappedInterceptor(StringUtils.toStringArray(Collections.singletonList("/**")), null, testInterceptor);
}

方式4

利用spring aop功能。采用AOP拦截处理的方式

@Slf4j
@Aspect
@Component
@SuppressWarnings("unused")
public class InterceptorAspect {

    private final String pCutStr = "execution(* org.springframework.web.servlet.config.annotation..WebMvcConfigurationSupport.requestMappingHandlerMapping(..))";

    @Pointcut(pCutStr)
    public void pointCut() {
    }

    @Before(value = "pointCut()")
    public void before(JoinPoint joinPoint) {
    }

    @After(value = "pointCut()")
    public void after(JoinPoint joinPoint) {
    }

    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.debug("执行方法前");
        final Object proceed = joinPoint.proceed();
        log.debug("执行方法后");
        return proceed;
    }

    @AfterReturning(value = "pointCut()", returning = "returnValue")
    public void afterReturning(JoinPoint joinPoint, Object returnValue) {
        RequestMappingHandlerMapping handlerMapping = null;
        if (returnValue instanceof RequestMappingHandlerMapping) {
            handlerMapping = (RequestMappingHandlerMapping) returnValue;
        }
        CustomAssert.notNull(handlerMapping, CustomExceptionSupplier.get("系统错误，SpringMVC获取配置错误"));
        final CustomInterceptorRegistry interceptorRegistry = new CustomInterceptorRegistry();
        interceptorRegistry.addInterceptor(new TestInterceptor6()).order(1);
        handlerMapping.setInterceptors(interceptorRegistry.getInterceptors().toArray());
    }


    public static class CustomInterceptorRegistry extends InterceptorRegistry {

        public CustomInterceptorRegistry() {
            super();
        }

        @NotNull
        @Override
        protected List<Object> getInterceptors() {
            return super.getInterceptors();
        }
    }


}

方式5

利用反射的方式。参考了 Spring MVC从源码分析到实践如何动态添加拦截器

@Configuration
@Slf4j
public class JwtInterceptorRegistryConfig {

    @Autowired
    public void configRequestMappingHandlerMapping(RequestMappingHandlerMapping requestMappingHandlerMapping) {
        SpringMvcPolyfill.addDynamicInterceptor(new JwtTokenInterceptor(), Collections.singletonList("/**"), null, requestMappingHandlerMapping);
    }
}

@Slf4j
public class SpringMvcPolyfill {

    /**
     * 缓存反射字段
     */
    private static Field adaptedInterceptorsField;

    /**
     * 动态添加拦截器
     * @param interceptor       拦截器
     * @param includeURLs       需要拦截的URL
     * @param excludeURLs       排除拦截的URL
     * @param handlerMapping    AbstractHandlerMapping实现类
     */
    @SuppressWarnings("all")
    public static void addDynamicInterceptor(HandlerInterceptor interceptor, List<String> includeURLs, List<String> excludeURLs, AbstractHandlerMapping handlerMapping) {
        String[] include = StringUtils.toStringArray(includeURLs);
        String[] exclude = StringUtils.toStringArray(excludeURLs);
        // Interceptor -> MappedInterceptor
        MappedInterceptor mappedInterceptor = new MappedInterceptor(include, exclude, interceptor);
        // 下面这行可以省略，但为了保持内部的处理流程，使表达式成立：interceptors.count() == adaptedInterceptors.count()
        handlerMapping.setInterceptors(mappedInterceptor);
        try {
            if (adaptedInterceptorsField == null) {
                // 虽然用了反射，但这些代码在只在启动时加载
                // 查找继承链
                // RequestMappingHandlerMapping -> RequestMappingInfoHandlerMapping -> AbstractHandlerMethodMapping -> AbstractHandlerMapping
                // WelcomePageHandlerMapping -> AbstractUrlHandlerMapping -> AbstractHandlerMapping
                Class<?> abstractHandlerMapping = handlerMapping.getClass();
                while (abstractHandlerMapping != AbstractHandlerMapping.class) {
                    abstractHandlerMapping = abstractHandlerMapping.getSuperclass();
                }
                adaptedInterceptorsField = abstractHandlerMapping.getDeclaredField("adaptedInterceptors");
                adaptedInterceptorsField.setAccessible(true);
            }
            // 添加到可采纳的拦截器列表，让拦截器处理器Chain流程获取得到这个拦截器
            List<HandlerInterceptor> handlerInterceptors = (List<HandlerInterceptor>) adaptedInterceptorsField.get(handlerMapping);
            handlerInterceptors.add(mappedInterceptor);
            adaptedInterceptorsField.set(handlerMapping, handlerInterceptors);
        } catch (Exception e) {
            log.error("SpringMvcPolyfill invoke AbstractHandlerMapping.adaptedInterceptors error with msg: {}",  e.getMessage(), e);
        }
    }
}

拦截器

@Slf4j
public class TestInterceptor extends HandlerInterceptorAdapter{

    @Override
    public void afterCompletion(@NotNull HttpServletRequest request, @NotNull HttpServletResponse response, @NotNull Object handler, Exception ex) {
        log.debug("afterCompletion");
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("preHandle");
        return super.preHandle(request, response, handler);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("postHandle");
        super.postHandle(request, response, handler, modelAndView);
    }
}

方式比较

方式一可以设置拦截器的优先级，方式二则不行即使使用@Order类也不行，原因在于如果是利用spring @Autowired则可以获取到排完序的列表，但是springMVC中使用 BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, MappedInterceptor.class, true, false).values()并没有排序。所以推荐使用方式1。关于spring bean加载顺序可以去看下@Bean处理也许可以根据方法先后顺序进行控制。

参考

1
2

《看透springMVC》
http://www.yizzuide.pub/2020/03/30/Spring%20MVC%E4%BB%8E%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E5%88%B0%E5%AE%9E%E8%B7%B5%E5%A6%82%E4%BD%95%E5%8A%A8%E6%80%81%E6%B7%BB%E5%8A%A0%E6%8B%A6%E6%88%AA%E5%99%A8/

本文作者： 初心
本文链接： http://funzzz.fun/2022/05/09/MVC从源码分析到实践如何动态添加拦截器/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！