首先，从一个简单案例说起

主配置类

  1. @Configuration
  2. public class MainConfig {
  4.     @Bean
  5.     public Person person() {
  6.         return new Person();
  7.     }
  8. }

测试类

  1. ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
  2. System.out.println(applicationContext.getBean("person"));

测试实体类

  1. public class Person {
  2. }

最主要的代码就是下面这句

  1. new AnnotationConfigApplicationContext(MainConfig.class);

那么，我们就看看这句话到底干了些什么事情

主要分为了以下的三步：

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

一、我们先看第一个: this()

主要分为两步，注册注解的扫描器，以及类路径的扫描器

  1. public AnnotationConfigApplicationContext() {
  2.     this.reader = new AnnotatedBeanDefinitionReader(this);
  3.     this.scanner = new ClassPathBeanDefinitionScanner(this);
  4. }

1.1 super() 调用父类的构造函数（主要工作，创建bean工厂，默认是DefaultListableBeanFactory）

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

1.2 new AnnotatedBeanDefinitionReader(this); 注册注解的扫描器

  1. # 主要调用流程
  2. AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); 
  4. registerAnnotationConfigProcessors(registry, null);
  5. # 最主要的工作，往容器中添加了一堆后置处理器，添加对一些技术 (JPA) 的支持
  1. # 主要往容器中添加了如下的几个类型的组件
  2. org.springframework.context.annotation.internalConfigurationAnnotationProcessor
  3. org.springframework.context.event.internalEventListenerFactory
  4. org.springframework.context.event.internalEventListenerProcessor
  5. org.springframework.context.annotation.internalAutowiredAnnotationProcessor
  6. org.springframework.context.annotation.internalCommonAnnotationProcessor
  7. org.springframework.context.annotation.internalRequiredAnnotationProcessor

1.3 new ClassPathBeanDefinitionScanner(this); 初始化类路径下的包扫描器

注册添加过滤规则，添加环境，以及资源的加载器
这里的userDefaultFilters，就是我们在 @ComponentScan(useDefaultFilters = false) 中指定的这个属性，用于让其看是否需要使用默认的过滤规则。
默认的扫描规则是，只要是@Component 就扫描进去

  1. public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
  2.                                       Environment environment, @Nullable ResourceLoader resourceLoader) {
  3.     Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
  4.     this.registry = registry;
  6.     if (useDefaultFilters) {
  7.         registerDefaultFilters();
  8.     }
  9.     setEnvironment(environment);
  10.     setResourceLoader(resourceLoader);
  11. }

第一步的流程就分析的差不多了，紧接着看第二步干了什么？

二、register(annotatedClasses);

  1. # 调用上一步的注解扫描器
  2. this.reader.register(annotatedClasses);
  3. # 循环所有传入的配置类，调用registerBean将配置类注册到容器中
  4. public void register(Class<?>... annotatedClasses) {
  5.     for (Class<?> annotatedClass : annotatedClasses) {
  6.         registerBean(annotatedClass);
  7.     }
  8. }

三、refresh(); 大名鼎鼎的refresh()，总共分为12步，且听下面一步步分析

  1. public void refresh() throws BeansException, IllegalStateException {
  2.         synchronized (this.startupShutdownMonitor) {
  3.             prepareRefresh();
  5.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  7.             prepareBeanFactory(beanFactory);
  9.             try {
  10.                 // Allows post-processing of the bean factory in context subclasses.
  11.                 postProcessBeanFactory(beanFactory);
  13.                 // Invoke factory processors registered as beans in the context.
  14.                 invokeBeanFactoryPostProcessors(beanFactory);
  16.                 // Register bean processors that intercept bean creation.
  17.                 registerBeanPostProcessors(beanFactory);
  19.                 // Initialize message source for this context.
  20.                 initMessageSource();
  22.                 // Initialize event multicaster for this context.
  23.                 initApplicationEventMulticaster();
  25.                 // Initialize other special beans in specific context subclasses.
  26.                 onRefresh();
  28.                 // Check for listener beans and register them.
  29.                 registerListeners();
  31.                 // Instantiate all remaining (non-lazy-init) singletons.
  32.                 finishBeanFactoryInitialization(beanFactory);
  34.                 finishRefresh();
  35.             }
  36.         }
  37.     }

3.1 prepareRefresh(); 准备刷新阶段

3.1.1 设置容器的一些状态

  1. this.closed.set(false);
  2. this.active.set(true);

3.1.2 初始化一些属性

  1. initPropertySources();
  2. getEnvironment().validateRequiredProperties();

3.1.3 初始化早期事件，早期对象的存放变量，用于存放ApplicationListener，ApplicationEvent

  1. if (this.earlyApplicationListeners == null) {
  2.     this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
  3. }
  4. else {
  5.     // Reset local application listeners to pre-refresh state.
  6.     this.applicationListeners.clear();
  7.     this.applicationListeners.addAll(this.earlyApplicationListeners);
  8. }
  10. // Allow for the collection of early ApplicationEvents,
  11. // to be published once the multicaster is available...
  12. this.earlyApplicationEvents = new LinkedHashSet<>();

3.2 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 获取刷新的Bean工厂

分为两步：
3.2.1 refreshBeanFactory(); 在 GenericApplicationContext 中进行实现，主要工作为，给bean工厂设置一个序列化id，并通过CAS设置refreshed为true，防止并发

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

3.2.2 getBeanFactory() 获取bean工厂 ，在 GenericApplicationContext 中实现，直接返回 在1.1 步中 初始化的 DefaultListableBeanFactory

3.3 prepareBeanFactory(beanFactory); 对bean工厂进行一些准备(设置bean工厂的类加载器，表达式解析器，后置处理器等等)

3.4 postProcessBeanFactory(beanFactory); 对bean工厂进行后置处理，进行一些扫尾工作。这边交由子类去实现，这边是个空方法。

3.5 invokeBeanFactoryPostProcessors(beanFactory); 调用bean工厂的后置处理器

  1. PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors())
  2. // 创建一个集合，用于保存需要处理的bean
  3. Set<String> processedBeans = new HashSet<>();
  4. // 如果 beanFactory 是 BeanDefinitionRegistry 类型的，很不巧，DefaultListableBeanFactory 就是这个类型的
  5. if (beanFactory instanceof BeanDefinitionRegistry) {
  6.     // 循环所有的后置处理器，这些后置处理器
  7.     for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
  8.         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
  9.             //区分出两种不同的PostProcessor
  10.         }
  11.     }
  12.     // 根据 PriorityOrdered，Ordered 或者没有标注任何注解的后置处理器，将其保存到不同的集合中
  13.     // 然后开始调用这些后置处理器，这个逻辑有点多，在下一步讲
  14.     invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry)
  16.     // 处理完 BeanDefinitionRegistryPostProcessor 这个类型的后置处理器之后，再处理非这个类型的，
  17.     // 也就是 BeanFactoryPostProcessor 这个类型的后置处理器
  18.     // 同样，根据 PriorityOrdered，Ordered 或者没有标注任何注解的后置处理器，保存到不同的集合
  19.     // 保存完成之后，分别调用这个后置处理器
  20.     invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
  21. }

以上就是3.5的逻辑步骤，下面再讲讲，BeanDefinitionRegistryPostProcessor 的 invoke 和 BeanFactoryPostProcessor 的invoke如何执行的
BeanDefinitionRegistryPostProcessor 的 invoke（invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry)）

  1. //循环所有的 BeanDefinitionRegistryPostProcessor，调用 postProcessBeanDefinitionRegistry方法，
  2. // 实现了 BeanDefinitionRegistryPostProcessor 的后置处理器，可以在对 beanDefinition 进行一些操作，
  3. // 比如修改bean的Class，修改bean初始化调用时的构造函数等等等，（即可以实现偷天换日！）
  4. for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
  5.     postProcessor.postProcessBeanDefinitionRegistry(registry);
  6. }
  7. // 默认在Spring中呢，有 ConfigurationClassPostProcessor 这么一个后置处理器，实现了这个接口
  8. // 那么就会调用到这个类的 postProcessBeanDefinitionRegistry方法
  9. // 在这个类中，真正的逻辑都在这个方法中，这个方法就开始真正的解析beanDefinition了
  10. processConfigBeanDefinitions(registry); 
  11. // 1. 获取现在所有的beanDefinition，开始循环
  12. registry.getBeanDefinitionNames()
  13. // 如果这个类有@Configuration注解的话
  14. ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)
  15. // 将配置类保存起来
  16. configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
  17. // 将bean名称的生成器，保存到这个类的属性中
  18. this.componentScanBeanNameGenerator = generator;
  19. //设置@Import导入进来的bean的名称生成器
  20. this.importBeanNameGenerator = generator;
  21. // 创建一个 @Configuration 配置类的解析器
  22. ConfigurationClassParser parser = new ConfigurationClassParser(
  23.                 this.metadataReaderFactory, this.problemReporter, this.environment,
  24.                 this.resourceLoader, this.componentScanBeanNameGenerator, registry);
  25. // 开始进行配置类的解析
  26. parser.parse(candidates)
  27. //parser.parse() 子流程
  28.     // 内部再调用parse
  29.     parse();
  30.     // 处理 配置类
  31.     processConfigurationClass(new ConfigurationClass(reader, beanName))
  32.     // 真正的解析逻辑
  33.     doProcessConfigurationClass(configClass, sourceClass)
  34.     // PropertySources 注解的 bean
  35.     processPropertySource(propertySource)
  36.     // ComponentScans / ComponentScan 注解的 bean
  37.     // 调用包扫描器进行扫描
  38.     this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName())
  39.     // 处理 @Import 进来的
  40.     processImports(configClass, sourceClass, getImports(sourceClass), true);
  41.     // 处理 ImportResource
  42.     configClass.addImportedResource(resolvedResource, readerClass);
  43.     // 处理 @Bean
  44.     Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
  46. // 把解析出来的 @Bean @Import 都给注册到容器中了
  47. this.reader.loadBeanDefinitions(configClasses)
  48. // loadBeanDefinitions 子流程
  49.     loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator)
  50.     // 判断这个类是否是Import进来的
  51.     if (configClass.isImported()) {
  52.         registerBeanDefinitionForImportedConfigurationClass(configClass);
  53.     }
  54.     // 通过 @Configuration + @Bean进来的
  55.     for (BeanMethod beanMethod : configClass.getBeanMethods()) {
  56.         loadBeanDefinitionsForBeanMethod(beanMethod);
  57.     }
  58.     // 通过 @ImportResources 进来的
  59.     loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
  60.     // 通过 某个类实现了 ImportBeanDefinitionRegistrar 导入进来的 
  61.     loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
  62. //loadBeanDefinitions 结束

BeanFactoryPostProcessor 的 invoke（ invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory) ）

  1. // 循环所有后置处理器，调用 postProcessBeanFactory
  2. postProcessor.postProcessBeanFactory(beanFactory);
  3. // 假设自己实现了一个 BeanFactoryPostProcessor ，在这步中，就调用 postProcessBeanFactory方法了

3.6registerBeanPostProcessors(beanFactory) 注册 bean的后置处理器

  1. PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
  2. // 获取所有的 BeanPostProcessor类型的
  3. beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
  4. // 根据 PriorityOrdered，Ordered，和没有注解三种的后置处理器，分别注册
  5. registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

3.7 initMessageSource()

  1. // 判断容器中是否包含名称为 messageSource 的bean
  2. beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)
  3. // 没有的话，创建一个，将其注册到容器中
  4. new DelegatingMessageSource();
  5. beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

3.8 initApplicationEventMulticaster(); 创建事件的多播器

  1. // 判断容器中，是否包含 名称为 applicationEventMulticaster 的bean
  2. beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)
  3. // 如果有，取出来赋值给属性 applicationEventMulticaster
  4. // 如果没有，创建一个 SimpleApplicationEventMulticaster 赋值给 applicationEventMulticaster，并注册到容器中
  5. this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  6. beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);

3.9 onRefresh() 注解版的ApplicationContext 是个空方法，交由子类去实现，在SpringBoot中通过这个方法来启动tomcat

3.10 registerListeners()

  1. // 取出那些早期的 ApplicationListener
  2. getApplicationListeners();
  3. // 注册到多播器中
  4. getApplicationEventMulticaster().addApplicationListener(listener);
  5. // 获取所有的 ApplicationListener 类型的bean
  6. getBeanNamesForType(ApplicationListener.class, true, false)
  7. // 注册到多播器中
  8. getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName)
  9. // 取出所有的早期时间，调用多播器 播一下
  10. getApplicationEventMulticaster().multicastEvent(earlyEvent)

3.11 finishBeanFactoryInitialization(beanFactory)

  1. beanFactory.preInstantiateSingletons();
  2. // 取出所有的bean定义
  3. for (String beanName : beanNames) {
  4.     // 根据beanName 获取beanDefinition 
  5.     getMergedLocalBeanDefinition(beanName);
  6.     // 判断 bean定义
  7.     if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  8.         // 如果不是抽象的 且 是单例的 且 不是懒加载的 
  9.         if (isFactoryBean(beanName)) {
  10.             //如果是 工厂bean，加上 FactoryBean 的特有前缀 & 去进行bean的创建
  11.             getBean(FACTORY_BEAN_PREFIX + beanName)
  12.             // 然后再去通过getBean 去拿真正的bean
  13.             // 实际，会调用到FactoryBean 的 getObject方法
  14.             getBean(beanName);
  15.         }else {
  16.             //不是工厂bean，直接走getBean的流程
  17.             getBean();
  18.         }
  19.     }
  20. }

3.12 finishRefresh();

  1. // 初始化 生命周期 处理器
  2. initLifecycleProcessor();
  3. // 调用LifeCycle 的 onRefresh 方法
  4. getLifecycleProcessor().onRefresh();
  5. // 发布一个容器已经刷新完成的事件，通知观察者
  6. publishEvent(new ContextRefreshedEvent(this))