IoC容器加载过程

现在用的比较多的注解的方式，这里仅对于注解的容器即AnnotationConfigApplicationContext的加过程的总结。使用时启动一个容器仅一行或几行代码，看着相当简单，但内部做了非常复杂的处理。这里的MainConfig是一个配置类，带上@Configuration注解的配置类是传统意义上的配置类Spring内部称为Full配置类；还有一种是没有带上@Configuration，但是带有@Component，@Import，@ImportResouce，@Service，@ComponentScan等注解的配置类Spring内部称之为Lite配置类。在解析这些配置类时，会给其加上Full或Lite属性。

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
// 或者通过下面的方式启动容器
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(MainStarter.class);
context.refresh();

实例化AnnotationConfigApplicationContext容器的时，首先会隐式调用父类GenericApplicationContext的无参构造函数去实例化Bean工厂DefaultListableBeanFactory。然后调用无参构造方法对读取器AnnotatedBeanDefinitionReader和扫描器ClassPathBeanDefinitionScanner进行了实例化，然后通过register注册自己的配置类为BeanDefinition，最后调用refresh()方法。

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
   // 注解的bean定义读取器
   private final AnnotatedBeanDefinitionReader reader;
   // 类路径下的bean定义扫描器
   private final ClassPathBeanDefinitionScanner scanner;
   public AnnotationConfigApplicationContext() {
      // 创建一个读取注解的BeanDefinition读取器，完成spring内部BeanDefinition的注册（主要是后置处理器）
      this.reader = new AnnotatedBeanDefinitionReader(this);
      /**
       * 创建BeanDefinition扫描器，可以用来扫描包或者类，继而转换为BeanDefinition
       * spring默认的扫描包不是该scanner对象，而是在执行工程后置处理器ConfigurationClassPostProcessor时，去扫描包时会new一个ClassPathBeanDefinitionScanner
       * 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法
       */
      this.scanner = new ClassPathBeanDefinitionScanner(this);
   }
   public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
      super(beanFactory);
      this.reader = new AnnotatedBeanDefinitionReader(this);
      this.scanner = new ClassPathBeanDefinitionScanner(this);
   }
   public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
      this();	// 调用构造函数
      register(annotatedClasses);	 //注册我们的配置类
      refresh(); // IOC容器刷新接口
   }
   public AnnotationConfigApplicationContext(String... basePackages) {
      this();
      scan(basePackages);
      refresh();
   }
}
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
	private final DefaultListableBeanFactory beanFactory;
	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}
}

实例化DefaultListableBeanFactory工厂

DefaultListableBeanFactory是最底层的实现，其中定义很多重要的属性，在后续的容器加载过程会频繁用到：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
   /** Map from serialized id to factory instance */
   private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories = new ConcurrentHashMap<>(8);
   /** Optional id for this factory, for serialization purposes */
   @Nullable
   private String serializationId;
   /** Whether to allow re-registration of a different definition with the same name */
   private boolean allowBeanDefinitionOverriding = true;
   /** Whether to allow eager class loading even for lazy-init beans */
   private boolean allowEagerClassLoading = true;
   /** Optional OrderComparator for dependency Lists and arrays */
   @Nullable
   private Comparator<Object> dependencyComparator;
   /** Resolver to use for checking if a bean definition is an autowire candidate */
   private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
   /** Map from dependency type to corresponding autowired value */
   private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
   /** 用于保存原始的bean定义信息(没有被mearged) */
   private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
   /** Map of singleton and non-singleton bean names, keyed by dependency type */
   private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);
   /** Map of singleton-only bean names, keyed by dependency type */
   private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);
   /** List of bean definition names, in registration order */
   private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
   /** List of names of manually registered singletons, in registration order */
   private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);
   /** Cached array of bean definition names in case of frozen configuration */
   @Nullable
   private volatile String[] frozenBeanDefinitionNames;
   /** Whether bean definition metadata may be cached for all beans */
   private volatile boolean configurationFrozen = false;
}

实例化BeanDefinition读取器

AnnotatedBeanDefinitionReader主要是注册内置的BeanPostProcessor以及注册相关的BeanDefinition，主要是注册系统内部的一些基础的配置类如：解析配置类的后置处理器ConfigurationClassPostProcessor、处理@Autowired注解的处理器AutowiredAnnotationBeanPostProcessor、处理@Required属性的注解处理器RequiredAnnotationBeanPostProcessor、处理JSR规范的注解处理器CommonAnnotationBeanPostProcessor、处理jpa注解的处理器PersistenceAnnotationBeanPostProcessor、处理监听方法的注解@EventListener解析器EventListenerMethodProcessor、注册事件监听器工厂DefaultEventListenerFactory。

ConfigurationClassPostProcessor是最重要的Bean其实现了BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口，其作用分别为注册BeanDefinition和修改BeanDefinition，BeanFactoryPostProcessor是Spring扩展点之一。

public class AnnotatedBeanDefinitionReader {
   private final BeanDefinitionRegistry registry;
   private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
   private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
   private ConditionEvaluator conditionEvaluator;
   public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
      this(registry, getOrCreateEnvironment(registry));
   }
   public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
      Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
      Assert.notNull(environment, "Environment must not be null");
      // 把ApplicationContext对象赋值给AnnotatedBeanDefinitionReader
      this.registry = registry;
      // 用户处理条件注解 @Conditional os.name
      this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
      // 注册一些内置的后置处理器
      AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
   }
}
public class AnnotationConfigUtils {
    public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
        registerAnnotationConfigProcessors(registry, null);
    }
    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
        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));
        }
        // 注册事件监听器工厂
        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;
    }
}

最终是通过registerPostProcessor注册这些BeanDefinition，最终是调用的DefaultListableBeanFactory的registerBeanDefinition将这些BeanDefinition放入保存原始的BeanDefinition信息的beanDefinitionMap及beanDefinitionNames中。这里仅仅是注册，并没有对这些Bean实例化。

创建BeanDefinition扫描器

常规使用方式是不会用到AnnotationConfigApplicationContext中的scanner的，这里的scanner仅仅是为了手动调用AnnotationConfigApplicationContext对象的scan方法。

register注册自定义配置类

register传入的是一个数组，最终会循环调用doRegisterBean注册传入的配置到DefaultListableBeanFactory中的beanDefinitionMap和beanDefinitionNames中。注意这里是使用AnnotatedGenericBeanDefinition来获得配置类的BeanDefinition而前面注册系统内部的一些基础的配置类时是通过RootBeanDefinition来获得配置类BeanDefinition的。

<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的作用域和scopedProxyMode，如果没有设置的话，默认为单例，默认scopedProxyMode=ScopedProxyMode.NO
   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还没有进行扫描，只是实例化了一个工厂，注册了一些内置的Bean和我们传进去的配置类。refresh是一个模板方法。

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    public void refresh() throws BeansException, IllegalStateException {
       synchronized (this.startupShutdownMonitor) {
          prepareRefresh();	// 刷新预处理，和主流程关系不大，就是保存了容器的启动时间，启动标志等
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 获取告诉子类初始化Bean工厂，不同工厂不同实现
          prepareBeanFactory(beanFactory); // 对bean工厂进行填充属性，添加了两个后置处理器：ApplicationContextAwareProcessor，ApplicationListenerDetector，还设置了忽略自动装配和允许自动装配的接口，若不存在某个bean的时候，spring就自动注册singleton bean，还设置了bean表达式解析器等
          try {
             postProcessBeanFactory(beanFactory); // 留个子类去实现该接口
             invokeBeanFactoryPostProcessors(beanFactory); // 调用我们的bean工厂的后置处理器，会在此将class扫描成beanDefinition，bean工厂的后置处理器调用
             registerBeanPostProcessors(beanFactory); // 注册bean的后置处理器
             initMessageSource(); // 初始化国际化资源处理器
             initApplicationEventMulticaster();// 创建事件多播器
             onRefresh();// 该方法同样也是留给子类实现的，springboot也是从该方法进行启动tomcat的
             registerListeners(); // 把事件监听器注册到多播器上
             finishBeanFactoryInitialization(beanFactory); // 实例化我们剩余的单实例bean
             finishRefresh(); // 最后容器刷新 发布刷新事件(Spring cloud也是从这里启动的)
          } catch (BeansException ex) {
             if (logger.isWarnEnabled()) {
                logger.warn("Exception  encountered during context initialization - " + "cancelling refresh attempt: " + ex);
             }
             // Destroy already created singletons to avoid dangling resources.
             destroyBeans();
             cancelRefresh(ex);
             throw ex;
          } finally {
             resetCommonCaches();
          }
       }
    }
}

prepareRefresh

主要做了一些刷新前的准备工作，和主流程关系不大，主要是保存了容器的启动时间，启动标志等；

protected void prepareRefresh() {
   this.startupDate = System.currentTimeMillis();
   this.closed.set(false);
   this.active.set(true);
   /**
    * 相传该方法在网上很多人说该方法没有用,因为这个方法是留个子类实现的,由于是对spring源码的核心 设计理念没有弄清楚,正式由于spring提供了大量的可扩展的接口提供给我们自己来实现
    * 比如我们自己写一个类重写了initPropertySources方法，在该方法中设置了一个环境变量的值为A 启动的时候，我的环境变量中没有该值就会启动抛出异常
    */
   initPropertySources();
   // 用来校验我们容器启动必须依赖的环境变量的值
   getEnvironment().validateRequiredProperties();
   // 创建一个早期事件监听器对象
   if (this.earlyApplicationListeners == null) {
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
   } else {
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
   }
   /**
    * 创建一个容器用于保存早期待发布的事件集合，就是我们的事件监听器还没有注册到多播器上的时候都称为早期事件
    * 早期事件不需要手动publishEvent发布， 在registerListeners中会自动发布， 发布完早期事件就不存在了。
    */
   this.earlyApplicationEvents = new LinkedHashSet<>();
}

obtainFreshBeanFactory

和主流程关系也不是很大，可简单认为就是把beanFactory取出来而已，XML模式下会在这里读取BeanDefinition；

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   // xml加载spring会在这里加载beanDefinition，javaconfig只是刷新了beanFactory
   refreshBeanFactory();
   //返回我们的bean工厂
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   return beanFactory;
}

prepareBeanFactory

做一些准备工作主要是为Bean工厂填充内部属性，添加了ApplicationContextAwareProcessor和ApplicationListenerDetector后置处理器，还设置了忽略自动装配和允许自动装配的接口，若不存在某个Bean时，Spring则自动注册Singleton Bean，还设置了bean表达式解析器等；

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   //设置bean工厂的类加载器为当前application应用的加载器
   beanFactory.setBeanClassLoader(getClassLoader());
   //为bean工厂设置我们标准的SPEL表达式解析器对象StandardBeanExpressionResolver
   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   //为我们的bean工厂设置了一个propertityEditor 属性资源编辑器对象(用于后面的给bean对象赋值使用)
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
   // 注册了一个完整的ApplicationContextAwareProcessor 后置处理器用来处理ApplicationContextAware接口的回调方法
   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
   // 忽略以下接口的bean的接口函数方法，在populateBean时以下接口都有setXXX方法，这些方法不特殊处理将会自动注入容器中的bean
   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
   /**
    * 当注册了依赖解析后，例如当注册了对BeanFactory.class的解析依赖后，，当bean的属性注入时，一旦检测到属性为BeanFactory 类型便会将beanFactory的实例注入进去。
    * 知道为什么可以@Autowired， ApplicationContext  applicationContext  就是因为这里设置了
    */
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);
   // 注册了一个事件监听器探测器后置处理器接口
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { // 处理aspectj的
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
   // 注册了bean工厂的内部的bean
   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { // 环境
      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { //环境系统属性
      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
   }
   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { //系统环境
      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
   }
}

postProcessBeanFactory

一个空方法留给子类去实现该接口。

invokeBeanFactoryPostProcessors

是目前为止最重要的方法，会在此将Class扫描成BeanDefinition以及Bean工厂后置处理器调用对IoC容器加载BeanDefinition前后进行处理。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   // 参数分别是当前Bean工厂，自己调用annotationConfigApplicationContext.addBeanFactoryPostProcessor添加的
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

   if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
}

BeanDefinitionRegistryPostProcessor是BeanDefinition解析前调用，执行的顺序依次是：实现了PriorityOrdered接口的，实现了Ordered接口的，没有实现任何的优先级接口的，BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口。

BeanFactoryPostProcessor是BeanDefinition解析后调用，其执行顺序和BeanDefinitionRegistryPostProcessor是一样的。但是Bean实例还没有被初始化。

很明显当前的beanFactory即AnnotationConfigApplicationContext从前面的类结构图可知明显是BeanDefinitionRegistry的实例，这里一般情况beanFactoryPostProcessors是空的。processedBeans变量是用于将已经处理过的后置处理器过滤掉，防止重复执行。

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    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的处理器名称
        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);
        // 把当前的加入到总的里面去，因为一开始spring只会执行BeanDefinitionRegistryPostProcessor独有的方法，而不会执行BeanDefinitionRegistryPostProcessor父类的方法
        // 即BeanFactoryProcessor接口中的方法，所以需要把这些后置处理器放入一个集合中，后续统一执行BeanFactoryProcessor接口中的方法
        registryProcessors.addAll(currentRegistryProcessors);
        // 在这里典型的BeanDefinitionRegistryPostProcessor就是ConfigurationClassPostProcessor，用于进行bean定义的加载，如包扫描，@import等等
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear(); // 调用完之后，马上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); // 调用他的后置处理方法
        currentRegistryProcessors.clear(); // 调用完之后，马上clear掉
        // 调用没有实现任何优先级接口的BeanDefinitionRegistryPostProcessor，定义一个重复处理的开关变量 默认值为true
        boolean reiterate = true;
        while (reiterate) { // 第一次就可以进来
            reiterate = false; // 进入循环马上把开关变量给改为false
            // 去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) { // 循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
                if (!processedBeans.contains(ppName)) { //没有被处理过的
                    //显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName); // 同时也加入到processedBeans集合中去
                    reiterate = true; //再次设置为true
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear(); // 调用完之后，马上clear掉
        }
        // 调用BeanDefinitionRegistryPostProcessor.postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        // 调用BeanFactoryPostProcessor自设的
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    } else {
        // 若当前的beanFactory没有实现BeanDefinitionRegistry说明没有注册Bean定义的能力
        // 则直接调用BeanDefinitionRegistryPostProcessor.postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }
    // 上面是所有BeanDefinitionRegistryPostProcessor调用完毕，接下来处理BeanFactoryPostProcessor
    
    
    //获取容器中所有的 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
        } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // 判断是否实现了PriorityOrdered 优先级最高
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { // 判断是否实现了Ordered  优先级其次
            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);
    
    beanFactory.clearMetadataCache();
}

invokeBeanDefinitionRegistryPostProcessors执行了三次，执行currentRegistryProcessors变量中装载的BeanDefinitionRegistryPostProcessor，第一次执行currentRegistryProcessors中只有解析配置类的后置处理器ConfigurationClassPostProcessor，这里调用的beanFactory.getBean，将会解析出系统中通过配置类配置的扫描包，扫描出所有Bean，第二次执行currentRegistryProcessors为空，为空的前提是扫描出的Bean中无BeanDefinitionRegistryPostProcessor，第三次执行和第二次执行一样。如下所示若定义一个自定义的BeanDefinitionRegistryPostProcessor，由于这里没有实现PriorityOrdered和Ordered接口，则第三次执行时会执行该BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法。

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        RootBeanDefinition car = (RootBeanDefinition) beanFactory.getBeanDefinition("car");
    }
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        RootBeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClass(Tank.class);
        registry.registerBeanDefinition("car", beanDefinition);
    }
}

当BeanDefinitionRegistryPostProcessor处理完毕后会将其与registryProcessors合并，因为一开始只会执行BeanDefinitionRegistryPostProcessor独有方法，不会执行其父类方法，即BeanFactoryProcessor接口中的方法，故需要把这些后置处理器放入一个集合中，后续统一执行BeanFactoryProcessor接口中的方法。

可理解为执行currentRegistryProcessors中的ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry方法，这就是Spring设计思想的体现了，在这里体现的就是其中的热插拔，插件化开发的思想。Spring中很多东西都是交给插件去处理的，该后置处理器就相当于一个插件。

当通过invokeBeanDefinitionRegistryPostProcessors方法执行过ConfigurationClassPostProcessor后，后续就能获取到项目中自定义的打上@Component注解的后置处理器。

private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
   for (BeanFactoryPostProcessor postProcessor : postProcessors) {
      postProcessor.postProcessBeanFactory(beanFactory);
   }
}
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        int factoryId = System.identityHashCode(beanFactory);
        if (this.factoriesPostProcessed.contains(factoryId)) {
            throw new IllegalStateException(
                "postProcessBeanFactory already called on this post-processor against " + beanFactory);
        }
        this.factoriesPostProcessed.add(factoryId);
        if (!this.registriesPostProcessed.contains(factoryId)) {
            processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
        }
        // 使用cglib对配置类进行代理，因为@Bean方法到时候要进行创建Bean的实例
        enhanceConfigurationClasses(beanFactory);
        beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
    }
    public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
        Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
        for (String beanName : beanFactory.getBeanDefinitionNames()) {
            BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
            // 只有full版配置类才会创建cglib代理
            if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
                if (!(beanDef instanceof AbstractBeanDefinition)) {
                    throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" + beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
                }
                configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
            }
        }
        if (configBeanDefs.isEmpty()) {
            return; // nothing to enhance -> return immediately
        }
        ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
        for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
            AbstractBeanDefinition beanDef = entry.getValue();
            // If a @Configuration class gets proxied, always proxy the target class
            beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
            try {
                // Set enhanced subclass of the user-specified bean class
                Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);
                if (configClass != null) {
                    Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
                    if (configClass != enhancedClass) {
                        // 重新修改Bean定义的Class，在创建Bean的实例时将会实例cglib的类
                        beanDef.setBeanClass(enhancedClass);
                    }
                }
            }
            catch (Throwable ex) {
            }
        }
    }
}

只有full版配置类才会创建cglib代理，虽然在指定配置时不标注@Configuration也行，所以加不加注解的区别就在这里，当在配置类中一个@Bean使用方法的方式引用另一个Bean若不加注解就会重复加载Bean，若加了@Configuration则会在这里创建cglib代理，当调用@Bean方法时会先检测容器中是否存在。

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessorNew");
    }
}

同样invokeBeanFactoryPostProcessors方法会执行自定义的BeanFactoryPostProcessor的postProcessBeanFactory方法。

registerBeanPostProcessors

给容器中注册bean的后置处理器，bean的后置处理器在bean的各个生命周期中都会进行调用。

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 去容器中获取所有的BeanPostProcessor 的名称(还是bean定义)
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    // 之前refresh-->prepareBeanFactory()中注册的postProcessorNames.length
    // bean后置处理器个数beanFactory.getBeanPostProcessorCount()成品个数 beanFactory工厂中bean定义的个数+1在后面又马上注册了BeanPostProcessorChecker的后置处理器
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    //按照BeanPostProcessor实现的优先级接口来分离我们的后置处理器
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();// 保存实现了priorityOrdered接口的
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>(); // 系统内部的
    List<String> orderedPostProcessorNames = new ArrayList<>(); // 实现了ordered接口的
    List<String> nonOrderedPostProcessorNames = new ArrayList<>(); // 没有优先级的
    for (String ppName : postProcessorNames) { // 循环bean定义(BeanPostProcessor)
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { //若实现了PriorityOrdered接口的
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); // 显示的调用getBean流程创建bean的后置处理器
            priorityOrderedPostProcessors.add(pp); // 加入到集合中
            if (pp instanceof MergedBeanDefinitionPostProcessor) { // 判断是否实现了MergedBeanDefinitionPostProcessor
                internalPostProcessors.add(pp); // 加入到集合中
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { // 判断是否实现了Ordered
            orderedPostProcessorNames.add(ppName);
        } else { // 没有任何拍下接口的
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    // 把实现了priorityOrdered注册到容器中
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    // 处理实现Ordered的bean定义
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); //显示调用getBean方法
        orderedPostProcessors.add(pp); //加入到集合中
        if (pp instanceof MergedBeanDefinitionPostProcessor) { //判断是否实现了MergedBeanDefinitionPostProcessor
            internalPostProcessors.add(pp); //加入到集合中
        }
    }
    //排序并且注册我们实现了Order接口的后置处理器
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    //注册我们普通的没有实现任何排序接口的
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    //注册MergedBeanDefinitionPostProcessor类型的后置处理器bean合并后的处理，Autowired注解正是通过此方法实现诸如类型的预解析。
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
    //注册ApplicationListenerDetector 应用监听器探测器的后置处理器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}