个人随笔
目录
一个简单的例子来探寻Spring实例化bean执行源码的主脉络(二)：解析配置类
2021-07-19 23:08:43

在上一篇文章中一个简单的例子来探寻Spring实例化bean执行源码的主脉络(一)：this()方法，我们跟踪源码还是不知道怎么解析配置类，只是走完了this()方法，跟配置类感觉没有一毛钱的关系，这里我们大概了解了一下this做了啥？

1、初始化了AnnotationConfigApplicationContext对象
2、初始化了AnnotationConfigApplicationContext的父对象GenericApplicationContext
3、GenericApplicationContext对象里面初始化了一个beanFactory成员变量，对象为DefaultListableBeanFactory
4、初始化了一个reader:AnnotatedBeanDefinitionReader
5、初始化reder的过程中把几个后置处理器比如internalPersistenceAnnotationProcessor和internalAutowiredAnnotationProcessor等放到了DefaultListableBeanFactory中的beanDefinitionMap中，key为bean的名称，值为beanDefinition放的应该是这些后置处理器的相关类定义
6、初始化了一个scanner:ClassPathBeanDefinitionScanner

推测所有要加载为bean的类都将放到beanDefinitionMap中！

先在我们继续看看第二个方法register(componentClasses);

  1. public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
  2.         this();
  3.         register(componentClasses);
  4.         refresh();
  5.     }

执行register(componentClasses);方法

这里我们终于看到了我们传入的参数，那大概可以推测，应该是在这个方法里面对我们的配置类进行初始化的，由上一篇文章我们可以合理推测，配置类也会放到beanDefinitionMap中，看看是不是这样，跟踪代码进去。

  1. /**
  2.      * Register one or more component classes to be processed.
  3.      * <p>Note that {@link #refresh()} must be called in order for the context
  4.      * to fully process the new classes.
  5.      * @param componentClasses one or more component classes — for example,
  6.      * {@link Configuration @Configuration} classes
  7.      * @see #scan(String...)
  8.      * @see #refresh()
  9.      */
  10.     @Override
  11.     public void register(Class<?>... componentClasses) {
  12.         Assert.notEmpty(componentClasses, "At least one component class must be specified");
  13.         this.reader.register(componentClasses);
  14.     }

看注释说是注册一个或者多个要处理的组件类，大概猜测一下，这里应该是注册类，而不是生成bean，所以可能是解析配置类SpringConfiguration，然后解析配置类上的@ComponentScan(basePackages = “com.suibibk.spring”)，然后把com.suibibk.spring文件加下的加了@Component注解的类全部都注册进来(猜测失败，值注册了SpringConfiguration)，注册到哪里呢？大胆推测注册到DefaultListableBeanFactor的beanDefinitionMap中去，好让后面实例化bean，当然推测不一定正确，不过好的框架一定会有重充足的注释，我们一定要根据注释和变量命名来推测理解源码！这里然后u调用的是

  1. this.reader.register(componentClasses);

reader就是在this()方法里面初始化的AnnotationConfigApplicationContext对象的AnnotatedBeanDefinitionReader，继续跟进去

  1. public void register(Class<?>... componentClasses) {
  2.         for (Class<?> componentClass : componentClasses) {
  3.             registerBean(componentClass);
  4.         }
  5.     }

这里的意思是可能会传入多个配置类，然后循环处理所有的配置类调用registerBean(componentClass);方法，跟踪进去

  1. /**
  2.      * Register a bean from the given bean class, deriving its metadata from
  3.      * class-declared annotations.
  4.      * @param beanClass the class of the bean
  5.      */
  6.     public void registerBean(Class<?> beanClass) {
  7.         doRegisterBean(beanClass, null, null, null, null);
  8.     }

方法的注释的意思是说从给定的bean类中注册一个bean，然后从类声名注解中得到他的元数据，是不是有点不知所云，不过大概可以知道还是解析配置类，继续跟进去

  1. private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
  2.             @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
  3.             @Nullable BeanDefinitionCustomizer[] customizers) {
  5.         AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
  6.         if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
  7.             return;
  8.         }
  10.         abd.setInstanceSupplier(supplier);
  11.         ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
  12.         abd.setScope(scopeMetadata.getScopeName());
  13.         String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
  15.         AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
  16.         if (qualifiers != null) {
  17.             for (Class<? extends Annotation> qualifier : qualifiers) {
  18.                 if (Primary.class == qualifier) {
  19.                     abd.setPrimary(true);
  20.                 }
  21.                 else if (Lazy.class == qualifier) {
  22.                     abd.setLazyInit(true);
  23.                 }
  24.                 else {
  25.                     abd.addQualifier(new AutowireCandidateQualifier(qualifier));
  26.                 }
  27.             }
  28.         }
  29.         if (customizers != null) {
  30.             for (BeanDefinitionCustomizer customizer : customizers) {
  31.                 customizer.customize(abd);
  32.             }
  33.         }
  35.         BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
  36.         definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  37.         BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
  38.     }

我们先看第一行代码

  1. AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);

这里相当于把我们传来的配置类包装了一下，变成了AnnotatedGenericBeanDefinition对象，话说，具体有啥用我也不知道，因为我们就只传了第一个参数beanClass，所以后面的qualifiers和customizers都是null，直接跳过，然后执行到最后的代码

  1. BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
  2. definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  3. BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

所料不差，就是把配置类注册到了DefaultListableBeanFactor的beanDefinitionMap中去，不过并没有对配置类的@ComponentScan进行解析，上面猜测失败，也就是说，register(componentClasses);方法只是对配置类进行了处理而已，其他啥都没有操作。

好吧，到这里我们已经看了this()和register(componentClasses)的源码，也知道了是在register注册了配置类，但是没有进行解析，看来一切都将在

  1. refresh();

中水落石出，走起！

执行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.                 invokeBeanFactoryPostProcessors(beanFactory);
  20.                 // Register bean processors that intercept bean creation.
  21.                 registerBeanPostProcessors(beanFactory);
  23.                 // Initialize message source for this context.
  24.                 initMessageSource();
  26.                 // Initialize event multicaster for this context.
  27.                 initApplicationEventMulticaster();
  29.                 // Initialize other special beans in specific context subclasses.
  30.                 onRefresh();
  32.                 // Check for listener beans and register them.
  33.                 registerListeners();
  35.                 // Instantiate all remaining (non-lazy-init) singletons.
  36.                 finishBeanFactoryInitialization(beanFactory);
  38.                 // Last step: publish corresponding event.
  39.                 finishRefresh();
  40.             }
  42.             catch (BeansException ex) {
  43.                 if (logger.isWarnEnabled()) {
  44.                     logger.warn("Exception encountered during context initialization - " +
  45.                             "cancelling refresh attempt: " + ex);
  46.                 }
  48.                 // Destroy already created singletons to avoid dangling resources.
  49.                 destroyBeans();
  51.                 // Reset 'active' flag.
  52.                 cancelRefresh(ex);
  54.                 // Propagate exception to caller.
  55.                 throw ex;
  56.             }
  58.             finally {
  59.                 // Reset common introspection caches in Spring's core, since we
  60.                 // might not ever need metadata for singleton beans anymore...
  61.                 resetCommonCaches();
  62.             }
  63.         }
  64.     }

这个方法很长，我们一行行来分析，有些理解不了的就先跳过，毕竟我们只是为了找到主脉络，目的是知道spring在什么地方对配置类进行解析以及在什么地方进行初始化的。
先看第一行代码

  1. prepareRefresh();

准备刷新？

  1. /**
  2.      * Prepare this context for refreshing, setting its startup date and
  3.      * active flag as well as performing any initialization of property sources.
  4.      */
  5.     protected void prepareRefresh() {
  6.         // Switch to active.
  7.         this.startupDate = System.currentTimeMillis();
  8.         this.closed.set(false);
  9.         this.active.set(true);
  11.         if (logger.isDebugEnabled()) {
  12.             if (logger.isTraceEnabled()) {
  13.                 logger.trace("Refreshing " + this);
  14.             }
  15.             else {
  16.                 logger.debug("Refreshing " + getDisplayName());
  17.             }
  18.         }
  20.         // Initialize any placeholder property sources in the context environment.
  21.         initPropertySources();
  23.         // Validate that all properties marked as required are resolvable:
  24.         // see ConfigurablePropertyResolver#setRequiredProperties
  25.         getEnvironment().validateRequiredProperties();
  27.         // Store pre-refresh ApplicationListeners...
  28.         if (this.earlyApplicationListeners == null) {
  29.             this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
  30.         }
  31.         else {
  32.             // Reset local application listeners to pre-refresh state.
  33.             this.applicationListeners.clear();
  34.             this.applicationListeners.addAll(this.earlyApplicationListeners);
  35.         }
  37.         // Allow for the collection of early ApplicationEvents,
  38.         // to be published once the multicaster is available...
  39.         this.earlyApplicationEvents = new LinkedHashSet<>();
  40.     }

what?设置一些初始时间和活跃标志？大概浏览下应该是跟解析配置文件和初始bean什么的没有任何关系的，可以跳过！

咱们来看第二行代码

  1. // Tell the subclass to refresh the internal bean factory.
  2. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

告诉子类刷新内部的bean工厂，点进去看看

  1. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  2.         refreshBeanFactory();
  3.         return getBeanFactory();
  4.     }
  1. @Override
  2.     protected final void refreshBeanFactory() throws IllegalStateException {
  3.         if (!this.refreshed.compareAndSet(false, true)) {
  4.             throw new IllegalStateException(
  5.                     "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
  6.         }
  7.         this.beanFactory.setSerializationId(getId());
  8.     }

上面的代码是在GenericApplicationContext下，因为我们的AnnotationConfigApplicationContext继承的就是这个对象，这里只是简单的设置一些信息，我们再看 getBeanFactory()

  1. /**
  2.      * Return the single internal BeanFactory held by this context
  3.      * (as ConfigurableListableBeanFactory).
  4.      */
  5.     @Override
  6.     public final ConfigurableListableBeanFactory getBeanFactory() {
  7.         return this.beanFactory;
  8.     }

只是返回一个BeanFactory由前面我们知道，这里就是DefaultListableBeanFactor对象。我们继续看代码

  1. // Prepare the bean factory for use in this context.
  2. prepareBeanFactory(beanFactory);

对这个beanFactory做一些准备工作，我们看看准备了啥

  1. /**
  2.      * Configure the factory's standard context characteristics,
  3.      * such as the context's ClassLoader and post-processors.
  4.      * @param beanFactory the BeanFactory to configure
  5.      */
  6.     protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  7.         // Tell the internal bean factory to use the context's class loader etc.
  8.         beanFactory.setBeanClassLoader(getClassLoader());
  9.         beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  10.         beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
  12.         // Configure the bean factory with context callbacks.
  13.         beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  14.         beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  15.         beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  16.         beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  17.         beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  18.         beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  19.         beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
  21.         // BeanFactory interface not registered as resolvable type in a plain factory.
  22.         // MessageSource registered (and found for autowiring) as a bean.
  23.         beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  24.         beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  25.         beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  26.         beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  28.         // Register early post-processor for detecting inner beans as ApplicationListeners.
  29.         beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
  31.         // Detect a LoadTimeWeaver and prepare for weaving, if found.
  32.         if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  33.             beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  34.             // Set a temporary ClassLoader for type matching.
  35.             beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  36.         }
  38.         // Register default environment beans.
  39.         if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  40.             beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  41.         }
  42.         if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  43.             beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  44.         }
  45.         if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  46.             beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  47.         }
  48.     }

一大串，对就是准备了一大串，看不懂没关系，反正我们知道是在做一些准备工作，我们看看有哪些看得懂的，比如beanFactory.setBeanClassLoader(getClassLoader());设置类加载器，

  1. beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

加入一个Bean后置处理器，加入的是ApplicationContextAwareProcessor对象，我们知道前面在执行this()方法的时候也还加入了很多其它的后置处理器。其它的不看先，跟我的目标有区别，我是要找到什么地方解析配置类。我们看下一行

  1. // Allows post-processing of the bean factory in context subclasses.
  2. postProcessBeanFactory(beanFactory);

允许在上下文子类中对bean工厂进行后处理,点进去发现是一个空的方法，应该是模板方法为了让后面的子类实现然后对代码逻辑进行增强把。继续

  1. // Invoke factory processors registered as beans in the context.
  2. invokeBeanFactoryPostProcessors(beanFactory);

在上下文中调用注册为bean的工厂处理器。额，看注释感觉是一个很重要的方法，难道一切都会在这里水落石出？

invokeBeanFactoryPostProcessors(beanFactory);方法

  1. /**
  2.      * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
  3.      * respecting explicit order if given.
  4.      * <p>Must be called before singleton instantiation.
  5.      */
  6.     protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  7.         PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
  9.         // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
  10.         // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
  11.         if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  12.             beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  13.             beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  14.         }
  15.     }

实例化并调用所有注册的BeanFactoryPostProcessor，我们继续跟踪代码

  1. PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
  1. public static void invokeBeanFactoryPostProcessors(
  2.             ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  4.         // Invoke BeanDefinitionRegistryPostProcessors first, if any.
  5.         Set<String> processedBeans = new HashSet<>();
  7.         if (beanFactory instanceof BeanDefinitionRegistry) {
  8.             BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  9.             List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
  10.             List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
  12.             for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
  13.                 if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
  14.                     BeanDefinitionRegistryPostProcessor registryProcessor =
  15.                             (BeanDefinitionRegistryPostProcessor) postProcessor;
  16.                     registryProcessor.postProcessBeanDefinitionRegistry(registry);
  17.                     registryProcessors.add(registryProcessor);
  18.                 }
  19.                 else {
  20.                     regularPostProcessors.add(postProcessor);
  21.                 }
  22.             }
  24.             // Do not initialize FactoryBeans here: We need to leave all regular beans
  25.             // uninitialized to let the bean factory post-processors apply to them!
  26.             // Separate between BeanDefinitionRegistryPostProcessors that implement
  27.             // PriorityOrdered, Ordered, and the rest.
  28.             List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
  30.             // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
  31.             String[] postProcessorNames =
  32.                     beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  33.             for (String ppName : postProcessorNames) {
  34.                 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  35.                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  36.                     processedBeans.add(ppName);
  37.                 }
  38.             }
  39.             sortPostProcessors(currentRegistryProcessors, beanFactory);
  40.             registryProcessors.addAll(currentRegistryProcessors);
  41.             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  42.             currentRegistryProcessors.clear();
  44.             // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
  45.             postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  46.             for (String ppName : postProcessorNames) {
  47.                 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
  48.                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  49.                     processedBeans.add(ppName);
  50.                 }
  51.             }
  52.             sortPostProcessors(currentRegistryProcessors, beanFactory);
  53.             registryProcessors.addAll(currentRegistryProcessors);
  54.             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  55.             currentRegistryProcessors.clear();
  57.             // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
  58.             boolean reiterate = true;
  59.             while (reiterate) {
  60.                 reiterate = false;
  61.                 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  62.                 for (String ppName : postProcessorNames) {
  63.                     if (!processedBeans.contains(ppName)) {
  64.                         currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  65.                         processedBeans.add(ppName);
  66.                         reiterate = true;
  67.                     }
  68.                 }
  69.                 sortPostProcessors(currentRegistryProcessors, beanFactory);
  70.                 registryProcessors.addAll(currentRegistryProcessors);
  71.                 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  72.                 currentRegistryProcessors.clear();
  73.             }
  75.             // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
  76.             invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
  77.             invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
  78.         }
  80.         else {
  81.             // Invoke factory processors registered with the context instance.
  82.             invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
  83.         }
  85.         // Do not initialize FactoryBeans here: We need to leave all regular beans
  86.         // uninitialized to let the bean factory post-processors apply to them!
  87.         String[] postProcessorNames =
  88.                 beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
  90.         // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
  91.         // Ordered, and the rest.
  92.         List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
  93.         List<String> orderedPostProcessorNames = new ArrayList<>();
  94.         List<String> nonOrderedPostProcessorNames = new ArrayList<>();
  95.         for (String ppName : postProcessorNames) {
  96.             if (processedBeans.contains(ppName)) {
  97.                 // skip - already processed in first phase above
  98.             }
  99.             else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  100.                 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
  101.             }
  102.             else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
  103.                 orderedPostProcessorNames.add(ppName);
  104.             }
  105.             else {
  106.                 nonOrderedPostProcessorNames.add(ppName);
  107.             }
  108.         }
  110.         // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
  111.         sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  112.         invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
  114.         // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
  115.         List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
  116.         for (String postProcessorName : orderedPostProcessorNames) {
  117.             orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
  118.         }
  119.         sortPostProcessors(orderedPostProcessors, beanFactory);
  120.         invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
  122.         // Finally, invoke all other BeanFactoryPostProcessors.
  123.         List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
  124.         for (String postProcessorName : nonOrderedPostProcessorNames) {
  125.             nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
  126.         }
  127.         invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
  129.         // Clear cached merged bean definitions since the post-processors might have
  130.         // modified the original metadata, e.g. replacing placeholders in values...
  131.         beanFactory.clearMetadataCache();
  132.     }

这个代码真的真的很长！我们根据方法的意思，大概可以看的出

  1. invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

才是主要的，调用bean定义注册后置处理器，其它我们不看先，

  1. /**
  2.      * Invoke the given BeanDefinitionRegistryPostProcessor beans.
  3.      */
  4.     private static void invokeBeanDefinitionRegistryPostProcessors(
  5.             Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
  7.         for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
  8.             postProcessor.postProcessBeanDefinitionRegistry(registry);
  9.         }
  10.     }

这里看不明白，继续

  1. /**
  2.      * Derive further bean definitions from the configuration classes in the registry.
  3.      */
  4.     @Override
  5.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
  6.         int registryId = System.identityHashCode(registry);
  7.         if (this.registriesPostProcessed.contains(registryId)) {
  8.             throw new IllegalStateException(
  9.                     "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
  10.         }
  11.         if (this.factoriesPostProcessed.contains(registryId)) {
  12.             throw new IllegalStateException(
  13.                     "postProcessBeanFactory already called on this post-processor against " + registry);
  14.         }
  15.         this.registriesPostProcessed.add(registryId);
  17.         processConfigBeanDefinitions(registry);
  18.     }

从注册中心中的配置类派生进一步的bean定义,这里感觉有点苗头了，直接看

  1. processConfigBeanDefinitions(registry);
  1. /**
  2.      * Build and validate a configuration model based on the registry of
  3.      * {@link Configuration} classes.
  4.      */
  5.     public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
  6.         List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
  7.         String[] candidateNames = registry.getBeanDefinitionNames();
  9.         for (String beanName : candidateNames) {
  10.             BeanDefinition beanDef = registry.getBeanDefinition(beanName);
  11.             if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
  12.                 if (logger.isDebugEnabled()) {
  13.                     logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
  14.                 }
  15.             }
  16.             else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
  17.                 configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
  18.             }
  19.         }
  21.         // Return immediately if no @Configuration classes were found
  22.         if (configCandidates.isEmpty()) {
  23.             return;
  24.         }
  26.         // Sort by previously determined @Order value, if applicable
  27.         configCandidates.sort((bd1, bd2) -> {
  28.             int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
  29.             int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
  30.             return Integer.compare(i1, i2);
  31.         });
  33.         // Detect any custom bean name generation strategy supplied through the enclosing application context
  34.         SingletonBeanRegistry sbr = null;
  35.         if (registry instanceof SingletonBeanRegistry) {
  36.             sbr = (SingletonBeanRegistry) registry;
  37.             if (!this.localBeanNameGeneratorSet) {
  38.                 BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
  39.                         AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
  40.                 if (generator != null) {
  41.                     this.componentScanBeanNameGenerator = generator;
  42.                     this.importBeanNameGenerator = generator;
  43.                 }
  44.             }
  45.         }
  47.         if (this.environment == null) {
  48.             this.environment = new StandardEnvironment();
  49.         }
  51.         // Parse each @Configuration class
  52.         ConfigurationClassParser parser = new ConfigurationClassParser(
  53.                 this.metadataReaderFactory, this.problemReporter, this.environment,
  54.                 this.resourceLoader, this.componentScanBeanNameGenerator, registry);
  56.         Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
  57.         Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
  58.         do {
  59.             parser.parse(candidates);
  60.             parser.validate();
  62.             Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
  63.             configClasses.removeAll(alreadyParsed);
  65.             // Read the model and create bean definitions based on its content
  66.             if (this.reader == null) {
  67.                 this.reader = new ConfigurationClassBeanDefinitionReader(
  68.                         registry, this.sourceExtractor, this.resourceLoader, this.environment,
  69.                         this.importBeanNameGenerator, parser.getImportRegistry());
  70.             }
  71.             this.reader.loadBeanDefinitions(configClasses);
  72.             alreadyParsed.addAll(configClasses);
  74.             candidates.clear();
  75.             if (registry.getBeanDefinitionCount() > candidateNames.length) {
  76.                 String[] newCandidateNames = registry.getBeanDefinitionNames();
  77.                 Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
  78.                 Set<String> alreadyParsedClasses = new HashSet<>();
  79.                 for (ConfigurationClass configurationClass : alreadyParsed) {
  80.                     alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
  81.                 }
  82.                 for (String candidateName : newCandidateNames) {
  83.                     if (!oldCandidateNames.contains(candidateName)) {
  84.                         BeanDefinition bd = registry.getBeanDefinition(candidateName);
  85.                         if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
  86.                                 !alreadyParsedClasses.contains(bd.getBeanClassName())) {
  87.                             candidates.add(new BeanDefinitionHolder(bd, candidateName));
  88.                         }
  89.                     }
  90.                 }
  91.                 candidateNames = newCandidateNames;
  92.             }
  93.         }
  94.         while (!candidates.isEmpty());
  96.         // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
  97.         if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
  98.             sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
  99.         }
  101.         if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
  102.             // Clear cache in externally provided MetadataReaderFactory; this is a no-op
  103.             // for a shared cache since it'll be cleared by the ApplicationContext.
  104.             ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
  105.         }
  106.     }

构建和验证配置模型，
一开始

  1. List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
  2. String[] candidateNames = registry.getBeanDefinitionNames();

从注册表中获取所有的候选名字

  1. @Override
  2.     public String[] getBeanDefinitionNames() {
  3.         String[] frozenNames = this.frozenBeanDefinitionNames;
  4.         if (frozenNames != null) {
  5.             return frozenNames.clone();
  6.         }
  7.         else {
  8.             return StringUtils.toStringArray(this.beanDefinitionNames);
  9.         }
  10.     }

其实就是我们之前放进去的bean名称，再看后面的逻辑

  1. if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
  2.                 configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
  3.             }

看方法名字就大概知道是什么检查是否是配置类，也就是加了@Configuration注解的类,通过调试验证了我的猜想，最后configCandidates中只有com.suibibk.spring.SpringConfiguration的信息。

  1. // Parse each @Configuration class
  2.         ConfigurationClassParser parser = new ConfigurationClassParser(
  3.                 this.metadataReaderFactory, this.problemReporter, this.environment,
  4.                 this.resourceLoader, this.componentScanBeanNameGenerator, registry);

这里生成了一个解析器，我们到这里就可以猜想，后面肯定是对配置类开始进行解析处理了，果不奇然

  1. do {
  2.     parser.parse(candidates);
  3.     parser.validate();
  4.     ...

接下来就是要准备来解析了。感觉这里又是一个重大的方法。

parser.parse(candidates);方法

  1. ublic void parse(Set<BeanDefinitionHolder> configCandidates) {
  2.         for (BeanDefinitionHolder holder : configCandidates) {
  3.             BeanDefinition bd = holder.getBeanDefinition();
  4.             try {
  5.                 if (bd instanceof AnnotatedBeanDefinition) {
  6.                     parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
  7.                 }
  8.                 else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
  9.                     parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
  10.                 }
  11.                 else {
  12.                     parse(bd.getBeanClassName(), holder.getBeanName());
  13.                 }
  14.             }
  15.             catch (BeanDefinitionStoreException ex) {
  16.                 throw ex;
  17.             }
  18.             catch (Throwable ex) {
  19.                 throw new BeanDefinitionStoreException(
  20.                         "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
  21.             }
  22.         }
  24.         this.deferredImportSelectorHandler.process();
  25.     }

我们之前在注册配置类的时候开始有对配置类进行包装

  1. AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);

而AnnotatedGenericBeanDefinition

  1. public class AnnotatedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition

所以

  1. if (bd instanceof AnnotatedBeanDefinition)

为true。进入到第一个

  1. parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());

进行解析，参数为配置类的元数据和配置类名称

  1. protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
  2.         processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
  3.     }

继续跟进去

  1. protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
  2.         if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
  3.             return;
  4.         }
  6.         ConfigurationClass existingClass = this.configurationClasses.get(configClass);
  7.         if (existingClass != null) {
  8.             if (configClass.isImported()) {
  9.                 if (existingClass.isImported()) {
  10.                     existingClass.mergeImportedBy(configClass);
  11.                 }
  12.                 // Otherwise ignore new imported config class; existing non-imported class overrides it.
  13.                 return;
  14.             }
  15.             else {
  16.                 // Explicit bean definition found, probably replacing an import.
  17.                 // Let's remove the old one and go with the new one.
  18.                 this.configurationClasses.remove(configClass);
  19.                 this.knownSuperclasses.values().removeIf(configClass::equals);
  20.             }
  21.         }
  23.         // Recursively process the configuration class and its superclass hierarchy.
  24.         SourceClass sourceClass = asSourceClass(configClass, filter);
  25.         do {
  26.             sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
  27.         }
  28.         while (sourceClass != null);
  30.         this.configurationClasses.put(configClass, configClass);
  31.     }

这里调试发现existingClass为null，话说我们也没有对配置类进行任何特殊处理，所以应该是null,直接看下面的方法

  1. // Recursively process the configuration class and its superclass hierarchy.
  2. SourceClass sourceClass = asSourceClass(configClass, filter);

递归地处理配置类及其超类层次结构。我们这里就只有一个孤孤单单的配置类，所以这里面应该只有

  1. com.suibibk.spring.SpringConfiguration

话说这个方法是用于那种有注解上有注解或者继承类为配置类的情况吧，这里不考虑那么多先，直接看

  1. sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
  1. /**
  2.      * Apply processing and build a complete {@link ConfigurationClass} by reading the
  3.      * annotations, members and methods from the source class. This method can be called
  4.      * multiple times as relevant sources are discovered.
  5.      * @param configClass the configuration class being build
  6.      * @param sourceClass a source class
  7.      * @return the superclass, or {@code null} if none found or previously processed
  8.      */
  9.     @Nullable
  10.     protected final SourceClass doProcessConfigurationClass(
  11.             ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
  12.             throws IOException {
  14.         if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
  15.             // Recursively process any member (nested) classes first
  16.             processMemberClasses(configClass, sourceClass, filter);
  17.         }
  19.         // Process any @PropertySource annotations
  20.         for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
  21.                 sourceClass.getMetadata(), PropertySources.class,
  22.                 org.springframework.context.annotation.PropertySource.class)) {
  23.             if (this.environment instanceof ConfigurableEnvironment) {
  24.                 processPropertySource(propertySource);
  25.             }
  26.             else {
  27.                 logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
  28.                         "]. Reason: Environment must implement ConfigurableEnvironment");
  29.             }
  30.         }
  32.         // Process any @ComponentScan annotations
  33.         Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
  34.                 sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
  35.         if (!componentScans.isEmpty() &&
  36.                 !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
  37.             for (AnnotationAttributes componentScan : componentScans) {
  38.                 // The config class is annotated with @ComponentScan -> perform the scan immediately
  39.                 Set<BeanDefinitionHolder> scannedBeanDefinitions =
  40.                         this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
  41.                 // Check the set of scanned definitions for any further config classes and parse recursively if needed
  42.                 for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
  43.                     BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
  44.                     if (bdCand == null) {
  45.                         bdCand = holder.getBeanDefinition();
  46.                     }
  47.                     if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
  48.                         parse(bdCand.getBeanClassName(), holder.getBeanName());
  49.                     }
  50.                 }
  51.             }
  52.         }
  54.         // Process any @Import annotations
  55.         processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
  57.         // Process any @ImportResource annotations
  58.         AnnotationAttributes importResource =
  59.                 AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
  60.         if (importResource != null) {
  61.             String[] resources = importResource.getStringArray("locations");
  62.             Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
  63.             for (String resource : resources) {
  64.                 String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
  65.                 configClass.addImportedResource(resolvedResource, readerClass);
  66.             }
  67.         }
  69.         // Process individual @Bean methods
  70.         Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
  71.         for (MethodMetadata methodMetadata : beanMethods) {
  72.             configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
  73.         }
  75.         // Process default methods on interfaces
  76.         processInterfaces(configClass, sourceClass);
  78.         // Process superclass, if any
  79.         if (sourceClass.getMetadata().hasSuperClass()) {
  80.             String superclass = sourceClass.getMetadata().getSuperClassName();
  81.             if (superclass != null && !superclass.startsWith("java") &&
  82.                     !this.knownSuperclasses.containsKey(superclass)) {
  83.                 this.knownSuperclasses.put(superclass, configClass);
  84.                 // Superclass found, return its annotation metadata and recurse
  85.                 return sourceClass.getSuperClass();
  86.             }
  87.         }
  89.         // No superclass -> processing is complete
  90.         return null;
  91.     }

额又是常长的方法，不用怕，我们看下代码，发现有如下几处注释有点熟悉

  1. // Process any @PropertySource annotations
  2. // Process any @ComponentScan annotations
  3. // Process any @Import annotations
  4. // Process any @ImportResource annotations
  5. // Process individual @Bean methods
  6. / Process default methods on interfaces

我们一眼就看到了我们的目的 @ComponentScan 那其它我们就不看先。

  1. Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
  2.                 sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
  3.         if (!componentScans.isEmpty() &&
  4.                 !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
  5.             for (AnnotationAttributes componentScan : componentScans) {
  6.                 // The config class is annotated with @ComponentScan -> perform the scan immediately
  7.                 Set<BeanDefinitionHolder> scannedBeanDefinitions =
  8.                         this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
  9.                 // Check the set of scanned definitions for any further config classes and parse recursively if needed
  10.                 for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
  11.                     BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
  12.                     if (bdCand == null) {
  13.                         bdCand = holder.getBeanDefinition();
  14.                     }
  15.                     if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
  16.                         parse(bdCand.getBeanClassName(), holder.getBeanName());
  17.                     }
  18.                 }
  19.             }
  20.         }

开始先获取了componentScans注解信息，我们知道为

  1. basePackages=[com.suibibk.spring]

我们直接看代码

  1. // The config class is annotated with @ComponentScan -> perform the scan immediately
  2.                 Set<BeanDefinitionHolder> scannedBeanDefinitions =
  3.                         this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

这里解析该componentScan返回BeanDefinitionHolders，可以大胆的推测这个方法里面一定去扫描了com.suibibk.spring路径下面的所有类和子类，如果有@component注解则会解析为BeanDefinition注册到放到了DefaultListableBeanFactory中的beanDefinitionMap中，key为bean的名称，值为beanDefinition放的应该是这些类的相关类定义，其实我有点奇怪为啥这里还要返回，解析完就直接放到beanDefinitionMap中了啊。然后我看到了下面。

  1. for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
  2.                     BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
  3.                     if (bdCand == null) {
  4.                         bdCand = holder.getBeanDefinition();
  5.                     }
  6.                     if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
  7.                         parse(bdCand.getBeanClassName(), holder.getBeanName());
  8.                     }
  9.                 }

原来是怕解析出来的类有些也是配置类。

好了我们继续跟进去上面的parse方法去

  1. public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
  2.         ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
  3.                 componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
  5.         Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
  6.         boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
  7.         scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
  8.                 BeanUtils.instantiateClass(generatorClass));
  10.         ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
  11.         if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
  12.             scanner.setScopedProxyMode(scopedProxyMode);
  13.         }
  14.         else {
  15.             Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
  16.             scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
  17.         }
  19.         scanner.setResourcePattern(componentScan.getString("resourcePattern"));
  21.         for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
  22.             for (TypeFilter typeFilter : typeFiltersFor(filter)) {
  23.                 scanner.addIncludeFilter(typeFilter);
  24.             }
  25.         }
  26.         for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
  27.             for (TypeFilter typeFilter : typeFiltersFor(filter)) {
  28.                 scanner.addExcludeFilter(typeFilter);
  29.             }
  30.         }
  32.         boolean lazyInit = componentScan.getBoolean("lazyInit");
  33.         if (lazyInit) {
  34.             scanner.getBeanDefinitionDefaults().setLazyInit(true);
  35.         }
  37.         Set<String> basePackages = new LinkedHashSet<>();
  38.         String[] basePackagesArray = componentScan.getStringArray("basePackages");
  39.         for (String pkg : basePackagesArray) {
  40.             String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
  41.                     ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
  42.             Collections.addAll(basePackages, tokenized);
  43.         }
  44.         for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
  45.             basePackages.add(ClassUtils.getPackageName(clazz));
  46.         }
  47.         if (basePackages.isEmpty()) {
  48.             basePackages.add(ClassUtils.getPackageName(declaringClass));
  49.         }
  51.         scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
  52.             @Override
  53.             protected boolean matchClassName(String className) {
  54.                 return declaringClass.equals(className);
  55.             }
  56.         });
  57.         return scanner.doScan(StringUtils.toStringArray(basePackages));
  58.     }

其实这个前面都不用看，扫描一样就发现了最重要的代码

  1. return scanner.doScan(StringUtils.toStringArray(basePackages));

话说，spring习惯把最终要执行的代码方法名称以do开头。

  1. /**
  2.      * Perform a scan within the specified base packages,
  3.      * returning the registered bean definitions.
  4.      * <p>This method does <i>not</i> register an annotation config processor
  5.      * but rather leaves this up to the caller.
  6.      * @param basePackages the packages to check for annotated classes
  7.      * @return set of beans registered if any for tooling registration purposes (never {@code null})
  8.      */
  9.     protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
  10.         Assert.notEmpty(basePackages, "At least one base package must be specified");
  11.         Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
  12.         for (String basePackage : basePackages) {
  13.             Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
  14.             for (BeanDefinition candidate : candidates) {
  15.                 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
  16.                 candidate.setScope(scopeMetadata.getScopeName());
  17.                 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
  18.                 if (candidate instanceof AbstractBeanDefinition) {
  19.                     postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
  20.                 }
  21.                 if (candidate instanceof AnnotatedBeanDefinition) {
  22.                     AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
  23.                 }
  24.                 if (checkCandidate(beanName, candidate)) {
  25.                     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
  26.                     definitionHolder =
  27.                             AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  28.                     beanDefinitions.add(definitionHolder);
  29.                     registerBeanDefinition(definitionHolder, this.registry);
  30.                 }
  31.             }
  32.         }

我们看这一行

  1. Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

这里直接就根据包路径返回了所有的BeanDefinition，所以这里绝bi是一行关键代码，后面就直接遍历candidates注册到DefaultListableBeanFactory中了,这个我们在this()方法里面注册一些后置处理器的时候看过，这里就不多说。

  1. /**
  2.      * Scan the class path for candidate components.
  3.      * @param basePackage the package to check for annotated classes
  4.      * @return a corresponding Set of autodetected bean definitions
  5.      */
  6.     public Set<BeanDefinition> findCandidateComponents(String basePackage) {
  7.         if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
  8.             return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
  9.         }
  10.         else {
  11.             return scanCandidateComponents(basePackage);
  12.         }
  13.     }

扫描类路径，寻找候选组件。
直接看

  1. return scanCandidateComponents(basePackage);

不要问我为啥不看

  1. return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);

额，按直觉来说我就不会选择它，看源码不要想着一下就全部弄明白，要靠直觉和大胆的推测以及略过看不懂的先再辅助于调试就可以了。

  1. private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
  2.         Set<BeanDefinition> candidates = new LinkedHashSet<>();
  3.         try {
  4.             //拼接路径，这里是：classpath*:com/suibibk/spring/**/*.class
  5.             String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
  6.                     resolveBasePackage(basePackage) + '/' + this.resourcePattern;
  7.             //根据路径获得资源
  8.             Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
  9.             boolean traceEnabled = logger.isTraceEnabled();
  10.             boolean debugEnabled = logger.isDebugEnabled();
  11.             for (Resource resource : resources) {
  12.                 if (traceEnabled) {
  13.                     logger.trace("Scanning " + resource);
  14.                 }
  15.                 if (resource.isReadable()) {
  16.                     try {
  17.                         MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
  18.                         //判断是否是候选Component，也就是加了@Component注解的类
  19.                         if (isCandidateComponent(metadataReader)) {
  20.                             //是的化这里就创建BeanDefinition
  21.                             ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
  22.                             sbd.setSource(resource);
  23.                             if (isCandidateComponent(sbd)) {
  24.                                 if (debugEnabled) {
  25.                                     logger.debug("Identified candidate component class: " + resource);
  26.                                 }
  27.                                 //加入到集合中
  28.                                 candidates.add(sbd);
  29.                             }
  30.                             else {
  31.                                 if (debugEnabled) {
  32.                                     logger.debug("Ignored because not a concrete top-level class: " + resource);
  33.                                 }
  34.                             }
  35.                         }
  36.                         else {
  37.                             if (traceEnabled) {
  38.                                 logger.trace("Ignored because not matching any filter: " + resource);
  39.                             }
  40.                         }
  41.                     }
  42.                     catch (Throwable ex) {
  43.                         throw new BeanDefinitionStoreException(
  44.                                 "Failed to read candidate component class: " + resource, ex);
  45.                     }
  46.                 }
  47.                 else {
  48.                     if (traceEnabled) {
  49.                         logger.trace("Ignored because not readable: " + resource);
  50.                     }
  51.                 }
  52.             }
  53.         }
  54.         catch (IOException ex) {
  55.             throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
  56.         }
  57.         //返回
  58.         return candidates;
  59.     }

大概过程是
1、拼接路径获得包扫描真实的路径
2、获得资源集合
3、遍历资源获得可读的元标签数据
4、判断是否是候选的组件
5、如果是候选的组件则生成BeanDefinition加入集合中
6、返回候选集合。

到这里终于把配置类解析完了。接下来就是上面说的，循环遍历候选集合注册到DefaultListableBeanFactory的beanDefinitionMap中。

  1. registerBeanDefinition(definitionHolder, this.registry);

关键点总结：

1、register(componentClasses);方法把配置类注册到DefaultListableBeanFactory的beanDefinitionMap中。
2、refresh();中的invokeBeanFactoryPostProcessors(beanFactory);解析配置类，把@ComponentScan(basePackages = “com.suibibk.spring”)路径下的所有加了@Component注解的类注册到DefaultListableBeanFactory的beanDefinitionMap中。

接下来就应该是bean初始化了，毕竟该有的东西都已经在DefaultListableBeanFactory的beanDefinitionMap中了。

 221

啊！这个可能是世界上最丑的留言输入框功能~


当然，也是最丑的留言列表

有疑问发邮件到 : suibibk@qq.com 侵权立删
Copyright : 个人随笔   备案号 : 粤ICP备18099399号-2