SpringBoot之Filter注册_springboot 注册filter

作者：黑客灵魂 | 2024-08-03 07:01:05

踩

springboot 注册filter

SpringBoot中是可以自行注册Filter的，在SpringBoot中有几种注册Filter的方式。

一、通过org.springframework.boot.web.servlet.FilterRegistrationBean注册


@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new MyFilter2());
        bean.addUrlPatterns("/*");
        return bean;
    }
 
   @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new MyFilter1());
        bean.addUrlPatterns("/*");
        return bean;
    }
}
 
public class MyFilter1 implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    }
 
    @Override
    public void destroy() {
    }
}
 
public class MyFilter2 implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    }
 
    @Override
    public void destroy() {
    }
}

二、通过 @WebFilter + @ServletComponentScan 注解实现


@Order(1)
@WebFilter(urlPatterns = "*.json", filterName = "reqResFilter")
public class ReqResFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) 
　　　　　　　　　　　　　　　　　throws IOException, ServletException {
    }
 
    @Override
    public void destroy() {
    }
}
 
@SpringBootApplication
@ServletComponentScan(basePackages = "com.dm.base.filter")
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

关于这两个注解有如下说明：

When using an embedded container, automatic registration of @WebServlet, @WebFilter, and @WebListener annotated classes can be enabled using @ServletComponentScan.

使用嵌入式容器时，可以使用@ServletComponentScan启用@WebServlet，@ WebFilter和@WebListener注释类的自动注册。

@ServletComponentScan will have no effect in a standalone container, where the container’s built-in discovery mechanisms will be used instead.

如果使用外置容器的话，就不需要使用这条注解，因为外置容器的内置发现机制将会替代这个注解的效果。

上面有使用@Order注解指定一个int值，越小越先执行。很多博客文章都是这么说的，但你真正的试了吗？真的可以使用这个注解指定顺序吗？答案是否定的。经过测试，发现 @Order 注解指定 int 值没有起作用，是无效的。为啥？因为看源码发现 @WebFilter 修饰的过滤器在加载时，没有使用 @Order 注解，而是使用的类名来实现自定义Filter顺序，所以这种方式下想定义Filter的顺序，就必须限定 Filter 的类名，比如刚才那个 Filter 叫 ReqResFilter ，加入我们现在新写了一个 Filter 叫 AlibabaFilter ，那么顺序就是 AlibabaFilter > ReqResFilter 。所以这种方式虽然实现起来简单，只需要注解，但自定义顺序就必须要限定类名，使用类名达到排序效果了。

三、Servlet对Filter处理

上面说的都是SpringBoot对Filter提供的使用方式，但是对于Servlet容器来讲，处理方式应该是统一的，毕竟SpringBoot最终还是会调用Servlet容器的接口来实现。首先来说，Filter处理逻辑是在DispatcherServlet之前的，也就是说，如果到了DispatcherServlet了，说明所有Filter逻辑已经处理完毕了。

spring boot默认的几个filter，按先后顺序分别是，可以看到他们的顺序都是依赖一个int类型的order变量决定的，数值越小，优先级越高。


// 编码过滤器
public class OrderedCharacterEncodingFilter extends CharacterEncodingFilter implements OrderedFilter {
        // -2147483648
	private int order = Ordered.HIGHEST_PRECEDENCE;
    ...
}
 
// Form内容处理过滤器
public class OrderedFormContentFilter extends FormContentFilter implements OrderedFilter {
    // -9900
	private int order = DEFAULT_ORDER;
    
}
 
// 请求的上下文环境处理了过滤器
public class OrderedRequestContextFilter extends RequestContextFilter implements OrderedFilter {
        // -105
	private int order = REQUEST_WRAPPER_FILTER_MAX_ORDER - 105;
    
}

那我们自定义的filter顺序由谁决定？可以探索一下，首先我们知道，顺序是按照filterChain变量里的filter依次执行的，所以我们需要知道filterChain是如何创建的？每次请求都会重新生成一个filterChain。看看如下方法：

org.apache.catalina.core.ApplicationFilterFactory#createFilterChain(...)


    public static ApplicationFilterChain createFilterChain(ServletRequest request,
            Wrapper wrapper, Servlet servlet) {
 
        // If there is no servlet to execute, return null
        if (servlet == null)
            return null;
 
        // Create and initialize a filter chain object
        ApplicationFilterChain filterChain = null;
        if (request instanceof Request) {
            Request req = (Request) request;
            if (Globals.IS_SECURITY_ENABLED) {
                // Security: Do not recycle
                filterChain = new ApplicationFilterChain();
            } else {
                filterChain = (ApplicationFilterChain) req.getFilterChain();
                if (filterChain == null) {
                    filterChain = new ApplicationFilterChain();
                    req.setFilterChain(filterChain);
                }
            }
        } else {
            // Request dispatcher in use
            filterChain = new ApplicationFilterChain();
        }
 
        filterChain.setServlet(servlet);
        filterChain.setServletSupportsAsync(wrapper.isAsyncSupported());
 
        // Acquire the filter mappings for this Context
        StandardContext context = (StandardContext) wrapper.getParent();
        FilterMap filterMaps[] = context.findFilterMaps();
 
        // If there are no filter mappings, we are done
        if ((filterMaps == null) || (filterMaps.length == 0))
            return filterChain;
 
        // Acquire the information we will need to match filter mappings
        DispatcherType dispatcher =
                (DispatcherType) request.getAttribute(Globals.DISPATCHER_TYPE_ATTR);
 
        String requestPath = null;
        Object attribute = request.getAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR);
        if (attribute != null){
            requestPath = attribute.toString();
        }
 
        String servletName = wrapper.getName();
 
        // Add the relevant path-mapped filters to this filter chain
        for (FilterMap filterMap : filterMaps) {
            if (!matchDispatcher(filterMap, dispatcher)) {
                continue;
            }
            if (!matchFiltersURL(filterMap, requestPath))
                continue;
            ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
                    context.findFilterConfig(filterMap.getFilterName());
            if (filterConfig == null) {
                // FIXME - log configuration problem
                continue;
            }
            filterChain.addFilter(filterConfig);
        }
 
        // Add filters that match on servlet name second
        for (FilterMap filterMap : filterMaps) {
            if (!matchDispatcher(filterMap, dispatcher)) {
                continue;
            }
            if (!matchFiltersServlet(filterMap, servletName))
                continue;
            ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
                    context.findFilterConfig(filterMap.getFilterName());
            if (filterConfig == null) {
                // FIXME - log configuration problem
                continue;
            }
            filterChain.addFilter(filterConfig);
        }
 
        // Return the completed filter chain
        return filterChain;
    }

我们需要关注的关键点是这句代码（32行）：FilterMap filterMaps[] = context.findFilterMaps();这个数组决定了filter的顺序，这里的context是org.apache.catalina.core.StandardContext，相关的方法有2个，但是这里有关的是addFilterMapBefore(...)。一个FilterMap对应一个Filter，这个方法会被调用多次的。

StandardContext#addFilterMap()，StandardContext#addFilterMapBefore()


    @Override
    public void addFilterMapBefore(FilterMap filterMap) {
        validateFilterMap(filterMap);
        // Add this filter mapping to our registered set
        filterMaps.addBefore(filterMap);
        fireContainerEvent("addFilterMap", filterMap);
    }

接下来我们需要看看谁在调用addFilterMapBefore(...)，是下面方法

org.apache.catalina.core.ApplicationFilterRegistration#addMappingForUrlPatterns(...)。这个方法生成FilterMap并添加，所以关键点是谁调用这个方法以及其调用顺序。


@Override
public void addMappingForUrlPatterns(
        EnumSet<DispatcherType> dispatcherTypes, boolean isMatchAfter,
        String... urlPatterns) {
 
    FilterMap filterMap = new FilterMap();
 
    filterMap.setFilterName(filterDef.getFilterName());
 
    if (dispatcherTypes != null) {
        for (DispatcherType dispatcherType : dispatcherTypes) {
            filterMap.setDispatcher(dispatcherType.name());
        }
    }
 
    if (urlPatterns != null) {
        // % decoded (if necessary) using UTF-8
        for (String urlPattern : urlPatterns) {
            filterMap.addURLPattern(urlPattern);
        }
 
        if (isMatchAfter) {
            context.addFilterMap(filterMap);
        } else {
            context.addFilterMapBefore(filterMap);
        }
    }
    // else error?
 
}

找到调用地方如下org.springframework.boot.web.servlet.AbstractFilterRegistrationBean#configure(...)，这里就到了springboot控制了，他是衔接springboot和servlet的地方，需要注意下这个衔接点。


@Override
protected void configure(FilterRegistration.Dynamic registration) {
	super.configure(registration);
	EnumSet<DispatcherType> dispatcherTypes = this.dispatcherTypes;
	if (dispatcherTypes == null) {
		dispatcherTypes = EnumSet.of(DispatcherType.REQUEST);
	}
	Set<String> servletNames = new LinkedHashSet<>();
	for (ServletRegistrationBean<?> servletRegistrationBean : this.servletRegistrationBeans) {
		servletNames.add(servletRegistrationBean.getServletName());
	}
	servletNames.addAll(this.servletNames);
	if (servletNames.isEmpty() && this.urlPatterns.isEmpty()) {
		registration.addMappingForUrlPatterns(dispatcherTypes, this.matchAfter, DEFAULT_URL_MAPPINGS);
	}
	else {
                // 这里调用
		if (!servletNames.isEmpty()) {
			registration.addMappingForServletNames(dispatcherTypes, this.matchAfter,
					StringUtils.toStringArray(servletNames));
		}
		if (!this.urlPatterns.isEmpty()) {
			registration.addMappingForUrlPatterns(dispatcherTypes, this.matchAfter,
					StringUtils.toStringArray(this.urlPatterns));
		}
	}
}

也就是说这个configure(..)方法也会被调用多次，继续追查看看谁在调用他。

org.springframework.boot.web.servlet.DynamicRegistrationBean#register(...)


@Override
protected final void register(String description, ServletContext servletContext) {
	D registration = addRegistration(description, servletContext);
	if (registration == null) {
		logger.info(StringUtils.capitalize(description) + " was not registered (possibly already registered?)");
		return;
	}
        // 这里调用
	configure(registration);
}

接着看调用链org.springframework.boot.web.servlet.RegistrationBean#onStartup(...)


@Override
public final void onStartup(ServletContext servletContext) throws ServletException {
	String description = getDescription();
	if (!isEnabled()) {
		logger.info(StringUtils.capitalize(description) + " was not registered (disabled)");
		return;
	}
	register(description, servletContext);
}

接着看调用链org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#selfInitialize(...)，这个方法只调用一次，下面的filter通过遍历生成。


private void selfInitialize(ServletContext servletContext) throws ServletException {
	prepareWebApplicationContext(servletContext);
	registerApplicationScope(servletContext);
	WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
	for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
                // 这里遍历调用
		beans.onStartup(servletContext);
	}
}

也就是说关键点在org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#getServletContextInitializerBeans()方法上


protected Collection<ServletContextInitializer> getServletContextInitializerBeans() {
	return new ServletContextInitializerBeans(getBeanFactory());
}

继续追调用org.springframework.boot.web.servlet.ServletContextInitializerBeans构造函数


@SafeVarargs
public ServletContextInitializerBeans(ListableBeanFactory beanFactory,
		Class<? extends ServletContextInitializer>... initializerTypes) {
	this.initializers = new LinkedMultiValueMap<>();
	this.initializerTypes = (initializerTypes.length != 0) ? Arrays.asList(initializerTypes)
			: Collections.singletonList(ServletContextInitializer.class);
	addServletContextInitializerBeans(beanFactory);
	addAdaptableBeans(beanFactory);
        // 排序就在这里
	List<ServletContextInitializer> sortedInitializers = this.initializers.values().stream()
			.flatMap((value) -> value.stream().sorted(AnnotationAwareOrderComparator.INSTANCE))
			.collect(Collectors.toList());
	this.sortedList = Collections.unmodifiableList(sortedInitializers);
	logMappings(this.initializers);
}

所以现在知道这个排序是怎么决定了吧，也即@Order注解，注意，如果这个Bean不是受Spring管理的就不会生效的。不生效的话默认值是2147483647，这样顺序会在最后面。

现在我们顺着来捋一下这个关系，其中有一个关键点需要明确的是，通常情况下，我们springboot应用是servlet容器的，所以实例化的ApplicationContext类型是：org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext。有了这个确定的类型，很多链路就变得清晰了。可以看到最后是丢给线程池来处理了。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/黑客灵魂/article/detail/921901