BeanFactoryPostProcessor和BeanDefinitionPostProcessor和ApplicationListener
BeanDefinitionPostProcessor: Spring的接口类用于处理对Bean的定义注册
GenericBeanDefinition:用于定义Bean的信息
FactoryBean: 用于处理Bean工厂的类

一:Spring是如何发布事件的? ApplicationListener

1.1)自己写一个TulingApplicationListener 实现ApplicationListener接口,并且把该组件加入到容器中.

  1. /**
  2.  * 创建一个监听器
  3.  *
  4.  */
  5. @Component
  6. public class TulingApplicationListener implements ApplicationListener {
  7.     @Override
  8.     public void onApplicationEvent(ApplicationEvent event) {
  9.         System.out.println("TulingApplicationListener 接受到了一个事件"+event);
  10.     }
  11. }
  1. public class MainClass {
  2.     public static void main(String[] args) {
  3.         AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
  4.         ctx.publishEvent(new ApplicationEvent("我手动发布了一个事件") {
  5.             @Override
  6.             public Object getSource() {
  7.                 return super.getSource();
  8.             }
  9.         });
  10.         ctx.close();
  11.     }
  12. }

测试结果: 

  1. TulingApplicationListener 接受到了一个事件org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@37bba400: startup date [Mon May 27 21:42:51 CST 2019]; root of context hierarchy]
  2. TulingApplicationListener 接受到了一个事件com.tuling.testapplicationlistener.MainClass$1[source=我手动发布了一个事件]
  3. TulingApplicationListener 接受到了一个事件org.springframework.context.event.ContextClosedEvent[source=org.springframework.context.annotation.AnnotationConfigApplicationContext@37bba400: startup date [Mon May 27 21:42:51 CST 2019]; root of context hierarchy]

进入类AnnotationConfigApplicationContext的构造函数

  1.     /**
  2.      * Create a new AnnotationConfigApplicationContext that needs to be populated
  3.      * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
  4.      */
  5.     public AnnotationConfigApplicationContext() {
  6.         // 往容器中放入一些列的后置处理器
  7.         this.reader = new AnnotatedBeanDefinitionReader(this);
  8.         // 指定扫描策略
  9.         this.scanner = new ClassPathBeanDefinitionScanner(this);
  10.     }
  12.     /**
  13.      * Create a new AnnotationConfigApplicationContext, deriving bean definitions
  14.      * from the given annotated classes and automatically refreshing the context.
  15.      * @param annotatedClasses one or more annotated classes,
  16.      * e.g. {@link Configuration @Configuration} classes
  17.      */
  18.     public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
  19.         this();
  20.         // 把配置类注册容器中【把我们的MainConfig记录到容器中去】
  21.         register(annotatedClasses);
  22.         //容器刷新。极其重要,核心
  23.         refresh();
  24.     }

如下图，在执行到this.scanner = new ClassPathBeanDefinitionScanner(this);时，容器中会有六个默认的bean

image.png

而走完register(annotatedClasses);之后，会将我们的MainConfig(自己定义的组件)记录到容器中去

  1. @Configuration
  2. @ComponentScan(basePackages = "com.tuling.testbeanfacotoryPostProcessor")
  3. public class MainConfig {
  4. }

image.png
如下为AbstractApplicationContext.refresh()方法

  1. @Override
  2.     public void refresh() throws BeansException, IllegalStateException {
  3.         synchronized (this.startupShutdownMonitor) {
  4.             // Prepare this context for refreshing.
  5.             prepareRefresh();
  7.             // Tell the subclass to refresh the internal bean factory.
  8.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  10.             // Prepare the bean factory for use in this context.
  11.             prepareBeanFactory(beanFactory);
  13.             try {
  14.                 // Allows post-processing of the bean factory in context subclasses.
  15.                 postProcessBeanFactory(beanFactory);
  17.                 // Invoke factory processors registered as beans in the context.
  18.                 // 调用bean工厂的后置处理器
  19.                 invokeBeanFactoryPostProcessors(beanFactory);
  21.                 // Register bean processors that intercept bean creation.
  22.                 registerBeanPostProcessors(beanFactory);
  24.                 // Initialize message source for this context.
  25.                 initMessageSource();
  27.                 // Initialize event multicaster for this context.
  28.                 // 初始化事件多播器
  29.                 initApplicationEventMulticaster();
  31.                 // Initialize other special beans in specific context subclasses.
  32.                 onRefresh();
  34.                 // Check for listener beans and register them.
  35.                 // 把事件监听器注册到多播器上去
  36.                 registerListeners();
  38.                 // Instantiate all remaining (non-lazy-init) singletons.
  39.                 finishBeanFactoryInitialization(beanFactory);
  41.                 // Last step: publish corresponding event.
  42.                 finishRefresh();
  43.             }
  45.             catch (BeansException ex) {
  46.                 if (logger.isWarnEnabled()) {
  47.                     logger.warn("Exception encountered during context initialization - " +
  48.                                 "cancelling refresh attempt: " + ex);
  49.                 }
  51.                 // Destroy already created singletons to avoid dangling resources.
  52.                 destroyBeans();
  54.                 // Reset 'active' flag.
  55.                 cancelRefresh(ex);
  57.                 // Propagate exception to caller.
  58.                 throw ex;
  59.             }
  61.             finally {
  62.                 // Reset common introspection caches in Spring's core, since we
  63.                 // might not ever need metadata for singleton beans anymore...
  64.                 resetCommonCaches();
  65.             }
  66.         }
  67.     }

源码解析:

i1>org.springframework.context.support.AbstractApplicationContext#refresh
i2>org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster（初始化事件多播器）
i3>org.springframework.context.support.AbstractApplicationContext#registerListeners（把事件监听器注册到多播器上去）


i2(初始化事件多播器源码解析)

AbstractApplicationContext.initApplicationEventMulticaster()

  1. protected void initApplicationEventMulticaster() {
  2.         ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  3.         //判断IOC容器中包含applicationEventMulticaster 事件多播器的Bean的name
  4.         if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
  5.             //创建一个applicationEventMulticaster的bean放在IOC 容器中,bean的name 为applicationEventMulticaster
  6.             this.applicationEventMulticaster =beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
  7.             if (logger.isDebugEnabled()) {
  8.                 logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
  9.             }
  10.         }
  11.         //容器中不包含一个beanName 为applicationEventMulticaster的多播器组件
  12.         else {
  13.             //创建一个SimpleApplicationEventMulticaster 多播器
  14.             this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  15.             //注册到容器中
  16.             beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
  17.             if (logger.isDebugEnabled()) {
  18.                 logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
  19.                         APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
  20.                         "': using default [" + this.applicationEventMulticaster + "]");
  21.             }
  22.         }
  23.     }

i3：把容器中的监听器注册到多播器上去 源码解析

AbstractApplicationContext.registerListeners()

  1. protected void registerListeners() {
  2.     //去容器中把applicationListener 捞取出来注册到多播器上去（系统的）
  3.     for (ApplicationListener<?> listener : getApplicationListeners()) {
  4.         getApplicationEventMulticaster().addApplicationListener(listener);
  5.     }
  7.     //我们自己实现了ApplicationListener 的组件
  8.     String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
  9.     for (String listenerBeanName : listenerBeanNames) {
  10.         getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  11.     }
  13.     //在这里之前，我们早期想发布的事件 由于没有多播器没有发布，
  14.     在这里我们总算有了自己的多播器，可以在这里发布早期堆积的事件了.
  15.     Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
  16.     this.earlyApplicationEvents = null;
  17.     // 如果拥有早期待处理事件，调用多播器，并通知观察者
  18.     if (earlyEventsToProcess != null) {
  19.         for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
  20.             // 通知观察者
  21.             getApplicationEventMulticaster().multicastEvent(earlyEvent);
  22.         }
  23.     }
  24. }

在看一眼AbstractApplicationContext.refresh()方法，多播器的早期与后期界线点为：AbstractApplicationContext.registerListeners();
在运行查看源码的时候发现没有早期事件，先存起来，程序过了registerListeners()后在 AbstractApplicationContext.finishRefresh();里面进行出发；其原因是因为防止onRefresh()中有事件[SpringBoot启动调用tomcat]

  2. ------------------------------如何发布事件------------------------------------------------------
  3.     public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) {
  4.     ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
  5.     //获取到所有的监听器
  6.     for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
  7.         //看spring 容器中是否支持线程池 异步发送事件
  8.         Executor executor = getTaskExecutor();
  9.         if (executor != null) {
  10.             executor.execute(new Runnable() {
  11.                 @Override
  12.                 public void run() {
  14.                     invokeListener(listener, event);
  15.                 }
  16.             });
  17.         }
  18.         else {  //同步发送事件
  19.             invokeListener(listener, event);
  20.         }
  21.     }
  22. }    
  24. private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
  25.     try {
  26.         //调用对于listener的onApplicationEvent事件
  27.         listener.onApplicationEvent(event);
  28.     }
  29.     catch (ClassCastException ex) {
  30.         String msg = ex.getMessage();
  31.         if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
  32.             // Possibly a lambda-defined listener which we could not resolve the generic event type for
  33.             // -> let's suppress the exception and just log a debug message.
  34.             Log logger = LogFactory.getLog(getClass());
  35.             if (logger.isDebugEnabled()) {
  36.                 logger.debug("Non-matching event type for listener: " + listener, ex);
  37.             }
  38.         }
  39.         else {
  40.             throw ex;
  41.         }
  42.     }
  43. }

二:BeanDefinitionRegistryPostProcessor 的处理源码流程

执行时机:所有的bean定义信息将要被加载到容器中，Bean实例还没有被初始化。

  1. @Component
  2. public class TulingBeanDefinationRegisterPostProcessor implements BeanDefinitionRegistryPostProcessor {
  3.     @Override
  4.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
  5.         System.out.println("TulingBeanDefinationRegisterPostProcessor的postProcessBeanDefinitionRegistry方法");
  6.         System.out.println("bean定义的数据量:"+registry.getBeanDefinitionCount());
  7.         RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(TulingLog.class);
  8.         registry.registerBeanDefinition("tulingLog",rootBeanDefinition);
  9.     }
  11.     @Override
  12.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  13.         System.out.println("TulingBeanDefinationRegisterPostProcessor的postProcessBeanFactory方法");
  14.         System.out.println(beanFactory.getBeanDefinitionCount());
  15.     }
  16. }

三:BeanFactoryPostProcessor 处理流程

执行时间:所有的Bean定义信息已经加载到容器中，但是Bean实例还没有被初始化.

  1. @Component
  2. public class TulingBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  3.     @Override
  4.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  5.         System.out.println("IOC 容器调用了TulingBeanFactoryPostProcessor的postProcessBeanFactory方法");
  6.         for(String name:beanFactory.getBeanDefinitionNames()) {
  7.             if("tulingLog".equals(name)) {
  8.                 BeanDefinition beanDefinition = beanFactory.getBeanDefinition(name);
  9.                 beanDefinition.setLazyInit(true);
  10.             }
  12.         }
  13.     }
  14. }

调用链:
i1:org.springframework.context.support.AbstractApplicationContext#refresh
>i2:org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors
>i3:org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
>i4:org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
>i5:org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions
> i6:org.springframework.context.annotation.ConfigurationClassParser#parse
>i7:org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
>i8:org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass

i4标记处源码解析 #invokeBeanFactoryPostProcessors

org.springframework.context.support.
PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

  1. public static void invokeBeanFactoryPostProcessors(
  2.   ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  4.   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
  5.   Set<String> processedBeans = new HashSet<String>();
  6.  //判断IOC 容器是不是BeanDefinitionRegistry的？
  7.   if (beanFactory instanceof BeanDefinitionRegistry) {
  8.   //把IOC容器 强制转为BeanDefinitionRegistry类型的
  9.     BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  10.      //创建一个普通的PostProcessors的list的组件
  11.       List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
  12.       //创建一个BeanDefinitionRegistryPostProcessor类型的list
  13.       List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
  14.         //处理容器硬编码(new 出来的)带入的beanFacotryPostProcessors
  15.       for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
  16.           //判断是不是BeanDefinitionRegistryPostProcessor
  17.           if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
  19.               BeanDefinitionRegistryPostProcessor registryProcessor =
  20.                   (BeanDefinitionRegistryPostProcessor) postProcessor;
  21.               //调用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry
  22.               registryProcessor.postProcessBeanDefinitionRegistry(registry);
  23.               //加入到list集合中
  24.               registryProcessors.add(registryProcessor);
  25.           }
  26.           else {//判断不是BeanDefinitionRegistryPostProcessor
  27.               //加入到集合中
  28.               regularPostProcessors.add(postProcessor);
  29.           }
  30.       }
  32.       //创建一个当前注册的RegistryProcessors的集合
  33.       List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
  35.         第一步:去容器中查询是否有BeanDefinitionRegistryPostProcessor类型的
  36.             String[] postProcessorNames =
  37.             beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  38.         for (String ppName : postProcessorNames) {
  39.             //判断是不是实现了PriorityOrdered接口的
  40.             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  41.                 //添加到currentRegistryProcessors的集合中
  42.                 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  43.                 //添加到processedBeans的集合中
  44.                 processedBeans.add(ppName);
  45.             }
  46.         }
  47.         //进行排序
  48.         sortPostProcessors(currentRegistryProcessors, beanFactory);
  49.         registryProcessors.addAll(currentRegistryProcessors);
  50.         //调用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
  51.         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  52.         currentRegistryProcessors.clear();
  54.         // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
  55.         第二步:去容器中查询是否有BeanDefinitionRegistryPostProcessor类型的
  56.             for (String ppName : postProcessorNames) {
  57.                 //排除被处理过的，并且实现了Ordered接口的
  58.                 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
  59.                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  60.                     //加到以处理的list中
  61.                     processedBeans.add(ppName);
  62.                 }
  63.             }
  64.         sortPostProcessors(currentRegistryProcessors, beanFactory);
  65.         registryProcessors.addAll(currentRegistryProcessors);
  66.         //调用BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
  67.         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  68.         currentRegistryProcessors.clear();
  70.         //调用普通的BeanDefinitionRegistryPostProcessors没用实现 PriorithOrdered和Ordered接口
  71.         boolean reiterate = true;
  72.         while (reiterate) {
  73.             reiterate = false;
  74.             postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  75.             for (String ppName : postProcessorNames) {
  76.                 if (!processedBeans.contains(ppName)) {
  77.                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  78.                     processedBeans.add(ppName);
  79.                     reiterate = true;
  80.                 }
  81.             }
  82.             sortPostProcessors(currentRegistryProcessors, beanFactory);
  83.             registryProcessors.addAll(currentRegistryProcessors);
  84.             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  85.             currentRegistryProcessors.clear();
  86.         }
  88.         //调用上诉实现了也实现了BeanFactoryPostProcessors的接口
  89.         invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
  90.         invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
  91.     }
  93.     else {
  94.         // Invoke factory processors registered with the context instance.
  95.         invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
  96.     }
  98.     //去IOC 容器中获取BeanFactoryPostProcessor 类型的
  99.     String[] postProcessorNames =
  100.         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
  102.     //分离实现了PriorityOrdered接口的 Ordered 接口的   普通的
  103.     List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
  104.     List<String> orderedPostProcessorNames = new ArrayList<String>();
  105.     List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
  107.     for (String ppName : postProcessorNames) {
  108.         if (processedBeans.contains(ppName)) {
  109.             // skip - already processed in first phase above
  110.         }
  111.         else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  112.             priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
  113.         }
  114.         else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
  115.             orderedPostProcessorNames.add(ppName);
  116.         }
  117.         else {
  118.             nonOrderedPostProcessorNames.add(ppName);
  119.         }
  120.     }
  122.     调用 PriorityOrdered.
  123.         sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  124.     invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
  126.     //调用 Ordered.
  127.     List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
  128.     for (String postProcessorName : orderedPostProcessorNames) {
  129.         orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
  130.     }
  131.     sortPostProcessors(orderedPostProcessors, beanFactory);
  132.     invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
  134.     //调用普通的
  135.     List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
  136.     for (String postProcessorName : nonOrderedPostProcessorNames) {
  137.         nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
  138.     }
  139.     invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
  141.     // Clear cached merged bean definitions since the post-processors might have
  142.     // modified the original metadata, e.g. replacing placeholders in values...
  143.     beanFactory.clearMetadataCache();
  144. }

i5源码解析

i5:org.springframework.context.annotation.
ConfigurationClassPostProcessor#processConfigBeanDefinitions 

  1. public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
  2.     List<BeanDefinitionHolder> configCandidates = new ArrayList<BeanDefinitionHolder>();
  3.     //去IOC容器中的获取Bean定义的名称
  4.     //    private volatile List<String> beanDefinitionNames = new ArrayList<String>(256);
  6.     //没有解析之前，系统候选的bean定义配置(有自己的 有系统自带的)
  7.     String[] candidateNames = registry.getBeanDefinitionNames();
  9.     //循环Bean定义的名称 找出自己的传入的主配置类的bean定义信息  configCandidates
  10.     for (String beanName : candidateNames) {
  11.         //去bean定义的map中获取对应的Bean定义对象
  12.         //    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);
  13.         BeanDefinition beanDef = registry.getBeanDefinition(beanName);
  14.         //检查该bean定义对象是不是用来描述配置类
  15.         if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
  16.             ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
  17.             if (logger.isDebugEnabled()) {
  18.                 logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
  19.             }
  20.         }
  21.         else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
  22.             configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
  23.         }
  24.     }
  26.     // Return immediately if no @Configuration classes were found
  27.     if (configCandidates.isEmpty()) {
  28.         return;
  29.     }
  31.     //检查配置类排序，看哪一个先起作用
  32.     Collections.sort(configCandidates, new Comparator<BeanDefinitionHolder>() {
  33.         @Override
  34.         public int compare(BeanDefinitionHolder bd1, BeanDefinitionHolder bd2) {
  35.             int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
  36.             int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
  37.             return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
  38.         }
  39.     });
  41.     // bean的名称生成策略
  42.     SingletonBeanRegistry sbr = null;
  43.     if (registry instanceof SingletonBeanRegistry) {
  44.         sbr = (SingletonBeanRegistry) registry;
  45.         if (!this.localBeanNameGeneratorSet && sbr.containsSingleton(CONFIGURATION_BEAN_NAME_GENERATOR)) {
  46.             BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
  47.            // 扫描包组件生成器
  48.             this.componentScanBeanNameGenerator = generator;
  49.             // importBean生成器
  50.             this.importBeanNameGenerator = generator;
  51.         }
  52.     }
  54.     /***创建一个配置类解析器
  55.         1)元数据读取器工厂
  56.         this.metadataReaderFactory = metadataReaderFactory;
  57.         2)问题报告器
  58.         this.problemReporter = problemReporter;
  59.         //设置环境
  60.         this.environment = environment;
  61.         3)资源加载器
  62.         this.resourceLoader = resourceLoader;
  63.         4）创建了一个组件扫描器
  64.         this.componentScanParser = new ComponentScanAnnotationParser(
  65.                 environment, resourceLoader, componentScanBeanNameGenerator, registry);
  66.         this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
  67.         ****/
  69.     // 创建配置类解析器
  70.     ConfigurationClassParser parser = new ConfigurationClassParser(
  71.         this.metadataReaderFactory, this.problemReporter, this.environment,
  72.         this.resourceLoader, this.componentScanBeanNameGenerator, registry);
  74.     //将要被解析的配置类(把自己的configCandidates加入到 候选的)
  75.     Set<BeanDefinitionHolder> candidates = new LinkedHashSet<BeanDefinitionHolder>(configCandidates);
  76.     //已经被解析的配置类(由于do while 那么mainclass就一定会被解析,被解析的size为1)
  77.     Set<ConfigurationClass> alreadyParsed = new HashSet<ConfigurationClass>(configCandidates.size());
  78.     do {
  79.         //通过配置解析器真正的解析配置类
  80.         parser.parse(candidates);
  82.         //进行校验
  83.         parser.validate();
  85.         //获取ConfigClass (把解析过的配置bean定义信息获取出来)
  86.         Set<ConfigurationClass> configClasses = new LinkedHashSet<ConfigurationClass>(parser.getConfigurationClasses());
  87.         configClasses.removeAll(alreadyParsed);
  89.         // Read the model and create bean definitions based on its content
  90.         if (this.reader == null) {
  91.             this.reader = new ConfigurationClassBeanDefinitionReader(
  92.                 registry, this.sourceExtractor, this.resourceLoader, this.environment,
  93.                 this.importBeanNameGenerator, parser.getImportRegistry());
  94.         }
  96.         //@CompentScan是直接注册Bean定义信息的    但是通过获取@Import,@Bean这种的注解还没有注册的bean定义,
  97.         this.reader.loadBeanDefinitions(configClasses);
  98.         //把系统解析过我们自己的组件放在alreadyParsed
  99.         alreadyParsed.addAll(configClasses);
  100.         //清除解析过的 配置文件 
  101.         candidates.clear();
  103.         //已经注册的bean定义个数大于最新 开始系统+主配置类的(发生过解析)
  104.         if (registry.getBeanDefinitionCount() > candidateNames.length) {
  105.             //获取系统+自己解析的+mainconfig的bean定义信息
  106.             String[] newCandidateNames = registry.getBeanDefinitionNames();
  107.             //系统的+mainconfig的bean定义信息
  108.             Set<String> oldCandidateNames = new HashSet<String>(Arrays.asList(candidateNames));
  110.             //已经解析过的自己的组件
  111.             Set<String> alreadyParsedClasses = new HashSet<String>();
  112.             for (ConfigurationClass configurationClass : alreadyParsed) {
  113.                 alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
  114.             }
  116.             for (String candidateName : newCandidateNames) {
  117.                 //老的（系统+mainconfig） 不包含解析的
  118.                 if (!oldCandidateNames.contains(candidateName)) {
  119.                     //把当前bean定义获取出来
  120.                     BeanDefinition bd = registry.getBeanDefinition(candidateName);
  121.                     //检查是否为解析过的
  122.                     if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
  123.                         !alreadyParsedClasses.contains(bd.getBeanClassName())) {
  124.                         //若不是解析过且通过检查的     把当前的bean定义 加入到candidates中        
  125.                         candidates.add(new BeanDefinitionHolder(bd, candidateName));
  126.                     }
  127.                 }
  128.             }
  129.             把解析过的赋值给原来的 
  130.                 candidateNames = newCandidateNames;
  131.         }
  132.     }
  133.     while (!candidates.isEmpty());  //还存主没有解析过的  再次解析
  135.     // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
  136.     if (sbr != null) {
  137.         if (!sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
  138.             sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
  139.         }
  140.     }
  142.     if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
  143.         ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
  144.     }
  145. }

i6源码解析

org.springframework.context.annotation.
ConfigurationClassParser#parse

  1. public void parse(Set<BeanDefinitionHolder> configCandidates) {
  2.     this.deferredImportSelectors = new LinkedList<DeferredImportSelectorHolder>();
  4.     for (BeanDefinitionHolder holder : configCandidates) {
  5.         BeanDefinition bd = holder.getBeanDefinition();
  6.         try {
  7.             //注解形式的bean定义信息
  8.             if (bd instanceof AnnotatedBeanDefinition) {
  9.                 //解析配置类的bean定义
  10.                 parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
  11.             }
  12.             else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
  13.                 parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
  14.             }
  15.             else {
  16.                 parse(bd.getBeanClassName(), holder.getBeanName());
  17.             }
  18.         }
  19.         catch (BeanDefinitionStoreException ex) {
  20.             throw ex;
  21.         }
  22.         catch (Throwable ex) {
  23.             throw new BeanDefinitionStoreException(
  24.                 "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
  25.         }
  26.     }
  28.     processDeferredImportSelectors();
  29. }
  32. org.springframework.context.annotation.ConfigurationClassParser#parse
  33.     org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
  35. protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
  36.         if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
  37.             return;
  38.         }
  40.         ConfigurationClass existingClass = this.configurationClasses.get(configClass);
  41.         if (existingClass != null) {
  42.             if (configClass.isImported()) {
  43.                 if (existingClass.isImported()) {
  44.                     existingClass.mergeImportedBy(configClass);
  45.                 }
  46.                 // Otherwise ignore new imported config class; existing non-imported class overrides it.
  47.                 return;
  48.             }
  49.             else {
  50.                 // Explicit bean definition found, probably replacing an import.
  51.                 // Let's remove the old one and go with the new one.
  52.                 this.configurationClasses.remove(configClass);
  53.                 for (Iterator<ConfigurationClass> it = this.knownSuperclasses.values().iterator(); it.hasNext();) {
  54.                     if (configClass.equals(it.next())) {
  55.                         it.remove();
  56.                     }
  57.                 }
  58.             }
  59.         }
  61.         递归处理配置类及其超类层次结构。
  62.         SourceClass sourceClass = asSourceClass(configClass);
  63.         do {
  64.             sourceClass = doProcessConfigurationClass(configClass, sourceClass);
  65.         }
  66.         while (sourceClass != null);
  68.         this.configurationClasses.put(configClass, configClass);
  69.     }
  72. org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass
  73.     protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
  74.     throws IOException {
  76.     // Recursively process any member (nested) classes first
  77.     processMemberClasses(configClass, sourceClass);
  79.     //处理@PropertySource注解
  80.     for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
  81.         sourceClass.getMetadata(), PropertySources.class,
  82.         org.springframework.context.annotation.PropertySource.class)) {
  83.         if (this.environment instanceof ConfigurableEnvironment) {
  84.             processPropertySource(propertySource);
  85.         }
  86.         else {
  87.             logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
  88.                         "]. Reason: Environment must implement ConfigurableEnvironment");
  89.         }
  90.     }
  92.     //处理@ComponentScan注解
  94.     //解析@ComponentScans注解的属性 封装成一个一个的componentscan对象
  95.     Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
  96.     if (!componentScans.isEmpty() &&!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
  98.         //循环componentScans的set
  99.         for (AnnotationAttributes componentScan : componentScans) {
  100.             // 立即执行扫描解析
  101.             Set<BeanDefinitionHolder> scannedBeanDefinitions =this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
  102.             //检查任何其他配置类的扫描定义集，并在需要时递归解析
  103.             for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
  104.                 //获取原始的bean定义信息
  105.                 BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
  106.                 if (bdCand == null) {
  107.                     bdCand = holder.getBeanDefinition();
  108.                 }
  109.                 //检查当前的bean定义信息是不是配置类  比如MainConfig的bean定义信息
  110.                 if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
  111.                     //递归调用来解析MainConfig,解析出来配置类的中导入的bean定义信息
  112.                     parse(bdCand.getBeanClassName(), holder.getBeanName());
  113.                 }
  114.             }
  115.         }
  116.     }
  118.     //处理@Import注解   解析Import 注解的ImportSelector  ImportBeanDefinitionRegister,@Bean这种
  119.     //存放在ConfigClass中
  120.     processImports(configClass, sourceClass, getImports(sourceClass), true);
  122.     //处理 @ImportResource annotations
  123.     if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
  124.         AnnotationAttributes importResource =
  125.             AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
  126.         String[] resources = importResource.getStringArray("locations");
  127.         Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
  128.         for (String resource : resources) {
  129.             String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
  130.             configClass.addImportedResource(resolvedResource, readerClass);
  131.         }
  132.     }
  134.     // 处理  @Bean methods
  135.     Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
  136.     for (MethodMetadata methodMetadata : beanMethods) {
  137.         configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
  138.     }
  140.     //处理接口
  141.     processInterfaces(configClass, sourceClass);
  143.     // 处理超类的
  144.     if (sourceClass.getMetadata().hasSuperClass()) {
  145.         String superclass = sourceClass.getMetadata().getSuperClassName();
  146.         if (!superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
  147.             this.knownSuperclasses.put(superclass, configClass);
  148.             // Superclass found, return its annotation metadata and recurse
  149.             return sourceClass.getSuperClass();
  150.         }
  151.     }
  153.     // No superclass -> processing is complete
  154.     return null;
  155. }
  157. //通过组件扫描器进行真正的解析    
  158. org.springframework.context.annotation.ComponentScanAnnotationParser#parse
  159. Set<BeanDefinitionHolder>
  161.     public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
  162.         Assert.state(this.environment != null, "Environment must not be null");
  163.         Assert.state(this.resourceLoader != null, "ResourceLoader must not be null");
  165.         //创建一个类路径下的bean定义扫描器
  166.         ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
  167.                 componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
  169.         //为扫描器设置一个bean 名称的生成器
  170.         Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
  171.         boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
  172.         scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
  173.                 BeanUtils.instantiateClass(generatorClass));
  176.         ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
  177.         if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
  178.             scanner.setScopedProxyMode(scopedProxyMode);
  179.         }
  180.         else {
  181.             Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
  182.             scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
  183.         }
  185.         scanner.setResourcePattern(componentScan.getString("resourcePattern"));
  187.         for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
  188.             for (TypeFilter typeFilter : typeFiltersFor(filter)) {
  189.                 scanner.addIncludeFilter(typeFilter);
  190.             }
  191.         }
  192.         for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
  193.             for (TypeFilter typeFilter : typeFiltersFor(filter)) {
  194.                 scanner.addExcludeFilter(typeFilter);
  195.             }
  196.         }
  198.         boolean lazyInit = componentScan.getBoolean("lazyInit");
  199.         if (lazyInit) {
  200.             scanner.getBeanDefinitionDefaults().setLazyInit(true);
  201.         }
  203.         Set<String> basePackages = new LinkedHashSet<String>();
  204.         String[] basePackagesArray = componentScan.getStringArray("basePackages");
  205.         for (String pkg : basePackagesArray) {
  206.             String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
  207.                     ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
  208.             basePackages.addAll(Arrays.asList(tokenized));
  209.         }
  210.         for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
  211.             basePackages.add(ClassUtils.getPackageName(clazz));
  212.         }
  213.         if (basePackages.isEmpty()) {
  214.             basePackages.add(ClassUtils.getPackageName(declaringClass));
  215.         }
  217.         scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
  218.             @Override
  219.             protected boolean matchClassName(String className) {
  220.                 return declaringClass.equals(className);
  221.             }
  222.         });
  223.         //真正扫描器扫描指定路径
  224.         return scanner.doScan(StringUtils.toStringArray(basePackages));
  225.     }
  228. //创建类路径下的bean定义扫描器
  229. public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
  230.                                       Environment environment, ResourceLoader resourceLoader) {
  232.     Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  233.     this.registry = registry;
  235.     //使用默认的扫描规则
  236.     if (useDefaultFilters) {
  237.         registerDefaultFilters();
  238.     }
  239.     //设置环境变量
  240.     setEnvironment(environment);
  241.     //设置资源加载器
  242.     setResourceLoader(resourceLoader);
  243. }
  245. //默认的扫描规则
  246. protected void registerDefaultFilters() {
  247.     //添加了Componet的解析，这就是我们为啥@Componet @Respository @Service @Controller的  @AspectJ
  248.     this.includeFilters.add(new AnnotationTypeFilter(Component.class));
  249.     ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
  250.     try {
  251.         //添加Jsr 250规范的注解
  252.         this.includeFilters.add(new AnnotationTypeFilter(
  253.             ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
  254.         logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
  255.     }
  256.     catch (ClassNotFoundException ex) {
  257.         // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
  258.     }
  259.     try {
  260.         //JSR330的注解
  261.         this.includeFilters.add(new AnnotationTypeFilter(
  262.             ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
  263.         logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
  264.     }
  265.     catch (ClassNotFoundException ex) {
  266.         // JSR-330 API not available - simply skip.
  267.     }
  268. }
  270. 使用扫描器去真正的扫描类,返回Set<BeanDefinitionHolder>
  271.     org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan
  273.     protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
  274.         Assert.notEmpty(basePackages, "At least one base package must be specified");
  275.         //创建一个Bean定义 holder的 set
  276.         Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
  277.         //循环扫描路径
  278.         for (String basePackage : basePackages) {
  279.             //找到候选的组件集合
  280.             Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
  281.             //循环候选组件集合
  282.             for (BeanDefinition candidate : candidates) {
  283.                 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
  284.                 candidate.setScope(scopeMetadata.getScopeName());
  285.                 //生成bean的名称
  286.                 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
  287.                 //判断是不是抽象的beand定义
  288.                 if (candidate instanceof AbstractBeanDefinition) {
  289.                     postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
  290.                 }
  291.                 //注解的bean定义
  292.                 if (candidate instanceof AnnotatedBeanDefinition) {
  293.                     AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
  294.                 }
  296.                 if (checkCandidate(beanName, candidate)) { //检查当前的和存主的bean定义是否有冲突
  297.                     //把候选的组件封装成BeanDefinitionHolder
  298.                     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
  299.                     definitionHolder =AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  300.                     //加入到bean定义的集合中
  301.                     beanDefinitions.add(definitionHolder);
  302.                     //注册当前的bean定义信息
  303.                     registerBeanDefinition(definitionHolder, this.registry);
  304.                 }
  305.             }
  306.         }
  307.         return beanDefinitions;
  308.     }
  311. org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents 
  312.     找到候选的组件 返回Set<BeanDefinition>的集合
  314.     public Set<BeanDefinition> findCandidateComponents(String basePackage) {
  315.         //候选的bean定义信息
  316.         Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
  317.         try {
  318.             //拼接需要扫描包下面的类的路径   classpath*:com/tuling/testapplicationlistener/**/*.class
  319.             String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
  320.                     resolveBasePackage(basePackage) + '/' + this.resourcePattern;
  321.             //把路径解析成一个个.class文件        
  322.             Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
  323.             boolean traceEnabled = logger.isTraceEnabled();
  324.             boolean debugEnabled = logger.isDebugEnabled();
  326.             //循环.class文件的resource对象
  327.             for (Resource resource : resources) {
  328.                 if (traceEnabled) {
  329.                     logger.trace("Scanning " + resource);
  330.                 }
  331.                 //判断class文件是否可读
  332.                 if (resource.isReadable()) {
  333.                     try {
  334.                         //把resource对象 变为一个类的原信息读取器
  335.                         MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
  336.                         //判断类的源信息读取器是否为候选的组件
  337.                         if (isCandidateComponent(metadataReader)) {  //是候选的组件
  338.                             //把类元信息读取器封装成一个ScannedGenericBeanDefinition
  339.                             ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
  340.                             sbd.setResource(resource);
  341.                             sbd.setSource(resource);
  342.                             //是候选的组件
  343.                             if (isCandidateComponent(sbd)) {
  344.                                 if (debugEnabled) {
  345.                                     logger.debug("Identified candidate component class: " + resource);
  346.                                 }
  347.                                 //把当前解析出来的定义的加入到 BeanDefinition的集合中
  348.                                 candidates.add(sbd);
  349.                             }
  350.                             else {
  351.                                 if (debugEnabled) {
  352.                                     logger.debug("Ignored because not a concrete top-level class: " + resource);
  353.                                 }
  354.                             }
  355.                         }
  356.                         else {
  357.                             if (traceEnabled) {
  358.                                 logger.trace("Ignored because not matching any filter: " + resource);
  359.                             }
  360.                         }
  361.                     }
  362.                     catch (Throwable ex) {
  363.                         throw new BeanDefinitionStoreException(
  364.                                 "Failed to read candidate component class: " + resource, ex);
  365.                     }
  366.                 }
  367.                 else {
  368.                     if (traceEnabled) {
  369.                         logger.trace("Ignored because not readable: " + resource);
  370.                     }
  371.                 }
  372.             }
  373.         }
  374.         catch (IOException ex) {
  375.             throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
  376.         }
  377.         return candidates;
  378.     }    
  380. 是不是需要扫描的组件    
  381. org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isCandidateComponent
  382.     protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
  383.         //是不是被排除的
  384.         for (TypeFilter tf : this.excludeFilters) {
  385.             if (tf.match(metadataReader, this.metadataReaderFactory)) {
  386.                 return false;
  387.             }
  388.         }
  389.         //在被包含的组件
  390.         for (TypeFilter tf : this.includeFilters) {
  391.             if (tf.match(metadataReader, this.metadataReaderFactory)) {
  392.                 return isConditionMatch(metadataReader);
  393.             }
  394.         }
  395.         return false;
  396.     }    
  398. 是否能够进行@Conditional判断
  399.     org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isConditionMatch
  400.     private boolean isConditionMatch(MetadataReader metadataReader) {
  401.         if (this.conditionEvaluator == null) {
  402.             this.conditionEvaluator = new ConditionEvaluator(getRegistry(), getEnvironment(), getResourceLoader());
  403.         }
  404.         return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
  405.     }