个人随笔
目录
Spring源码分析：SpringIOC初始化过程源码分析-基于注解方式（四）
2020-09-28 22:28:03

在上一篇文章中，我们分析了SpringIOC基于配置文件方式的启动源码分析，以及单例bean的初始化过程，这一片文章我们来看看SpringIOC基于注解方式的启动过程，其实主要区别就是一个解析配置文件获得BeanDefinition一个是按注解扫描包获得BeanDefinition，后面的实例化过程是一样的了，所以这篇文章也只是分析到获得BeanDefinition.

SpringIOC 初始化过程–Bean容器的创建过程(基于AnnotationConfigApplicationContext方式)

这里写一个启动Spring容器的例子

IndexDao

  1. public interface IndexDao {
  3.     String testSource();
  4. }

IndexDaoImpl

  1. @Service
  2. public class IndexDaoImpl implements IndexDao {
  4.     public IndexDaoImpl() {
  5.         System.out.println("constructor");
  6.     }
  8.     public String testSource(){
  10.         return "test \n test2";
  11.     }
  12. }

AppConfig

  1. @Configuration
  2. @ComponentScan("cn.haoxy")
  3. public class AppConfig {
  4. }

TestBean

  1. public class TestBean {
  2.     public static void main(String[] args) {
  3.         AnnotationConfigApplicationContext applicationContext = new     AnnotationConfigApplicationContext();
  4.         applicationContext.register(AppConfig.class);
  5.         applicationContext.refresh();
  6.         IndexDao bean = applicationContext.getBean(IndexDao.class);
  7.         System.out.println(bean.testSource());
  8.         applicationContext.close();
  9.     }
  10. }

在Maven构建项目时引入的

  1. <dependency>
  2.   <groupId>org.springframework</groupId>
  3.   <artifactId>spring-context</artifactId>
  4.   <version>5.0.11.RELEASE</version>
  5. </dependency>

在看关于spring源码的文章时很多都是基于 ClassPathXmlApplicationContext(…) 现在都基于springboot项目很少再使用xml的方式去配置,现在很多都是基于注解的方式; 所以本文我们使用AnnotationConfigApplicationContext();来进行讲解;

当然，除了这两个以外我们也还有其他构建 ApplicationContext 的方案可供选择:

FileSystemXmlApplicationContext: 的构造函数需要一个 xml 配置文件在系统中的路径，其他和 ClassPathXmlApplicationContext 基本上一样。

对于上面的类我们先混个眼熟就行;后面我们会再说到的;

启动过程分析

AnnotationConfigApplicationContext();方法介绍
第一步: 我们肯定要从AnnotationConfigApplicationContext的构造方法开始说起;

AnnotationConfigApplicationContext有父类,故先要执行父类的构造方法;父类的构造方法实例化一个工厂DefaultListableBeanFactory

  1. public GenericApplicationContext() {
  2.         this.beanFactory = new DefaultListableBeanFactory();
  3.     }

到这里我们再来看一个类图:主要是BeanFactory介绍:

ApplicationContext 继承了 ListableBeanFactory，这个 Listable 的意思就是，通过这个接口，我们可以获取多个 Bean，大家看源码会发现，最顶层 BeanFactory 接口的方法都是获取单个 Bean 的。

ApplicationContext 继承了 HierarchicalBeanFactory，Hierarchical 单词本身已经能说明问题了，也就是说我们可以在应用中起多个 BeanFactory，然后可以将各个 BeanFactory 设置为父子关系。

AutowireCapableBeanFactory 这个名字中的 Autowire 大家都非常熟悉，它就是用来自动装配 Bean 用的，但是仔细看上图，ApplicationContext 并没有继承它，不过不用担心，不使用继承，不代表不可以使用组合，如果你看到 ApplicationContext 接口定义中的最后一个方法 getAutowireCapableBeanFactory() 就知道了。

ConfigurableListableBeanFactory 也是一个特殊的接口，看图，特殊之处在于它继承了第二层所有的三个接口，而 ApplicationContext 没有。这点之后会用到。

然后，请读者打开编辑器，翻一下 BeanFactory、ListableBeanFactory、HierarchicalBeanFactory、AutowireCapableBeanFactory、ApplicationContext 这几个接口的代码，

下面我们着重介绍一下DefaultListableBeanFactory,我们可以看到 ConfigurableListableBeanFactory 只有一个实现类 DefaultListableBeanFactory，而且实现类 DefaultListableBeanFactory 还通过实现右边的 AbstractAutowireCapableBeanFactory 通吃了右路。所以结论就是，最底下这个家伙 DefaultListableBeanFactory 基本上是最牛的 BeanFactory 了，这也是为什么这边会使用这个类来实例化的原因。上面在的构造方法中实例化了DefaultListableBeanFactory,DefaultListableBeanFactory类中定义了

  1. private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

和

  1. private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

至于这两个东西是做什么的,我们需要先了解一下BeanDefinition;

BeanDefinition介绍

我们来看下 BeanDefinition 的接口定义：

  1. public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
  3.    // 我们可以看到，默认只提供 sington 和 prototype 两种，
  4.    // 很多读者可能知道还有 request, session, globalSession, application, websocket 这几种，
  5.    // 不过，它们属于基于 web 的扩展。
  6.    String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
  7.    String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
  9.    // 比较不重要，直接跳过吧
  10.    int ROLE_APPLICATION = 0;
  11.    int ROLE_SUPPORT = 1;
  12.    int ROLE_INFRASTRUCTURE = 2;
  14.    // 设置父 Bean，这里涉及到 bean 继承，不是 java 继承。请参见附录的详细介绍
  15.    // 一句话就是：继承父 Bean 的配置信息而已
  16.    void setParentName(String parentName);
  18.    // 获取父 Bean
  19.    String getParentName();
  21.    // 设置 Bean 的类名称，将来是要通过反射来生成实例的
  22.    void setBeanClassName(String beanClassName);
  24.    // 获取 Bean 的类名称
  25.    String getBeanClassName();
  28.    // 设置 bean 的 scope
  29.    void setScope(String scope);
  31.    String getScope();
  33.    // 设置是否懒加载
  34.    void setLazyInit(boolean lazyInit);
  36.    boolean isLazyInit();
  38.    // 设置该 Bean 依赖的所有的 Bean，注意，这里的依赖不是指属性依赖(如 @Autowire 标记的)，
  39.    // 是 depends-on="" 属性设置的值。
  40.    void setDependsOn(String... dependsOn);
  42.    // 返回该 Bean 的所有依赖
  43.    String[] getDependsOn();
  45.    // 设置该 Bean 是否可以注入到其他 Bean 中，只对根据类型注入有效，
  46.    // 如果根据名称注入，即使这边设置了 false，也是可以的
  47.    void setAutowireCandidate(boolean autowireCandidate);
  49.    // 该 Bean 是否可以注入到其他 Bean 中
  50.    boolean isAutowireCandidate();
  52.    // 主要的。同一接口的多个实现，如果不指定名字的话，Spring 会优先选择设置 primary 为 true 的 bean
  53.    void setPrimary(boolean primary);
  55.    // 是否是 primary 的
  56.    boolean isPrimary();
  58.    // 如果该 Bean 采用工厂方法生成，指定工厂名称;
  59.    // 一句话就是：有些实例不是用反射生成的，而是用工厂模式生成的
  60.    void setFactoryBeanName(String factoryBeanName);
  61.    // 获取工厂名称
  62.    String getFactoryBeanName();
  63.    // 指定工厂类中的 工厂方法名称
  64.    void setFactoryMethodName(String factoryMethodName);
  65.    // 获取工厂类中的 工厂方法名称
  66.    String getFactoryMethodName();
  68.    // 构造器参数
  69.    ConstructorArgumentValues getConstructorArgumentValues();
  71.    // Bean 中的属性值，后面给 bean 注入属性值的时候会说到
  72.    MutablePropertyValues getPropertyValues();
  74.    // 是否 singleton
  75.    boolean isSingleton();
  77.    // 是否 prototype
  78.    boolean isPrototype();
  80.    // 如果这个 Bean 是被设置为 abstract，那么不能实例化，
  81.    // 常用于作为 父bean 用于继承，其实也很少用......
  82.    boolean isAbstract();
  84.    int getRole();
  85.    String getDescription();
  86.    String getResourceDescription();
  87.    BeanDefinition getOriginatingBeanDefinition();
  88. }

在Java中，一切皆对象。在JDK中使用java.lang.Class来描述类这个对象。

在Spring中，存在bean这样一个概念，那Spring又是怎么抽象bean这个概念，用什么类来描述bean这个对象呢？Spring使用BeanDefinition来描述bean。

BeanDefinition有很多子类例如:

我们继续往下看

  1. public AnnotationConfigApplicationContext() {
  2.     /**
  3.      * 创建一个读取注解的Bean定义读取器
  4.      */
  5.     this.reader = new AnnotatedBeanDefinitionReader(this);
  8.     //可以用来扫描包或者类，继而转换成BeanDefinition
  9.     //但是实际上我们扫描包工作不是scanner这个对象来完成的而是
  10.     //spring自己new的一个ClassPathBeanDefinitionScanner
  11.     //这里的scanner仅仅是为了程序员能够在外部调用AnnotationConfigApplicationContext对象的scan方法
  12.     this.scanner = new ClassPathBeanDefinitionScanner(this);
  13. }

上面代码首先在AnnotationConfigApplicationContext构造方法中实例化了一个读取器和扫描器;重点看上面的注释;

紧接着看下AnnotatedBeanDefinitionReader(this);里面做了什么事情

  1. org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment)
  3. org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source)
  5. public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
  6.             BeanDefinitionRegistry registry, @Nullable Object source) {
  8.         DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
  9.         if (beanFactory != null) {
  10.             if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
  11.                 //AnnotationAwareOrderComparator主要能解析@Order注解和@Priority
  12.                 beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
  13.             }
  14.             if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
  15.                 //ContextAnnotationAutowireCandidateResolver提供处理延迟加载的功能
  16.                 beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
  17.             }
  18.         }
  20.         Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
  21.         //BeanDefinitio的注册，这里很重要，需要理解注册每个bean的类型
  22.         if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  23.             //需要注意的是ConfigurationClassPostProcessor的类型是BeanDefinitionRegistryPostProcessor
  24.             //而 BeanDefinitionRegistryPostProcessor 最终实现BeanFactoryPostProcessor这个接口
  25.             RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
  26.             def.setSource(source)
  27.             beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
  28.         }
  30.         if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  31.             //AutowiredAnnotationBeanPostProcessor 实现了 MergedBeanDefinitionPostProcessor
  32.             //MergedBeanDefinitionPostProcessor 最终实现了 BeanPostProcessor
  33.             RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
  34.             def.setSource(source);
  35.             beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
  36.         }
  38.         if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  39.             RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
  40.             def.setSource(source);
  41.             beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
  42.         }
  44.   //省略
  45. ........
  47.         return beanDefs;
  48.     }

上面代码主要做了以下几件事:

拿到上面在父类构造方法中实例化的一个工厂DefaultListableBeanFactory

向DefaultListableBeanFactory工厂中添加AnnotationAwareOrderComparator主要解析@Order注解和@Priority处理优先级;

向DefaultListableBeanFactory工厂中添加ContextAnnotationAutowireCandidateResolver提供处理延迟加载的功能

注册spring内部自己定义的bean;并放入到beanDefinitionMap和beanDefinitionNames中,这里着重看一下

org.springframework.context.annotation.internalConfigurationAnnotationProcessor=ConfigurationClassPostProcessor这里有个印象后面会再次说到;

例如:

这个方法到这里就结束了,这就是 AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();所做的事情;

register()方法介绍

我们接着看下面applicationContext.register(AppConfig.class);

  1. public void register(Class<?>... annotatedClasses) {
  2.         for (Class<?> annotatedClass : annotatedClasses) {
  3.             registerBean(annotatedClass);
  4.         }
  5.     }
  6. public void registerBean(Class<?> annotatedClass) {
  7.         doRegisterBean(annotatedClass, null, null, null);
  8.     }
  1. ```

void doRegisterBean(Class annotatedClass, @Nullable Supplier instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer… definitionCustomizers) {
/**

  1.      * 根据指定的bean创建一个BeanDefinition的子类AnnotatedGenericBeanDefinition
  2.      * 这个AnnotatedGenericBeanDefinition可以理解为一个数据结构
  3.      * AnnotatedGenericBeanDefinition包含了类的其他信息,比如一些元信息
  4.      * scope，lazy等等
  5.      *
  6.      */
  8.     AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
  9.     /**
  10.      * 判断这个类是否需要跳过解析
  11.      * 通过代码可以知道spring判断是否跳过解析，主要判断类有没有加注解
  12.      */
  13.     if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
  14.         return;
  15.     }
  17.     abd.setInstanceSupplier(instanceSupplier);
  18.     /**
  19.      * 得到类的作用域
  20.      */
  21.     ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
  22.     /**
  23.      * 把类的作用域添加到数据结构结构中
  24.      */
  25.     abd.setScope(scopeMetadata.getScopeName());
  26.     /**
  27.      * 生成类的名字通过beanNameGenerator
  28.      */
  29.     String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
  30.     /**
  31.      * 处理类当中的通用注解
  32.      * 分析源码可以知道他主要处理
  33.      * Lazy DependsOn Primary Role等等注解
  34.      * 处理完成之后processCommonDefinitionAnnotations中依然是把他添加到数据结构当中
  35.      *
  36.      */
  37.     AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
  39.     /**
  40.      * 如果传参中带了这些注解类就会为true, 否则qualifiers一直为空
  41.      * 因为这里传如的是null(doRegisterBean(annotatedClass, null, null, null);)
  42.      */
  43.     if (qualifiers != null) {
  44.         for (Class<? extends Annotation> qualifier : qualifiers) {
  45.             ////如果配置了@Primary注解，如果加了则作为首选
  46.             if (Primary.class == qualifier) {
  47.                 abd.setPrimary(true);
  48.             }
  49.             //懒加载
  50.             else if (Lazy.class == qualifier) {
  51.                 abd.setLazyInit(true);
  52.             }
  53.             else {
  54.                 //如果使用了除@Primary和@Lazy以外的其他注解，则为该Bean添加一个根据名字自动装配的限定符
  55.                 //这里难以理解，后面会详细介绍
  56.                 abd.addQualifier(new AutowireCandidateQualifier(qualifier));
  57.             }
  58.         }
  59.     }
  60.   //这里也为null
  61.     for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
  62.         customizer.customize(abd);
  63.     }
  65.     /**
  66.      * 这个BeanDefinitionHolder也是一个数据结构
  67.      */
  68.     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
  70.     /**
  71.      * ScopedProxyMode 跳过
  72.      */
  73.     definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  75.     /**
  76.      * 把上述的这个数据结构注册给registry
  77.      * registry就是AnnotationConfigApplicationContext
  78.      * AnnotationConfigApplicationContext在初始化的時候通過調用父類的構造方法
  79.      * 实例化了一个DefaultListableBeanFactory
  80.      * registerBeanDefinition里面就是把definitionHolder这个数据结构包含的信息注册到
  81.      * DefaultListableBeanFactory这个工厂
  82.      */
  83.     BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
  84. }
  85. ```

总结一下这个方法所做的事情:

根据指定的bean创建一个BeanDefinition的子类AnnotatedGenericBeanDefinition

得到当前类的作用域,当前传入的是AppConfig.class(默认是singleton);把类的作用域添加到AnnotatedGenericBeanDefinition中

生成bean的名字并放入BeanDefinitionHolder中

处理当前类使用的通用注解,详细看代码上的注释

实例化一个BeanDefinitionHolder,相当于一个中间媒介;来存放BeanDefinition和beanName然后注册给registry，这里的registry就是AnnotationConfigApplicationContext，在AnnotationConfigApplicationContext的父类中实例化了一个DefaultListableBeanFactory;DefaultListableBeanFactory 中有个Map集合
private final Map bdMap = new ConcurrentHashMap<>(256);
就是在这个方法中将AppConfig.class放入到beanDefinitionMap 中的；那现在beanDefinitionMap 的size大小就是7个;到
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);方法中看下；最终走了
org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition方法中的

  1. else {
  2.   // Still in startup registration phase
  3.   this.beanDefinitionMap.put(beanName, beanDefinition);
  4.   this.beanDefinitionNames.add(beanName);
  5.   this.manualSingletonNames.remove(beanName);
  6.  }

applicationContext.register(AppConfig.class);方法到这里也就结束了；

下面我们进入今天的重要部分：

refresh()方法

  1. org.springframework.context.support.AbstractApplicationContext#refresh
  3. @Override
  4. public void refresh() throws BeansException, IllegalStateException {
  5.     synchronized (this.startupShutdownMonitor) {
  6.         // Prepare this context for refreshing.
  7.         //准备工作包括设置启动时间，是否激活标识位，
  8.         // 初始化属性源(property source)配置
  9.         prepareRefresh();
  11.         // Tell the subclass to refresh the internal bean factory.
  12.         //返回一个factory 为什么需要返回一个工厂
  13.         //因为要对工厂进行初始化 
  14.            /** 这里说明一下：如果你使用是的xml配置的方式就会执行                  AbstractRefreshableApplicationContext的refreshBeanFactory方法去加载xml配置信息；因为ClassPathXmlApplicationContext是它的子类；现在我们使用的是注解配置的方式所以会执行GenericApplicationContext的refreshBeanFactory方法，这个方法就是只返回了一个beanFactory**/
  15.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  17.         // Prepare the bean factory for use in this context.
  18.         //准备工厂
  19.         prepareBeanFactory(beanFactory);
  21.         try {
  22.             // Allows post-processing of the bean factory in context subclasses.
  24.             //这个方法在当前版本的spring是没用任何代码的
  25.             //可能spring期待在后面的版本中去扩展吧
  26.             postProcessBeanFactory(beanFactory);
  28.             // Invoke factory processors registered as beans in the context.
  29.             //在spring的环境中去执行已经被注册的 factory processors
  30.             //设置执行自定义的ProcessBeanFactory 和spring内部自己定义的
  31.             invokeBeanFactoryPostProcessors(beanFactory);
  33.             // Register bean processors that intercept bean creation.
  34.             //注册beanPostProcessor
  35.             registerBeanPostProcessors(beanFactory);
  37.             // Initialize message source for this context.
  38.             // 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了
  39.             initMessageSource();
  41.             // Initialize event multicaster for this context.
  42.             //初始化应用事件广播器
  43.             initApplicationEventMulticaster();
  45.             // Initialize other special beans in specific context subclasses.
  46.             // 从方法名就可以知道，典型的模板方法(钩子方法)，
  47.             // 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
  48.             onRefresh();
  50.             // Check for listener beans and register them.
  51.             // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
  52.             registerListeners();
  54.             // Instantiate all remaining (non-lazy-init) singletons.
  55.             // 重点，重点，重点
  56.             // 初始化所有的 singleton beans
  57.             //（lazy-init 的除外）
  58.             finishBeanFactoryInitialization(beanFactory);
  60.             // Last step: publish corresponding event.
  61.             // 最后，广播事件，ApplicationContext 初始化完成
  62.             finishRefresh();
  63.         }
  64.            //.......

像prepareRefresh();,obtainFreshBeanFactory();都没有什么好说的看上面的注释就可以，这里我们简单介绍一下prepareBeanFactory(beanFactory);方法；

prepareBeanFactory()

  1. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  2.         // 设置 BeanFactory 的类加载器，我们知道 BeanFactory 需要加载类，也就需要类加载器，
  3.       // 这里设置为加载当前 ApplicationContext 类的类加载器
  4.     beanFactory.setBeanClassLoader(getClassLoader());
  5.     //bean表达式解释器, 为了能够让我们的beanFactory去解析bean表达式
  6.     beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  7.     //对象与string类型的转换   <property red="dao">
  8.        //想深入了解参考 https://blog.csdn.net/pentiumchen/article/details/44026575
  9.     beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
  11.     //添加一个后置管理器ApplicationContextAwareProcessor
  12.     // 能够在bean中获得到各种*Aware（*Aware都有其作用）
  13.        // 这个我们很常用，如我们会为了获取 ApplicationContext 而 implement ApplicationContextAware
  14.     beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  15.     // 下面几行的意思就是，如果某个 bean 依赖于以下几个接口的实现类，在自动装配的时候忽略它们，
  16.           // Spring 会通过其他方式来处理这些依赖。
  17.     beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  18.     beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  19.     beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  20.     beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  21.     beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  22.     beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
  24.     // 下面几行就是为特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值，
  25.        //MessageSource 被注册成为了一个普通的 bean
  26.     beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  27.     beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  28.     beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  29.     beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  31. // 这个 BeanPostProcessor 也很简单，在 bean 实例化后，如果是 ApplicationListener 的子类，
  32.    // 那么将其添加到 listener 列表中，可以理解成：注册 事件监听器
  33.     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
  35.     // 这里涉及到特殊的 bean，名为：loadTimeWeaver，这不是我们的重点，忽略它
  36.     if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  37.         beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  38.         // Set a temporary ClassLoader for type matching.
  39.         beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  40.     }
  42.     //意思是如果自定义的Bean中没有名为"systemProperties"和"systemEnvironment"的Bean，
  43.     // 则注册两个Bena，Key为"systemProperties"和"systemEnvironment"，Value为Map，
  44.     // 这两个Bean就是一些系统配置和系统环境信息
  45.     // Register default environment beans.
  46.     if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  47.         beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  48.     }
  49.     if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  50.         beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  51.     }
  52.     if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  53.         beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  54.     }
  55. }

上面prepareBeanFactory方法只是给beanFactory增加一些特殊的东西例如:表达式解析器,后置处理器,忽略一些特定的类;至此beanFactory中的beanDefinitionMap 的size大小依然还是7个;

postProcessBeanFactory(beanFactory);是一个空方法；

下面重点介绍一下invokeBeanFactoryPostProcessors(beanFactory);

invokeBeanFactoryPostProcessors()

  1. protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  2.         //这里的getBeanFactoryPostProcessors()是获取手动给spring的BeanFactoryPostProcessors()
  3.         //何为手动给spring --> 手动调用AnnotationConfigApplicationContext.addBeanFactoryPostProcessor();
  4.         //所以说自定义的BeanFactoryPostProcessors并非只有implements BeanFactoryPostProcessors才叫自定义
  5.         //我们并没有手动去调用所以getBeanFactoryPostProcessors()的size = 0
  7.         //这里问: 那如果我们自己去implements BeanFactoryPostProcessors 那getBeanFactoryPostProcessors()的size还会不会是0?
  8.         //回答:  还是0! 因为我们自己implements BeanFactoryPostProcessors必须要加@Component,但是直到现在为止spring并没有开始扫描@Component
  9.         //所以还是0
  10.         PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
  12.         // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
  13.         // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
  14.         if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
  15.             beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
  16.             beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  17.         }
  18.     }

进入invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());方法

下面的信息量比较大,我们先看一下下面代码中需要的类图,先熟悉一下,有助于理解;

  1. public static void invokeBeanFactoryPostProcessors(
  2.         //List<BeanFactoryPostProcessor> beanFactoryPostProcessors 这个是我们手动传过来的
  3.         ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  5.     // Invoke BeanDefinitionRegistryPostProcessors first, if any.
  6.     Set<String> processedBeans = new HashSet<>();
  7.     //这里肯定是会进的,当前的beanFactory 一直都是 DefaultListableBeanFactory,而DefaultListableBeanFactory是BeanDefinitionRegistry的子类
  8.     if (beanFactory instanceof BeanDefinitionRegistry) {
  9.         BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  10.         //BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor
  11.         //BeanDefinitionRegistryPostProcessor功能比BeanFactoryPostProcessor更强大
  12.         //我们自己要是想扩展有两种方式;1:实现BeanFactoryPostProcessor,2,BeanDefinitionRegistryPostProcessor,所以定义了两个来存放,
  13.         //这里之所以实例化两个list的目的是:进行区分,spring对这两个有不同的处理方式
  15.         List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
  16.         List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();
  17.         //这里是size=0;上面的代码注释中解释过
  18.         for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
  19.             if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
  20.                 BeanDefinitionRegistryPostProcessor registryProcessor =
  21.                         (BeanDefinitionRegistryPostProcessor) postProcessor;
  22.          //如我们自己implements BeanDefinitionRegistryPostProcessor并且没有加@Component而是我们自己手动添加的ApplicationContext.addBeanFactoryPostProcessor(new TestBeanDefinitionRegistryPostProcessor());那么在下面这句话就会执行重写的方法;
  23.                 registryProcessor.postProcessBeanDefinitionRegistry(registry);
  24.                 registryProcessors.add(registryProcessor);
  25.             } else {
  26.                 regularPostProcessors.add(postProcessor);
  27.             }
  28.         }
  29.         //这里又定义了一个,和上面的区别是,这个currentRegistryProcessors 放的是spring内部自己实现了BeanDefinitionRegistryPostProcessor接口的对象
  30.         List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
  31.         //BeanDefinitionRegistryPostProcessor 等于 BeanFactoryPostProcessor
  32.         //getBeanNamesForType  根据bean的类型获取bean的名字 ConfigurationClassPostProcessor
  33.         //这里的getBeanNamesForType代码就不展开了大致说下 就是拿到beanDefinitionNames中的7个值去对和BeanDefinitionRegistryPostProcessor对比看是否是他的子类
  34.         //这里7个中只有一个ConfigurationClassPostProcessor是它的子类,所以值取到了一个ConfigurationClassPostProcessor
  35.         String[] postProcessorNames =
  36.                 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  37.      //ConfigurationClassPostProcessor我们在最开始介绍注册spring内部自己定义的bean时,向beanDefinitionMap添加了6个(AppConfig.calss之外)中,其中一个就是它;
  38.      //这里解释一下为什么要在最开始注册这个呢？因为spring的工厂需要去解析,扫描等等功能    
  39.         //而这些功能都是需要在spring工厂初始化完成之前执行
  40.         //要么在工厂最开始的时候、要么在工厂初始化之中，反正不能再之后
  41.         //因为如果在之后就没有意义，因为那个时候已经需要使用工厂了
  42.     //所以这里Spring在一开始就注册了一个BeanFactoryPostProcessor，用来插手SpringFactory的实例化过程
  43.      //而这个类叫做ConfigurationClassPostProcessor
  44.         for (String ppName : postProcessorNames) {
  45.             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  46.                 //添加到集合currentRegistryProcessors中
  47.                 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  48.                 //添加到processedBeans的Set集合中
  49.                 processedBeans.add(ppName);
  50.             }
  51.         }
  52.         //排序不重要，况且currentRegistryProcessors这里也只有一个数据
  53.         sortPostProcessors(currentRegistryProcessors, beanFactory);
  54.         //合并list，不重要(为什么要合并，因为有我们自定义个还有spring自己内部实现的)
  55.         registryProcessors.addAll(currentRegistryProcessors);
  57.         /**
  58.          * //最重要。注意这里是方法调用
  59.          * //调用这个方法
  60.          * //循环所有的BeanDefinitionRegistryPostProcessor
  61.          *     //该方法内部postProcessor.postProcessBeanDefinitionRegistry
  62.          */
  63.         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
  64.         //这个list只是一个临时变量，故而要清除
  65.         currentRegistryProcessors.clear();
  66.      // 下面的代码先不看,等invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);执行完之后我们回头再看....
  67.    }

这里就不总结了,看上面的代码注释就很清楚了,下面

  1. invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

是重点,我们进去看看做了什么事?

  1. private static void invokeBeanDefinitionRegistryPostProcessors(
  2.             Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
  4.         //只有一条数据
  5.         for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
  6.             postProcessor.postProcessBeanDefinitionRegistry(registry);
  7.         }
  8.     }

然后执行了

  1. org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry

之后执行了

  1. org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions

我们着重看下这个方法!

  1. public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
  2.         //定义一个list 存放 applicationContext 提供的bd
  3.         List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
  4.         //获取容器中注册的所有bd名字 这里会有7个
  5.         String[] candidateNames = registry.getBeanDefinitionNames();
  7.         /**
  8.          * Full : 加了Configuration注解的类会被Sping标记为Full
  9.          * Lite : 其他注解标记为Lite
  10.          */
  11.         //遍历beanName  拿出的所有bd(BeanDefinition)，然后判断bd时候包含了@Configuration、@Import，@Compent。。。注解
  12.         //这里循环7,但是有个6个我们都不需要看,我们只看AppConfig
  13.         for (String beanName : candidateNames) {
  14.             //根据bean名称得到具体的BeanDefinition
  15.             BeanDefinition beanDef = registry.getBeanDefinition(beanName);
  16.             //检查是否被处理过
  17.             //如果BeanDefinition中的configurationClass属性为full或者lite,则意味着已经处理过了,直接跳过
  18.             //进去下面checkConfigurationClassCandidate方法就会明白这句话的意思
  19.             if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
  20.                     ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
  21.                 if (logger.isDebugEnabled()) {
  22.                     logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
  23.                 }
  24.             }
  25.             //判断是否是Configuration类，如果加了Configuration注解下面的这几个注解就不再判断了
  26.             /**
  27.              *        candidateIndicators.add(Component.class.getName());
  28.              *         candidateIndicators.add(ComponentScan.class.getName());
  29.              *         candidateIndicators.add(Import.class.getName());
  30.              *         candidateIndicators.add(ImportResource.class.getName());
  31.              */
  32.             else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
  33.                 //BeanDefinitionHolder 也可以看成一个数据结构,将BeanDefinitionHolder添加到上面实例化的一个configCandidates集合中;
  34.                 configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
  35.             }
  36.         }
  38.         // Return immediately if no @Configuration classes were found
  39.         if (configCandidates.isEmpty()) {
  40.             return;
  41.         }
  43.         //  排序，根据order,不重要
  44.         configCandidates.sort((bd1, bd2) -> {
  45.             int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
  46.             int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
  47.             return Integer.compare(i1, i2);
  48.         });
  50.         //如果BeanDefinitionRegistry是SingletonBeanRegistry子类的话,
  51.         // 由于我们当前传入的是DefaultListableBeanFactory,是SingletonBeanRegistry 的子类
  52.         // 因此会将registry强转为SingletonBeanRegistry
  53.         SingletonBeanRegistry sbr = null;
  54.         if (registry instanceof SingletonBeanRegistry) {
  55.             sbr = (SingletonBeanRegistry) registry;
  56.             if (!this.localBeanNameGeneratorSet) {
  57.                 BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
  58.                 if (generator != null) {
  59.                     this.componentScanBeanNameGenerator = generator;
  60.                     this.importBeanNameGenerator = generator;
  61.                 }
  62.             }
  63.         }
  65.         if (this.environment == null) {
  66.             this.environment = new StandardEnvironment();
  67.         }
  69.         // 实例化ConfigurationClassParser 为了解析各个配置类
  70.         ConfigurationClassParser parser = new ConfigurationClassParser(
  71.                 this.metadataReaderFactory, this.problemReporter, this.environment,
  72.                 this.resourceLoader, this.componentScanBeanNameGenerator, registry);
  74.         //实例化2个set,candidates用于将之前加入的configCandidates进行去重
  75.         //因为可能有多个配置类重复了
  76.         //alreadyParsed用于判断是否处理过
  77.         Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
  78.         Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
  79.         do {
  80.             //扫描包,将去重后的candidates集合传入;里面只有一个appConfig
  81.             parser.parse(candidates);
  82.             parser.validate();
  84.             Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
  85.             configClasses.removeAll(alreadyParsed);
  87.             // Read the model and create bean definitions based on its content
  88.             if (this.reader == null) {
  89.                 this.reader = new ConfigurationClassBeanDefinitionReader(
  90.                         registry, this.sourceExtractor, this.resourceLoader, this.environment,
  91.                         this.importBeanNameGenerator, parser.getImportRegistry());
  92.             }
  93.             /**
  94.              *
  95.              *      这里值得注意的是扫描出来的bean当中可能包含了特殊类
  96.              *     比如ImportBeanDefinitionRegistrar那么也在这个方法里面处理
  97.              *     但是并不是包含在configClasses当中
  98.              *      configClasses当中主要包含的是importSelector
  99.              *      因为ImportBeanDefinitionRegistrar在扫描出来的时候已经被添加到一个list当中去了
  100.              *
  101.              */
  102.             //bd 到 map
  103.             this.reader.loadBeanDefinitions(configClasses);
  104.             alreadyParsed.addAll(configClasses);
  106.             candidates.clear();
  107.             if (registry.getBeanDefinitionCount() > candidateNames.length) {
  108.                 String[] newCandidateNames = registry.getBeanDefinitionNames();
  109.                 Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
  110.                 Set<String> alreadyParsedClasses = new HashSet<>();
  111.                 for (ConfigurationClass configurationClass : alreadyParsed) {
  112.                     alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
  113.                 }
  114.                 for (String candidateName : newCandidateNames) {
  115.                     if (!oldCandidateNames.contains(candidateName)) {
  116.                         BeanDefinition bd = registry.getBeanDefinition(candidateName);
  117.                         if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
  118.                                 !alreadyParsedClasses.contains(bd.getBeanClassName())) {
  119.                             candidates.add(new BeanDefinitionHolder(bd, candidateName));
  120.                         }
  121.                     }
  122.                 }
  123.                 candidateNames = newCandidateNames;
  124.             }
  125.         }
  126.         while (!candidates.isEmpty());
  128.         // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
  129.         if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
  130.             sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
  131.         }
  133.         if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
  134.             // Clear cache in externally provided MetadataReaderFactory; this is a no-op
  135.             // for a shared cache since it'll be cleared by the ApplicationContext.
  136.             ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
  137.         }
  138.     }

这个方法有点长,而且很重要,需要慢慢看;在这个方法中我们只需要针对AppConfig这个类看就可以了其他6个可以跳过;

我们先进入一下checkConfigurationClassCandidate方法,看看是怎么检查注解又怎么标识Full和Lite的;

  1. public static boolean checkConfigurationClassCandidate(BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
  2.         String className = beanDef.getBeanClassName();
  3.         if (className == null || beanDef.getFactoryMethodName() != null) {
  4.             return false;
  5.         }
  7.         AnnotationMetadata metadata;
  8.         //......由于篇幅原因,省略一些代码,用一句话来说明一下;这个metadata是怎么来的
  9.       /**
  10.       1,如果BeanDefinition 是 AnnotatedBeanDefinition的实例,并且className 和 BeanDefinition中的元            数据的类名相同,则直接从BeanDefinition 获得Metadata
  11.         2,如果BeanDefinition 是 AbstractBeanDefinition的实例,并且beanDef 有 beanClass 属性存在
  12.             则实例化StandardAnnotationMetadata    
  13.       **/
  16.         //判断当前这个bd中存在的类是不是加了@Configruation注解
  17.         //如果存在则spring认为他是一个全注解的类
  18.         if (isFullConfigurationCandidate(metadata)) {
  19.             //如果存在Configuration 注解,则为BeanDefinition 设置configurationClass属性为full
  20.             beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
  21.         }
  22.         //判断是否加了以下注解，摘录isLiteConfigurationCandidate的源码
  23.         //     candidateIndicators.add(Component.class.getName());
  24.         //        candidateIndicators.add(ComponentScan.class.getName());
  25.         //        candidateIndicators.add(Import.class.getName());
  26.         //        candidateIndicators.add(ImportResource.class.getName());
  27.         //如果不存在Configuration注解，spring则认为是一个部分注解类
  28.         else if (isLiteConfigurationCandidate(metadata)) {
  29.             beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
  30.         }
  31.         else {
  32.             return false;
  33.         }
  35.         // It's a full or lite configuration candidate... Let's determine the order value, if any.
  36.         Integer order = getOrder(metadata);
  37.         if (order != null) {
  38.             beanDef.setAttribute(ORDER_ATTRIBUTE, order);
  39.         }
  41.         return true;
  42.     }

isFullConfigurationCandidate();

  1.     public static boolean isFullConfigurationCandidate(AnnotationMetadata metadata) {
  2. return metadata.isAnnotated(Configuration.class.getName());
  3.  }

isLiteConfigurationCandidate();

  1. static {
  2.     candidateIndicators.add(Component.class.getName());
  3.     candidateIndicators.add(ComponentScan.class.getName());
  4.     candidateIndicators.add(Import.class.getName());
  5.     candidateIndicators.add(ImportResource.class.getName());
  6. }

下面我们重点分析parse方法

  1. public void parse(Set<BeanDefinitionHolder> configCandidates) {
  2.         this.deferredImportSelectors = new LinkedList<>();
  3.         //根据BeanDefinition 的类型 做不同的处理,一般都会调用ConfigurationClassParser#parse 进行解析
  4.         //遍历configCandidates中的BeanDefinitionHolder取出BeanDefinition
  5.         //BeanDefinition中包含了AppConfig的一些属性信息
  6.         for (BeanDefinitionHolder holder : configCandidates) {
  7.             BeanDefinition bd = holder.getBeanDefinition();
  8.             try {
  9.                 //当前bd类型就是AnnotatedBeanDefinition --> true
  10.                 if (bd instanceof AnnotatedBeanDefinition) {
  11.                     //解析注解对象，并且把解析出来的bd放到map，但是这里的bd指的是普通的
  12.                     //何谓不普通的呢？比如@Bean 和各种beanFactoryPostProcessor得到的bean不在这里put
  13.                     //但是这里解析，只是put而已
  14.                     //Metadata中主要包含的是解析出来的注解,当前AppConfig 解析出来的注解是@Configuration,@ComponentScan
  15.                     //注解何时被解析出来的呢? 就是一开始将AppConfig 加载到BeanDefinitionMap中时;
  16.                     parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
  17.                 }
  18.                 else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
  19.                     parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
  20.                 }
  21.                 else {
  22.                     parse(bd.getBeanClassName(), holder.getBeanName());
  23.                 }
  24.             }
  25.             catch (BeanDefinitionStoreException ex) {
  26.                 throw ex;
  27.             }
  28.             catch (Throwable ex) {
  29.                 throw new BeanDefinitionStoreException(
  30.                         "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
  31.             }
  32.         }
  33.         //处理延迟加载的importSelect
  34.         processDeferredImportSelectors();
  35.     }

然后进入真正的解析方法:

  1. org.springframework.context.annotation.ConfigurationClassParser#parse(AnnotationMetadata, String)

在这个方法中又调用了:

  1. org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass方法;
  1. protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
  2.         if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
  3.             return;
  4.         }
  5.         // 处理Imported 的情况
  6.         //就是当前这个注解类有没有被别的类import
  7.         ConfigurationClass existingClass = this.configurationClasses.get(configClass);
  8.         if (existingClass != null) {
  9.             if (configClass.isImported()) {
  10.                 if (existingClass.isImported()) {
  11.                     existingClass.mergeImportedBy(configClass);
  12.                 }
  13.                 // Otherwise ignore new imported config class; existing non-imported class overrides it.
  14.                 return;
  15.             }
  16.             else {
  17.                 // Explicit bean definition found, probably replacing an imports.
  18.                 // Let's remove the old one and go with the new one.
  19.                 this.configurationClasses.remove(configClass);
  20.                 this.knownSuperclasses.values().removeIf(configClass::equals);
  21.             }
  22.         }
  24.         // 递归地处理配置类及其超类层次结构。
  25.         SourceClass sourceClass = asSourceClass(configClass);
  26.         do {
  27.       //解析注解并扫描
  28.             sourceClass = doProcessConfigurationClass(configClass, sourceClass);
  29.         }
  30.         while (sourceClass != null);
  31.         //一个map，用来存放扫描出来的bean（注意这里的bean不是对象，仅仅bean的信息，因为还没到实例化这一步）
  32.         this.configurationClasses.put(configClass, configClass);
  33.     }

然后进入doProcessConfigurationClass()方法,下面不重要的代码我就不贴了;

  1. protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
  2.             throws IOException {
  4.         //处理内部类 一般不会写内部类
  5.         processMemberClasses(configClass, sourceClass);
  7.         // 处理@PropertySource注释
  8.         for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
  9.                 sourceClass.getMetadata(), PropertySources.class,
  10.                 org.springframework.context.annotation.PropertySource.class)) {
  11.             if (this.environment instanceof ConfigurableEnvironment) {
  12.                 processPropertySource(propertySource);
  13.             }
  14.             else {
  15.                 logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
  16.                         "]. Reason: Environment must implement ConfigurableEnvironment");
  17.             }
  18.         }
  20.         // 处理@ComponentScan注释
  21.         Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
  22.                 sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
  23.         if (!componentScans.isEmpty() &&
  24.                 !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
  25.             for (AnnotationAttributes componentScan : componentScans) {
  26.                 // The config class is annotated with @ComponentScan -> perform the scan immediately
  27.                 //解析扫描的一些基本信息，比如是否过滤，比如是否加入新的包。。。。。includeFilters,excludeFilters等等都是ComponentScan中的属性
  28.                 //扫描普通类-->componentScan ---> com.haoxy
  29.                 //这里扫描出来所有@Component
  30.                 //并且把扫描的出来的普通bean放到map当中
  31.                 Set<BeanDefinitionHolder> scannedBeanDefinitions =
  32.                         this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
  33.                 // Check the set of scanned definitions for any further config classes and parse recursively if needed
  34.                 for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
  35.                     BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
  36.                     if (bdCand == null) {
  37.                         bdCand = holder.getBeanDefinition();
  38.                     }
  39.                     //检查扫描出来的类当中是否还有@Configuration
  40.                     if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
  41.                         parse(bdCand.getBeanClassName(), holder.getBeanName());
  42.                     }
  43.                 }
  44.             }
  45.         }
  47.         //下面是处理@Import  imports 3种情况
  48.         //ImportSelector
  49.         //普通类
  50.         //ImportBeanDefinitionRegistrar
  51.         //这里和内部地柜调用时候的情况不同
  52.         /**
  53.          * 这里处理的import是需要判断我们的类当中时候有@Import注解
  54.          * 如果有这把@Import当中的值拿出来，是一个类
  55.          * 比如@Import(xxxxx.class)，那么这里便把xxxxx传进去进行解析
  56.          * 在解析的过程中如果发觉是一个importSelector那么就回调selector的方法
  57.          * 返回一个字符串（类名），通过这个字符串得到一个类
  58.          * 继而在递归调用本方法来处理这个类
  59.          *
  60.          * 判断一组类是不是imports（3种import）
  61.          *
  62.          *代码就不贴了,不是咱们这次研究的重点
  63.          */
  64.         processImports(configClass, sourceClass, getImports(sourceClass), true);
  65.   //..........
  66. }

上面的代码就是扫描普通类—-@Component,包括@Component子类： @Repository @Controller @service;并且放到了BeanDefinitionMap当中;

进入

org.springframework.context.annotation.ComponentScanAnnotationParser#parse
方法;这里就是处理ComponentScan注解中的一些属性;例如scopedProxy,scopeResolver,includeFilters,excludeFilters,lazyInit,basePackages,basePackageClasses,等…我们直接进入parse方法的org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan方法;这个方法把@ComponentScan中的值传了过去;

  1. protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
  2.         Assert.notEmpty(basePackages, "At least one base package must be specified");
  3.         Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
  4.         //获取到包名
  5.         for (String basePackage : basePackages) {
  6.             //扫描basePackage路径下的java文件
  7.             //符合条件的并把它转成BeanDefinition类型
  8.             Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
  9.             for (BeanDefinition candidate : candidates) {
  10.                 //解析scope属性
  11.                 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
  12.                 candidate.setScope(scopeMetadata.getScopeName());
  13.                 //生成bean名称
  14.                 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
  15.                 if (candidate instanceof AbstractBeanDefinition) {
  16.                     //如果这个类是AbstractBeanDefinition的子类
  17.                     //则为他设置默认值，比如lazy，init destory
  18.                     postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
  19.                 }
  20.                 if (candidate instanceof AnnotatedBeanDefinition) {
  21.                     //检查并且处理常用的注解
  22.                     //这里的处理主要是指把常用注解的值设置到AnnotatedBeanDefinition当中
  23.                     //当前前提是这个类必须是AnnotatedBeanDefinition类型的，说白了就是加了注解的类
  24.                     AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
  25.                 }
  26.                 if (checkCandidate(beanName, candidate)) {
  27.                     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
  28.                     definitionHolder =
  29.                             AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  30.                     beanDefinitions.add(definitionHolder);
  31.                     //根据包名扫描到的类加载到beanDefinition map 中
  32.                     registerBeanDefinition(definitionHolder, this.registry);
  33.                 }
  34.             }
  35.         }
  36.         return beanDefinitions;
  37.     }

扫描候选组件的类路径方法:
org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents

  1. public Set<BeanDefinition> findCandidateComponents(String basePackage) {
  2.    if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
  3.       //根据索引获得bean定义，配合spring-context-indexer使用,有兴趣得自己去了解一下，这里不做具体得解析
  4.       return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
  5.    }
  6.    else {
  7.       //扫描获得bean定义
  8.       return scanCandidateComponents(basePackage);
  9.    }
  10. }
  1. private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
  2.             Set<BeanDefinition> candidates = new LinkedHashSet<>();
  3.             try {
  4.                 //classpath*:cn/haoxy/**/*.class  ant path模式串
  5.                 String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
  6.                         resolveBasePackage(basePackage) + '/' + this.resourcePattern;
  7.                 //这里resources有四个;分别是 TestBean.class,AppConfig.class,IndexDao.class,IndexDaoImpl.class
  8.                 Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
  9.                 boolean traceEnabled = logger.isTraceEnabled();
  10.                 boolean debugEnabled = logger.isDebugEnabled();
  11.                 //遍历resources;
  12.                 for (Resource resource : resources) {
  13.                     if (traceEnabled) {
  14.                         logger.trace("Scanning " + resource);
  15.                     }
  16.                     if (resource.isReadable()) {
  17.                         try {
  18.                             MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
  19.                        //判断是否是我们需要的资源
  20.                       /**
  21.                       * 通过isCandidateComponent(MetadataReader metadataReader)来根据excludeFilters和includeFilters判断是否可以进行下一步的操作，
  22.                       * 如果这个资源被排除的filter匹配上，就返回false，代表不是我们所需要的。
  23.                       * 如果被包含的filter匹配上，并且他还要通过条件判断isConditionMatch的话，返回true，代表是我们需要的资源，可以进行下一步的操作。
  24.                       * 这里我们插一句Spring有默认的includ类型的filter实现，如果上层传入的话，就是用上层传入的，否则就使用默认的，
  25.                       * 默认的是扫描@Component注解以及他的子类@Repository @Controller @service
  26.                       */
  27.                         //显然这里只会匹配一个IndexDaoImpl.class
  28.                             if (isCandidateComponent(metadataReader)) {
  29.                                 ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
  30.                                 sbd.setResource(resource);
  31.                                 sbd.setSource(resource);
  32.                                 if (isCandidateComponent(sbd)) {
  33.                                     if (debugEnabled) {
  34.                                         logger.debug("Identified candidate component class: " + resource);
  35.                                     }
  36.                                     candidates.add(sbd);
  37.                                 }
  38.                             //........省
  40.             }
  41.             catch (IOException ex) {
  42.                 throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
  43.             }
  44.             return candidates;
  45.         }

这里只会有一个IndexDaoImpl符合我们的要求,放到candidates集合中并返回到doScan方法中;然后解析此类的作用域scope,生成bean名称等,然后调用registerBeanDefinition(definitionHolder, this.registry);方法把它加入到beanDefinitionMap集合中;

下面我们看看registerBeanDefinition(definitionHolder, this.registry)方法

从org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition
方法转来转去最后转到了
org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition方法；

  1. public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
  2.             throws BeanDefinitionStoreException {
  4.         Assert.hasText(beanName, "Bean name must not be empty");
  5.         Assert.notNull(beanDefinition, "BeanDefinition must not be null");
  7.         if (beanDefinition instanceof AbstractBeanDefinition) {
  8.             try {
  9.                 ((AbstractBeanDefinition) beanDefinition).validate();
  10.             }
  11.             catch (BeanDefinitionValidationException ex) {
  12.                 throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanNam)....
  13.             }
  14.         }
  15.         //所有的 Bean 注册后会放入这个 beanDefinitionMap 中
  16.         //判断beanDefinitionMap中是否存在当前bean;之所以判断是因为我们可以配置允许bean覆盖
  17.         BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
  18.         //显然这里是不成立的，我们并没有配置允许bean覆盖，existingDefinition中也不会存在我们当前bean
  19.         if (existingDefinition != null) {
  20.             //如果进到这里说明我们允许了bean的覆盖
  21.             if (!isAllowBeanDefinitionOverriding()) {
  22.                 // 如果不允许覆盖的话，抛异常
  23.                 throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName)....
  24.             }
  25.             else if (existingDefinition.getRole() < beanDefinition.getRole()) {
  26.                 //这里的代码都是打印日志 log....
  27.                 //日志内容: 用框架定义的 Bean 覆盖用户自定义的 Bean
  28.                 //.....
  29.             else if (!beanDefinition.equals(existingDefinition)) {
  30.                 //log....
  31.                 //日志内容: 用新的 Bean 覆盖旧的 Bean
  32.             }
  33.             else {
  34.                 //log....
  35.                 //日志内容: 用同等的 Bean 覆盖旧的 Bean，这里指的是 equals 方法返回 true 的 Bean
  36.             }
  37.             //覆盖bean
  38.             this.beanDefinitionMap.put(beanName, beanDefinition);
  39.         }
  40.         else {
  41.             //上面的if不成立就来到了这里;如果是普通bean(IndexDaoImpl等),这里返回是true,
  42.             // 如果是AppConfig等特殊bean,Spring一开始就加载的会走下面的else
  43.             if (hasBeanCreationStarted()) {
  44.                 // Cannot modify startup-time collection elements anymore (for stable iteration)
  45.                 synchronized (this.beanDefinitionMap) {
  46.                     //以beanName为key,beanDefinition为value  put 到 beanDefinitionMap中;
  47.                     //注意，"注册Bean" 这个动作结束，Bean 依然还没有初始化，我们后面会有大篇幅说初始化过程，
  48.                     this.beanDefinitionMap.put(beanName, beanDefinition);
  49.                     List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
  50.                     updatedDefinitions.addAll(this.beanDefinitionNames);
  51.                     updatedDefinitions.add(beanName);
  52.                     //将beanName 添加到 beanDefinitionNames集合中
  53.                     this.beanDefinitionNames = updatedDefinitions;
  54.                     if (this.manualSingletonNames.contains(beanName)) {
  55.                         Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
  56.                         updatedSingletons.remove(beanName);
  57.                         this.manualSingletonNames = updatedSingletons;
  58.                     }
  59.                 }
  60.             }
  61.             //特殊bean
  62.             else {
  63.                 // Still in startup registration phase
  64.                //同样是以beanName为key,beanDefinition为value  put 到 beanDefinitionMap中;
  65.                 this.beanDefinitionMap.put(beanName, beanDefinition);
  66.                 //将beanName 添加到 beanDefinitionNames集合中
  67.                 this.beanDefinitionNames.add(beanName);
  68.                 //这LinkedHashSet存放的是:environment,systemProperties,systemEnvironment
  69.                 //都是一些系统环境，系统属性,这里对我们不重要
  70.                 this.manualSingletonNames.remove(beanName);
  71.             }
  72.             // 这个不重要，在预初始化的时候会用到，不必管它。
  73.             this.frozenBeanDefinitionNames = null;
  74.         }
  76.         if (existingDefinition != null || containsSingleton(beanName)) {
  77.             resetBeanDefinition(beanName);
  78.         }
  79.     }

这时候beanDefinitionMap的size大小就是8个了;然后放到beanDefinitions集合中返回;这里只是把它加入到beanDefinitionMap集合中还没有进行初始化;上面就是@ComponentScan注解作用的扫描BeanDefination的全部过程了。这一篇文章终于结束了，好累，自己总结了一遍印象更深刻一些；

bean的创建及初始化就参考：Spring源码分析：SpringIOC初始化过程源码分析-基于配置文件模式（三）文章的后面部分就可以了！

参考：https://www.haoxiaoyong.cn/2019/12/01/2019/2019-12-01-spring1/

 850

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


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

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