SpringIOC容器加载流程和源码剖析

前言

说道SpringIOC大家想到的都是控制反转，依赖注入。控制反转是将Bean的创建过程由Spring接手，由Spring创建而不需要我们自己来创建。而依赖注入就是实现控制反转的方式。

SpringIOC基本概念

BeanFactory

Spring Bean的创建使用的是工厂模式，简单而言只要实现了BeanFactory接口就有了创建Bean的能力，但在Spring中提供了很多的容器实现，我们配置方式一般使用AnnotationConfigApplicationContext容器，xml方式我们一般可以使用ClassPathXmlApplicationContext容器。那么问题来了，**BeanFactory和ApplicationContext有什么区别？**

ApplicationContext是继承于BeanFactory，所以ApplicationContext有许多BeanFactory没有的能力。在Spring中我们推荐使用ApplicationContext，除了一些资源受限的情况下我们为了更轻会使用BeanFactory。

Feature	BeanFactory	ApplicationContext
Bean Bean实例化/装配	Yes	Yes
集成的生命周期管理	No	Yes
自动注册 BeanPostProcessor	No	Yes
自动注册 BeanFactoryPostProcessor	No	Yes
便利的 MessageSource 访问 (国际化)	No	Yes
内置ApplicationEvent 发布机制	No	Yes

BeanDefinition

BeanDefinition顾名思义叫Bean定义，其实在这个阶段，Bean还没有完全创建，以BeanDefinition来称呼。

Spring会把class解析成Bean定义放在BeanDefinitionMap中.这个时候Bean定义存的是一些源信息，主要是用来给后面的BeanFactory来创建Bean。大概过程是class->BeanDefinition->经过BeanFactory->Bean。

SpringIOC流程源码分析

这里我们以AnnotationConfigApplicationContext进入。主要看怎样加载类成BeanDefinition，然后BeanDefinition生成Bean的过程。

在初始化主要做的事情有以下

1. 初始化BeanFactory
2. 注册一些内置的后置处理器（包括了ConfigurationClassPostProcessor（配置类解析后置处理器））
3. 创建BeanDefinition扫描器（这里创建的BeanDefinition扫描器不是后续Spring用来扫描的，而是给我们自己扫描的）
4. 注册配置类
5. refresh()方法中加载解析配置类

测试代码

public class MainStart {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
        ctx.getBean("people");
    }
}

我们首先进入AnnotationConfigApplicationContext方法的父类GenericApplicationContext的无参构造方法,这里我们看到了

public GenericApplicationContext() {
  
    /**
     * ApplicationContext spring上下文对象初始beanFactory
     */
    this.beanFactory = new DefaultListableBeanFactory();
}

注意到这里使用的是DefaultListableBeanFactory是因为这个BeanFactory是最上层的，实现的功能最多。

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    // 调用构造函数
    this();
    // 注册传进来的配置类
    register(annotatedClasses);
    // 调用一堆方法
    refresh();
}

AnnotationConfigApplicationContext构造方法

public AnnotationConfigApplicationContext() {
    // 注册一些内置的后置处理器包括了ConfigurationClassPostProcessor（配置类解析后置处理器）
    this.reader = new AnnotatedBeanDefinitionReader(this);
    
    // 创建BeanDefinition扫描器,扫描包或者类，继而转换为BeanDefinition
    // spring默认的扫描包不是这个scanner对象，这是给我们自己调用context.scan()扫描的
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}

AnnotatedBeanDefinitionReader构造方法

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   Assert.notNull(environment, "Environment must not be null");
   //初始化BeanDefinition注册器
   this.registry = registry;
   //处理条件注解 @Conditional
   this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
   //注册一些内置的后置处理器（包含解析配置类后置处理器）
   AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

registerAnnotationConfigProcessors方法

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
      BeanDefinitionRegistry registry, @Nullable Object source) {

   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
   if (beanFactory != null) {
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         //注册了实现Order接口的排序器
         beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
      }
      // 设置@AutoWired的候选的解析器：ContextAnnotationAutowireCandidateResolver
      // getLazyResolutionProxyIfNecessary方法，它也是唯一实现。
      // 如果字段上带有@Lazy注解，表示进行懒加载 Spring不会立即创建注入属性的实例，而是生成代理对象，来代替实例
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
         beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
      }
   }

   Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

   // 为我们容器中注册了解析我们配置类的后置处理器ConfigurationClassPostProcessor
   // org.springframework.context.annotation.internalConfigurationAnnotationProcessor
   if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // 为我们容器中注册了处理@Autowired注解的处理器AutowiredAnnotationBeanPostProcessor
   // org.springframework.context.annotation.internalAutowiredAnnotationProcessor
   if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // 为我们容器中注册处理@Required属性的注解处理器RequiredAnnotationBeanPostProcessor
   // org.springframework.context.annotation.internalRequiredAnnotationProcessor
   if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // 为我们容器注册处理JSR规范的注解处理器CommonAnnotationBeanPostProcessor
   // org.springframework.context.annotation.internalCommonAnnotationProcessor
   if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // 处理jpa注解的处理器
   // org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor
   if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition();
      try {
         def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
               AnnotationConfigUtils.class.getClassLoader()));
      }
      catch (ClassNotFoundException ex) {
         throw new IllegalStateException(
               "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
      }
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // 处理监听方法的注解@EventListener解析器EventListenerMethodProcessor
   // org.springframework.context.event.internalEventListenerProcessor
   if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
   }

   // 注册事件监听器工厂
   // org.springframework.context.event.internalEventListenerFactory
   if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
   }

   return beanDefs;
}

这里最主要的就是注册了解析我们配置类的后置处理器ConfigurationClassPostProcessor。这个后置处理器在后面refresh中会调用

现在我们回到AnnotationConfigApplicationContext中的构造方法中register方法一直跟进去到doRegisterBean方法

doRegisterBean方法

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
            @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
    // 存储@Configuration注解注释的类
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    // 判断是否需要跳过注解，spring中有一个@Condition注解，当不满足条件，这个bean就不会被解析
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        return;
    }

    abd.setInstanceSupplier(instanceSupplier);
    // 解析bean的作用域，如果没有设置的话，默认为单例
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    abd.setScope(scopeMetadata.getScopeName());
    // 获得beanName
    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    // 解析通用注解，填充到AnnotatedGenericBeanDefinition，解析的注解为Lazy，Primary，DependsOn，Role，Description
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    if (qualifiers != null) {
        for (Class<? extends Annotation> qualifier : qualifiers) {
            if (Primary.class == qualifier) {
                abd.setPrimary(true);
            }
            else if (Lazy.class == qualifier) {
                abd.setLazyInit(true);
            }
            else {
                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
            }
        }
    }
    for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
        customizer.customize(abd);
    }

    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

    // 注册，最终会调用DefaultListableBeanFactory中的registerBeanDefinition方法去注册，
    // DefaultListableBeanFactory维护着一系列信息，比如beanDefinitionNames，beanDefinitionMap
    // beanDefinitionNames是一个List<String>,用来保存beanName
    // beanDefinitionMap是一个Map,用来保存beanName和beanDefinition
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

refresh方法

Spring中最最最重要的方法，不管用什么容器最终都会到这个方法。

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 准备刷新上下文环境
      prepareRefresh();

      // 获取告诉子类初始化Bean工厂  不同工厂不同实现
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // bean工厂进行填充属性
      prepareBeanFactory(beanFactory);

      try {
         // 留个子类去实现该接口
         postProcessBeanFactory(beanFactory);

         // 调用我们的bean工厂的后置处理器. 1. 会在此将class扫描成beanDefinition  2.bean工厂的后置处理器调用
         invokeBeanFactoryPostProcessors(beanFactory);

         // 注册我们bean的后置处理器
         registerBeanPostProcessors(beanFactory);

         // 初始化国际化资源处理器.
         initMessageSource();

         // 创建事件多播器
         initApplicationEventMulticaster();

         // 这个方法同样也是留个子类实现的springboot也是从这个方法进行启动tomcat的.
         onRefresh();

         // 把我们的事件监听器注册到多播器上
         registerListeners();

         // 实例化我们剩余的单实例bean.
         finishBeanFactoryInitialization(beanFactory);

         // 最后容器刷新 发布刷新事件(Spring cloud也是从这里启动的)
         finishRefresh();
      }
   }

只是对于解析配置类生成BeanDefinition主要就是看2个方法，一个是invokeBeanFactoryPostProcessors，在这个方法中会调用我们上面在reader方法中注册的ConfigurationClassPostProcessor后置处理器，在这个后置处理器中会解析配置类加载成BeanDefinition。另一个方法就是finishBeanFactoryInitialization，这个方法中会实例化剩余的单例Bean,Bean的循环依赖就是这里解决的。

invokeBeanFactoryPostProcessors方法

// beanFactory:存在bean工厂中的后置处理器，存储在BeanDefinitionMap中，是上面初始化的时候存储的那6个后置处理器加上配置类共7个BeanDefinition
// beanFactoryPostProcessors:我们调用context的addBeanFactoryPostProcessor方法加入的后置处理器，这里是0
public static void invokeBeanFactoryPostProcessors(
         ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

      //调用BeanDefinitionRegistryPostProcessor的后置处理器 Begin
      // 定义已处理的后置处理器
      Set<String> processedBeans = new HashSet<>();

      //判断我们的beanFactory实现了BeanDefinitionRegistry(实现了该结构就有注册和获取Bean定义的能力）
      if (beanFactory instanceof BeanDefinitionRegistry) {
         //强行把我们的bean工厂转为BeanDefinitionRegistry，因为待会需要注册Bean定义
         BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
         //保存BeanFactoryPostProcessor类型的后置   BeanFactoryPostProcessor 提供修改
         List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
         //保存BeanDefinitionRegistryPostProcessor类型的后置处理器 BeanDefinitionRegistryPostProcessor 提供注册
         List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

         //循环我们传递进来的beanFactoryPostProcessors
         for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            //判断我们的后置处理器是不是BeanDefinitionRegistryPostProcessor
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
               //进行强制转化
               BeanDefinitionRegistryPostProcessor registryProcessor =
                     (BeanDefinitionRegistryPostProcessor) postProcessor;
               //调用他作为BeanDefinitionRegistryPostProcessor的处理器的后置方法
               registryProcessor.postProcessBeanDefinitionRegistry(registry);
               //添加到我们用于保存的BeanDefinitionRegistryPostProcessor的集合中
               registryProcessors.add(registryProcessor);
            }
            else {//若没有实现BeanDefinitionRegistryPostProcessor 接口，那么他就是BeanFactoryPostProcessor
               //把当前的后置处理器加入到regularPostProcessors中
               regularPostProcessors.add(postProcessor);
            }
         }

         //定义一个集合用户保存当前准备创建的BeanDefinitionRegistryPostProcessor
         List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

         //去容器中拿BeanDefinitionRegistryPostProcessor的bean的处理器名称，这里只拿到了ConfigurationClassPostProcessor
         String[] postProcessorNames =
               beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
         //循环筛选出来的匹配BeanDefinitionRegistryPostProcessor的类型名称
         for (String ppName : postProcessorNames) {
            //判断是否实现了PriorityOrdered接口的
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
               //显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
               currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
               //同时也加入到processedBeans集合中去
               processedBeans.add(ppName);
            }
         }
         //对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
         sortPostProcessors(currentRegistryProcessors, beanFactory);
         //把当前的加入到总的里面去
         registryProcessors.addAll(currentRegistryProcessors);
         
         //在这里典型的BeanDefinitionRegistryPostProcessor就是ConfigurationClassPostProcessor
         //用于进行bean定义的加载 比如我们的包扫描，@import等
         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
         //调用完之后，马上clear掉
         currentRegistryProcessors.clear();
          
         //去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称（内置的和上面注册的）
         postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
         //循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
         for (String ppName : postProcessorNames) {
            //表示没有被处理过,且实现了Ordered接口的
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
               //显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
               currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
               //同时也加入到processedBeans集合中去
               processedBeans.add(ppName);
            }
         }
         //对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
         sortPostProcessors(currentRegistryProcessors, beanFactory);
         //把他加入到用于保存到registryProcessors中
         registryProcessors.addAll(currentRegistryProcessors);
         //调用他的后置处理方法
         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
         //调用完之后，马上clea掉
         currentRegistryProcessors.clear();

         //调用没有实现任何优先级接口的BeanDefinitionRegistryPostProcessor
         //定义一个重复处理的开关变量 默认值为true
         boolean reiterate = true;
         //第一次就可以进来
         while (reiterate) {
            //进入循环马上把开关变量给改为false
            reiterate = false;
            //去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            //循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
            for (String ppName : postProcessorNames) {
               //没有被处理过的
               if (!processedBeans.contains(ppName)) {
                  //显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
                  currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                  //同时也加入到processedBeans集合中去
                  processedBeans.add(ppName);
                  //再次设置为true
                  reiterate = true;
               }
            }
            //对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            //把他加入到用于保存到registryProcessors中
            registryProcessors.addAll(currentRegistryProcessors);
            //调用他的后置处理方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            //进行clear
            currentRegistryProcessors.clear();
         }
         //调用 BeanDefinitionRegistryPostProcessor.postProcessBeanFactory方法
         invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
         //调用BeanFactoryPostProcessor 自设的（没有）
         invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
      }

      else {
          //若当前的beanFactory没有实现了BeanDefinitionRegistry 说明没有注册Bean定义的能力
          // 那么就直接调用BeanDefinitionRegistryPostProcessor.postProcessBeanFactory方法
         invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
      }

      //获取容器中所有的 BeanFactoryPostProcessor
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

      //保存BeanFactoryPostProcessor类型实现了priorityOrdered
      List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
      //保存BeanFactoryPostProcessor类型实现了Ordered接口的
      List<String> orderedPostProcessorNames = new ArrayList<>();
      //保存BeanFactoryPostProcessor没有实现任何优先级接口的
      List<String> nonOrderedPostProcessorNames = new ArrayList<>();
      for (String ppName : postProcessorNames) {
         //processedBeans包含的话，表示在上面处理BeanDefinitionRegistryPostProcessor的时候处理过了
         if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
         }
         //判断是否实现了PriorityOrdered 优先级最高
         else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
         }
         //判断是否实现了Ordered  优先级 其次
         else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
         }
         //没有实现任何的优先级接口的  最后调用
         else {
            nonOrderedPostProcessorNames.add(ppName);
         }
      }
      //  排序
      sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
      // 先调用BeanFactoryPostProcessor实现了 PriorityOrdered接口的
      invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

      //再调用BeanFactoryPostProcessor实现了 Ordered.
      List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
      for (String postProcessorName : orderedPostProcessorNames) {
         orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
      }
      sortPostProcessors(orderedPostProcessors, beanFactory);
      invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

      //调用没有实现任何方法接口的
      List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
      for (String postProcessorName : nonOrderedPostProcessorNames) {
         nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
      }
      invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

      // Clear cached merged bean definitions since the post-processors might have
      // modified the original metadata, e.g. replacing placeholders in values...
      beanFactory.clearMetadataCache();
   }

这里调用比较复杂，大概梳理一下，这里主要是对2种接后置处理器进行调用

1. BeanDefinitionRegistryPostProcessor：带注册得Bean工厂后置处理器，调用方法是postProcessBeanDefinitionRegistry
2. BeanFactoryPostProcessor：不带注册的Bean工厂后置处理器调用方法是postProcessBeanFactory

这里在看优先级

首先BeanDefinitionRegistryPostProcessor先进行调用然后BeanFactoryPostProcessor调用

在BeanDefinitionRegistryPostProcessor内部会先调用实现了PriorityOrdered接口的，然后调用实现了Ordered接口的，最后调用都没有实现的，然后调用BeanFactoryPostProcessor处理器的postProcessBeanFactory也是按照PriorityOrdered->Ordered->null的规则调用。

现在我们看到invokeBeanDefinitionRegistryPostProcessors方法ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry方法，这里就是根据配置类配置的包路径扫描class解析成Bean定义到BeanDefinitionMap中去

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
        //获取IOC 容器中目前所有bean定义的名称
        String[] candidateNames = registry.getBeanDefinitionNames();

        //循环我们的上一步获取的所有的bean定义信息
        for (String beanName : candidateNames) {
            //通过bean的名称来获取我们的bean定义对象
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            //判断是否有没有解析过
            if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
                    ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
                }
            }
            //进行正在的解析判断是不是完全的配置类 还是一个非正式的配置类
            else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
                //满足添加 就加入到候选的配置类集合中
                configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
            }
        }

        // 若没有找到配置类 直接返回
        if (configCandidates.isEmpty()) {
            return;
        }

        //对我们的配置类进行Order排序
        configCandidates.sort((bd1, bd2) -> {
            int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
            int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
            return Integer.compare(i1, i2);
        });

        // 创建我们通过@CompentScan导入进来的bean name的生成器
        // 创建我们通过@Import导入进来的bean的名称
        SingletonBeanRegistry sbr = null;
        if (registry instanceof SingletonBeanRegistry) {
            sbr = (SingletonBeanRegistry) registry;
            if (!this.localBeanNameGeneratorSet) {
                BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
                if (generator != null) {
                    //设置@CompentScan导入进来的bean的名称生成器(默认类首字母小写）也可以自己定义，一般不会
                    this.componentScanBeanNameGenerator = generator;
                    //设置@Import导入进来的bean的名称生成器(默认类首字母小写）也可以自己定义，一般不会
                    this.importBeanNameGenerator = generator;
                }
            }
        }

        if (this.environment == null) {
            this.environment = new StandardEnvironment();
        }

        //创建一个配置类解析器对象
        ConfigurationClassParser parser = new ConfigurationClassParser(
                this.metadataReaderFactory, this.problemReporter, this.environment,
                this.resourceLoader, this.componentScanBeanNameGenerator, registry);

        //用于保存我们的配置类BeanDefinitionHolder放入上面筛选出来的配置类
        Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
        //用于保存我们的已经解析的配置类，长度默认为解析出来默认的配置类的集合长度
        Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
        //do while 会进行第一次解析
        do {
            //真正的解析我们的配置类
            parser.parse(candidates);
            parser.validate();

            //解析出来的配置类
            Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
            configClasses.removeAll(alreadyParsed);

            // Read the model and create bean definitions based on its content
            if (this.reader == null) {
                this.reader = new ConfigurationClassBeanDefinitionReader(
                        registry, this.sourceExtractor, this.resourceLoader, this.environment,
                        this.importBeanNameGenerator, parser.getImportRegistry());
            }
            // 此处才把@Bean的方法和@Import 注册到BeanDefinitionMap中
            this.reader.loadBeanDefinitions(configClasses);
            //加入到已经解析的集合中
            alreadyParsed.addAll(configClasses);

            candidates.clear();
            //判断我们ioc容器中的是不是>候选原始的bean定义的个数
            if (registry.getBeanDefinitionCount() > candidateNames.length) {
                //获取所有的bean定义
                String[] newCandidateNames = registry.getBeanDefinitionNames();
                //原始的老的候选的bean定义
                Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
                Set<String> alreadyParsedClasses = new HashSet<>();
                //赋值已经解析的
                for (ConfigurationClass configurationClass : alreadyParsed) {
                    alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
                }

                for (String candidateName : newCandidateNames) {
                    //表示当前循环的还没有被解析过
                    if (!oldCandidateNames.contains(candidateName)) {
                        BeanDefinition bd = registry.getBeanDefinition(candidateName);
                        //判断有没有被解析过
                        if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                                !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                            candidates.add(new BeanDefinitionHolder(bd, candidateName));
                        }
                    }
                }
                candidateNames = newCandidateNames;
            }
        }
        //存在没有解析过的 需要循环解析
        while (!candidates.isEmpty());

        // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
        if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
            sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
        }

        if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
            // Clear cache in externally provided MetadataReaderFactory; this is a no-op
            // for a shared cache since it'll be cleared by the ApplicationContext.
            ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
        }
    }

ConfigurationClassUtils.checkConfigurationClassCandidate方法

这个方法将配置类分成了2种一种是@Configuration,这种类型标注了属性configurationClass为full其他的标注为lite

public static boolean checkConfigurationClassCandidate(BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
        // .......

        // 判断是不是真正的配置类 就是判断当前的bean的class上有没有标注了@Configuration注解
        if (isFullConfigurationCandidate(metadata)) {
            // 设置了标记
            beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
        }
        // 这里判断该配置类是一个非正式的配置类(Component ComponentScan Import ImportResource)
        else if (isLiteConfigurationCandidate(metadata)) {
            beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
        }
        else {
            return false;
        }

        // 解析配置类上是否标注了@Order注解
        Integer order = getOrder(metadata);
        if (order != null) {
            beanDef.setAttribute(ORDER_ATTRIBUTE, order);
        }

        return true;
    }

核心方法parser.parse(candidates)解析配置类的地方

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        // 用于来保存延时的ImportSelectors，SpringBoot自动装配的的类AutoConfigurationImportSelector
        this.deferredImportSelectors = new LinkedList<>();
        // 循环配置类
        for (BeanDefinitionHolder holder : configCandidates) {
            BeanDefinition bd = holder.getBeanDefinition();
            try {
                //真正的解析我们的bean定义:通过注解元数据解析
                if (bd instanceof AnnotatedBeanDefinition) {
                    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
                }
                else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                    parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
                }
                else {
                    parse(bd.getBeanClassName(), holder.getBeanName());
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                        "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
            }
        }
        //处理我们延时的DeferredImportSelectors springboot就是通过这步进行记载spring.factories文件中的自定装配的对象
        processDeferredImportSelectors();
    }

parse->processConfigurationClass->doProcessConfigurationClass->this.componentScanParser.parse

这里就是解析ComponentScans，把该扫描的包路径集合封装好调用doScan进行扫描

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
   // 看到这里就想到了初始化构造方法中的scan了，从这也看出来spring内部的扫描并没有使用初始化new出来的扫描器
   ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
         componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

   //为我们的扫描器设置beanName的生成器对象
   Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
   boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
   scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
         BeanUtils.instantiateClass(generatorClass));

   //s解析@Scope的ProxyMode属性,该属性可以将Bean创建问jdk代理或cglib代理
   ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
   if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
      scanner.setScopedProxyMode(scopedProxyMode);
   }
   else {
      Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
      scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
   }

   scanner.setResourcePattern(componentScan.getString("resourcePattern"));

   //设置CompentScan对象的includeFilters包含的属性
   for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
      for (TypeFilter typeFilter : typeFiltersFor(filter)) {
         scanner.addIncludeFilter(typeFilter);
      }
   }
   //设置CompentScan对象的excludeFilters包含的属性
   for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
      for (TypeFilter typeFilter : typeFiltersFor(filter)) {
         scanner.addExcludeFilter(typeFilter);
      }
   }

   //是否懒加载，此懒加载为componentScan延迟加载所有类
   boolean lazyInit = componentScan.getBoolean("lazyInit");
   if (lazyInit) {
      scanner.getBeanDefinitionDefaults().setLazyInit(true);
   }

   //包路径
   Set<String> basePackages = new LinkedHashSet<>();
   String[] basePackagesArray = componentScan.getStringArray("basePackages");
   for (String pkg : basePackagesArray) {
      String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      Collections.addAll(basePackages, tokenized);
   }
   for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
      basePackages.add(ClassUtils.getPackageName(clazz));
   }
   if (basePackages.isEmpty()) {
      basePackages.add(ClassUtils.getPackageName(declaringClass));
   }

   scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
      @Override
      protected boolean matchClassName(String className) {
         return declaringClass.equals(className);
      }
   });
   //真正的进行扫描解析
   return scanner.doScan(StringUtils.toStringArray(basePackages));

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
   Assert.notEmpty(basePackages, "At least one base package must be specified");
   //创建bean定义的holder对象用于保存扫描后生成的bean定义对象
   Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
   //循环我们的包路径集合
   for (String basePackage : basePackages) {
      //找到候选的Components
      Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
      for (BeanDefinition candidate : candidates) {

         ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
         candidate.setScope(scopeMetadata.getScopeName());
         //设置我们的beanName
         String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
         //这是默认配置 autowire-candidate
         if (candidate instanceof AbstractBeanDefinition) {
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
         }
         //获取@Lazy @DependsOn等注解的数据设置到BeanDefinition中
         if (candidate instanceof AnnotatedBeanDefinition) {
            AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
         }
         //把我们解析出来的组件bean定义注册到我们的IOC容器中（容器中没有才注册）
         if (checkCandidate(beanName, candidate)) {
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            definitionHolder =
                  AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            beanDefinitions.add(definitionHolder);
            registerBeanDefinition(definitionHolder, this.registry);
         }
      }
   }
   return beanDefinitions;
}

findCandidateComponents->scanCandidateComponents方法

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
   Set<BeanDefinition> candidates = new LinkedHashSet<>();
   try {
      //把我们的包路径转为资源路径 xx/xx/xx
      String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolveBasePackage(basePackage) + '/' + this.resourcePattern;
      //扫描指定包路径下面的所有.class文件
      Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
      boolean traceEnabled = logger.isTraceEnabled();
      boolean debugEnabled = logger.isDebugEnabled();
      //需要我们的resources集合
      for (Resource resource : resources) {
         if (traceEnabled) {
            logger.trace("Scanning " + resource);
         }
         //判断当的是不是可读的
         if (resource.isReadable()) {
            try {
               MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
               //是不是候选的组件这里表示可以扫描Component,ManagedBean,Named
               if (isCandidateComponent(metadataReader)) {
                  //包装成为一个ScannedGenericBeanDefinition
                  ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                  //并且设置class资源
                  sbd.setResource(resource);
                  sbd.setSource(resource);
                  // 这里表示可以扫描的类
                  // 顶级类、嵌套类、静态内部类
                 // 非接口、非抽象类
                  // 抽象类并且必须方法中有@LookUp
                  if (isCandidateComponent(sbd)) {
                     if (debugEnabled) {
                        logger.debug("Identified candidate component class: " + resource);
                     }
                     //加入到集合中
                     candidates.add(sbd);
                  }
                  else {
                     if (debugEnabled) {
                        logger.debug("Ignored because not a concrete top-level class: " + resource);
                     }
                  }
               }
               else {
                  if (traceEnabled) {
                     logger.trace("Ignored because not matching any filter: " + resource);
                  }
               }
            }
            catch (Throwable ex) {
               throw new BeanDefinitionStoreException(
                     "Failed to read candidate component class: " + resource, ex);
            }
         }
         else {
            if (traceEnabled) {
               logger.trace("Ignored because not readable: " + resource);
            }
         }
      }
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
   }
   //返回
   return candidates;
}

finishBeanFactoryInitialization方法

这一部分在后续Spring如何解决循环依赖中

流程图

Q&A

SpringIOC的加载过程？

首先Spring会初始化reader，register和scan三个类，reader主要负责读取配置类和加载一些spring内部需要用的后置处理器共6个，在这些后置处理器中包含了解析配置类的后置处理器，register主要负责注册bean定义,当然也包括bean后置处理器的注册。scan主要负责扫描包路径下的类，当然初始化中的scan并不是spring内部使用的扫描器。然后注册我们的配置类。现在我们配置类，解析配置类的bean工厂后置处理器都有了，spring就可以利用后置处理器解析配置类。当然这里解析之前会getBean去拿到完整的bean，解析完配置类获取到包扫描路径，扫描配置类中的包扫描路径，将扫描到的类解析成bean定义注册进Spring中。最后我们对BeanDefinitionMap中的类进行遍历getBean生成完整的bean。

扩展点

这一块内容共提供了2个扩展点，这2个扩展点是针对Bean定义进行修改和注册

1. BeanDefinitionRegistryPostProcessor：带注册得Bean工厂后置处理器，可以注册Bean定义
2. BeanFactoryPostProcessor：Bean工厂后置处理器，可以修改Bean定义