springboot之ServletComponentScan

简介

在springboot web工程中可以通过使用@ServletComponentScan注解会自动扫描装配带有@WebServlet、@WebFilter和@WebListener的类，分别实现注册servelt、添加servler过滤器、添加servlet监听器，如：ServletContextListener、ServletRequestListener、HttpSessionListener等

实例

添加过滤器

/**
 *urlPatterns = "/*" 表示对所有的web资源进行拦截
 */
@WebFilter(urlPatterns ="/*")
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        response.getWriter().write("我是一个过滤器; ");
        chain.doFilter(request, response);
    }
}

添加请求监听器，并设置参数

@WebListener
public class MyListener implements ServletRequestListener {

    /**
     * 请求初始化
     */
    @Override
    public  void requestInitialized (ServletRequestEvent sre) {
        sre.getServletRequest().setAttribute("myName", "张三;");
    }
}

添加Servlet处理请求

/**
 *urlPatterns = "/myServlet" 表示处理path为myServlet web请求
 */
@WebServlet(urlPatterns ="/myServlet")
public class MyWebServlet extends HttpServlet {

    private static final long serialVersionUID = 6586226767091889098L;

    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws IOException
    {
        val myName = req.getAttribute("myName");
        resp.getWriter().write("myName is" + myName );
        resp.getWriter().write(" 我已经处理请求了");
    }
}

运行结果

原理分许

首先引入@ServletComponentScan定义要扫描的的包或class ，同时注入ServletComponentScanRegistrar来获取要扫描的包或者类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
//此配置类为关键
@Import(ServletComponentScanRegistrar.class)
public @interface ServletComponentScan {
    
     /**
	 * 同basePackages，指定要扫描包路径
	 * 可以指定多个包路劲
	 */
	@AliasFor("basePackages")
	String[] value() default {};

	@AliasFor("value")
	String[] basePackages() default {};
    /**
	 * 将指定类的包路径作为扫描路径，可以指定多个类，跟上面两个参数不能同时使用，优先使用上面两个参数
	 */
	Class<?>[] basePackageClasses() default {};
}

ServletComponentScanRegistrar实现了ImportBeanDefinitionRegistrar接口，实现了registerBeanDefinitions接口方法注入了ServletComponentRegisteringPostProcessor工厂处理器，具体代码分析如下：

class ServletComponentScanRegistrar implements ImportBeanDefinitionRegistrar {

	private static final String BEAN_NAME = "servletComponentRegisteringPostProcessor";
    /**
	 * 获取要扫码的包路径，然后注入ServletComponentRegisteringPostProcessor或更新工厂处理器
	 */
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
		if (registry.containsBeanDefinition(BEAN_NAME)) {
			updatePostProcessor(registry, packagesToScan);
		}
		else {
			addPostProcessor(registry, packagesToScan);
		}
	}
    /**
	 * 如果之前已经注入过工厂处理器则更新要扫码的包路径，该场景主要用来处理项目中多次使用@ServletComponentScan 注解的情况
	 */
	private void updatePostProcessor(BeanDefinitionRegistry registry, Set<String> packagesToScan) {
		ServletComponentRegisteringPostProcessorBeanDefinition definition = (ServletComponentRegisteringPostProcessorBeanDefinition) registry
				.getBeanDefinition(BEAN_NAME);
		definition.addPackageNames(packagesToScan);
	}
    /**
	 * 注入工厂后置处理器
	 */
	private void addPostProcessor(BeanDefinitionRegistry registry, Set<String> packagesToScan) {
		ServletComponentRegisteringPostProcessorBeanDefinition definition = new ServletComponentRegisteringPostProcessorBeanDefinition(
				packagesToScan);
		registry.registerBeanDefinition(BEAN_NAME, definition);
	}
  /**
   * 获取要扫码的包路径
   */
	private Set<String> getPackagesToScan(AnnotationMetadata metadata) {       
	    //获取注解元数据
		AnnotationAttributes attributes = AnnotationAttributes
				.fromMap(metadata.getAnnotationAttributes(ServletComponentScan.class.getName()));
		String[] basePackages = attributes.getStringArray("basePackages");
		Class<?>[] basePackageClasses = attributes.getClassArray("basePackageClasses");
		Set<String> packagesToScan = new LinkedHashSet<>(Arrays.asList(basePackages));
		for (Class<?> basePackageClass : basePackageClasses) {
			packagesToScan.add(ClassUtils.getPackageName(basePackageClass));
		}
		//如果没有指定包路径，将使用指定类的包路径作为要扫码的包
		if (packagesToScan.isEmpty()) {
			packagesToScan.add(ClassUtils.getPackageName(metadata.getClassName()));
		}
		return packagesToScan;
	}
    //继承至GenericBeanDefinition，构造函数及getInstanceSupplier方法指定了真正要注入的beanDefinition即
    // ServletComponentRegisteringPostProcessorBeanDefinition，同时传了了该beanDefinition的参数
	static final class ServletComponentRegisteringPostProcessorBeanDefinition extends GenericBeanDefinition {

		private Set<String> packageNames = new LinkedHashSet<>();

		ServletComponentRegisteringPostProcessorBeanDefinition(Collection<String> packageNames) {
			setBeanClass(ServletComponentRegisteringPostProcessor.class);
			setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			addPackageNames(packageNames);
		}
        //此处为关键，在生产bean实例的时候会取调用该方法，可以参考   
        // AbstractAutowireCapableBeanFactory#createBeanInstance
		@Override
		public Supplier<?> getInstanceSupplier() {
			return () -> new ServletComponentRegisteringPostProcessor(this.packageNames);
		}

		private void addPackageNames(Collection<String> additionalPackageNames) {
			this.packageNames.addAll(additionalPackageNames);
		}

	}
}

ServletComponentRegisteringPostProcessor实现了BeanFactoryPostProcessor工厂处理器，并且实现了postProcessBeanFactory，该方法是实现处理@WebFilter等注解的核心的方法，具体分析如下：

class ServletComponentRegisteringPostProcessor implements BeanFactoryPostProcessor, ApplicationContextAware {

	private static final List<ServletComponentHandler> HANDLERS;
      //初始化的扫描器注解过滤器，如WebServletHandler构造函数里包含WebServlet注解
	static {
		List<ServletComponentHandler> servletComponentHandlers = new ArrayList<>();
		servletComponentHandlers.add(new WebServletHandler());
		servletComponentHandlers.add(new WebFilterHandler());
		servletComponentHandlers.add(new WebListenerHandler());
		HANDLERS = Collections.unmodifiableList(servletComponentHandlers);
	}

	private final Set<String> packagesToScan;

	private ApplicationContext applicationContext;

	ServletComponentRegisteringPostProcessor(Set<String> packagesToScan) {
		this.packagesToScan = packagesToScan;
	}
    //执行工厂后置处理器方法，通过classPath遍历扫描器对应的路径
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		if (isRunningInEmbeddedWebServer()) {
			ClassPathScanningCandidateComponentProvider componentProvider = createComponentProvider();
			for (String packageToScan : this.packagesToScan) {
				scanPackage(componentProvider, packageToScan);
			}
		}
	}
    //执行扫描并获取满足条件的beanDefinition（过滤条件是具有@WebFilter等三个注解）
	private void scanPackage(ClassPathScanningCandidateComponentProvider componentProvider, String packageToScan) {
		for (BeanDefinition candidate : componentProvider.findCandidateComponents(packageToScan)) {
			if (candidate instanceof AnnotatedBeanDefinition) {
				for (ServletComponentHandler handler : HANDLERS) {
				    //注入对应的beanDefinition到容器，下面具体会说明
					handler.handle(((AnnotatedBeanDefinition) candidate),
							(BeanDefinitionRegistry) this.applicationContext);
				}
			}
		}
	}
    //判断当前容器是web容器且servlet上下文还未初始化（因为filter、listenr、sevelt是在初始化过程中进行条件的）
	private boolean isRunningInEmbeddedWebServer() {
		return this.applicationContext instanceof WebApplicationContext
				&& ((WebApplicationContext) this.applicationContext).getServletContext() == null;
	}
     //构造扫描器器
	private ClassPathScanningCandidateComponentProvider createComponentProvider() {
		ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(
				false);
		componentProvider.setEnvironment(this.applicationContext.getEnvironment());   
		//设置扫描器条件过滤器，在扫描的时候会作为判断，具有详看：ClassPathScanningCandidateComponentProvider#isCandidateComponent方法
		componentProvider.setResourceLoader(this.applicationContext);
		for (ServletComponentHandler handler : HANDLERS) {
			componentProvider.addIncludeFilter(handler.getTypeFilter());
		}
		return componentProvider;
	}

	Set<String> getPackagesToScan() {
		return Collections.unmodifiableSet(this.packagesToScan);
	}
    
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
	}
}

ServletComponentHandler#handle处理beanDefinition的注入，具体如下：
一：WebServletHandler注入ServletRegistrationBean，，具体构造Servlet实例并添加到容器中的源码如下：
ServletContextInitializerBeans#addServletContextInitializerBean

	private void addServletContextInitializerBean(String beanName, ServletContextInitializer initializer,
			ListableBeanFactory beanFactory) {
		//构造Servlet实例，并添加到servlet容器中	
		if (initializer instanceof ServletRegistrationBean) {
			Servlet source = ((ServletRegistrationBean<?>) initializer).getServlet();
			addServletContextInitializerBean(Servlet.class, beanName, initializer, beanFactory, source);
		}
		//构造filter并添加到servlet容器中	
		else if (initializer instanceof FilterRegistrationBean) {
			Filter source = ((FilterRegistrationBean<?>) initializer).getFilter();
			addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);
		}
		else if (initializer instanceof DelegatingFilterProxyRegistrationBean) {
			String source = ((DelegatingFilterProxyRegistrationBean) initializer).getTargetBeanName();
			addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);
		}
		//构造ServletListener并添加到servlet容器中
		else if (initializer instanceof ServletListenerRegistrationBean) {
			EventListener source = ((ServletListenerRegistrationBean<?>) initializer).getListener();
			addServletContextInitializerBean(EventListener.class, beanName, initializer, beanFactory, source);
		}
		else {
			addServletContextInitializerBean(ServletContextInitializer.class, beanName, initializer, beanFactory,
					initializer);
		}
	}

二、WebFilterHandler注入FilterRegistrationBean，并设置filter相关属性，在初始化servelt上下文的时候出创建具体的Filter实例，原理同上

二、WebListenerHandler注入ServletComponentWebListenerRegistrar，具体构造ServletListener实例添加在servelt容器原理同上，