Spring容器的refresh()方法实现

1. prepareRefresh() 刷新前的预处理

1. initPropertySources() 初始化一些属性设置；子类自定义个性化的属性设置方法
2. getEnvironment().validateRequiredProperties(); 检验属性的合法等
3. earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>(); 保存容器的一些早期事件

2. obtainFreshBeanFactory(); 获取BeanFactory

1. refreshBeanFactory(); 刷新BeanFactory
   1. 创建一个this.beanFactory = new DefaultListableBeanFactory();
   2. 给beanFactory设置ID
2. getBeanFactory(); 返回刚刚GenericApplicationContext创建的beanFactory对象
3. 将创建的DefaultListableBeanFactory返回

3. prepareBeanFactory(beanFactory); beanFactory的预处理准备工作（一般都是一些设置）

1. 设置BeanFactory的类加载器 支持表达式解析器。。
2. 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
3. 设置忽略的自动装配的接口 EnvironmentAware EmbeddedValueResolverAware ResourceLoaderAware 不能通过自动注入
4. 注册可以解析的自动装配； 我们可以在任何组件中使用自动注入 BeanFactory ResourceLoader ApplicationContext ApplicationEventPublisher
5. 添加部分BeanPostProcessor【ApplicationListenerDetector】
6. 添加编译时的AspectJ支持
7. 给BeanFactory中注册一些能用的组件； environment【ConfigurableEnvironment】 systemProperties【Map】 systemEnvironment【Map】

4. postProcessBeanFactory(beanFactory); BeanFactory准备工作完成后进行的后置处理工作

1. 子类通过重写这个方法来在beanFactory创建并准备工作完成以后做进一步的设置

---

以上是BeanFactory的创建及预准备工作

5. invokeBeanFactoryPostProcessors(beanFactory); BeanFactory的后置处理器，在BeanFactory标准初始化之后BeanFactoryPostProcessor

• BeanFactoryPostProcessor
• BeanDefinitionRegistryPostProcessor

1. 先执行BeanDefinitionRegistryPostProcessor的方法
   1. 获取所有的BeanDefinitionRegistryPostProcessor
   2. 看先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor postProcess.postProcessBeanDefinitionRegistry(registry);
   3. 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor postProcess.postProcessBeanDefinitionRegistry(registry);
   4. 最后执行没有实现任何优先级或者顺序接口的BeanDefinitionRegistryPostProcessor postProcess.postProcessBeanDefinitionRegistry(registry);
2. 再执行BeanFactoryPostProcessor的方法
   1. 获取所有的BeanFactoryPostProcessor
   2. 看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor postProcessor.postProcessBeanFactory(beanFactory);
   3. 再执行实现了Ordered顺序接口的BeanFactoryPostProcessor postProcessor.postProcessBeanFactory(beanFactory);
   4. 最后执行没有实现任何优先级或者顺序接口的BeanFactoryPostProcessor postProcessor.postProcessBeanFactory(beanFactory);

6. registerBeanPostProcessors(beanFactory); 注册BeanPostProcessor(Bean的后置处理器)【intercept bean creation.】

• BeanPostProcessor 不同类型的beanPostProcessor在创建bean后的执行时机是不一样的
• DestructionAwareBeanPostProcessor
• InstantiationAwareBeanPostProcessor
• SmartInstantiationAwareBeanPostProcessor
• MergedBeanDefinitionPostProcessor 【放入internalPostProcessors】

1. 获取所有的BeanPostProcessor; 后置处理器默认都可以通过PriorityOrdered，Ordered指定优先级
2. 先注册PriorityOrdered优先级接口的BeanPostProcessor（把每个BeanPostProcessor添加到BeanFactory中） beanFactory.addBeanPostProcessor(beanPostProcessor);
3. 再注册Ordered接口的
4. 注册没有实现任何接口的
5. 最后注册MergedBeanDefinitionPostProcessor
6. 注册一个ApplicationListenerDetector, 来在bean创建完成检查是否是ApplicationListener。如果是addApplicationListener applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7. initMessageSource(); 初始化MessageSource组件

• 做国际化功能
• 消息绑定
• 消息解析

1. 获取beanFactory
2. 看容器中是否有id为messageSource的组件。 如果有赋值给this.messageSource，没有创建一个DelegatingMessageSource
3. 把创建好的MessageSource注册到容器中 beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);

8. initApplicationEventMulticaster(); 初始化事件派发器

1. 获取beanFactory
2. 从beanFactory中获取applicationEventMulticaster
3. 如果上一步没配置;创建一个SimpleApplicationEventMulticaster

9. onRefresh(); 留给子容器（子类）

1. 子类重写这个方法，在容器刷新的时候可以自定义逻辑 比如: springboot整合tomcat

10. registerListeners(); 给容器中所有的项目里面的ApplicationListener注册进来；

1. 从容器中拿到所有的ApplicationListener
2. 将每个监听器添加到事件派发器中 getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3. 如果存在earlyApplicationEvents 派发之前步骤产生的事件 getApplicationEventMulticaster().multicastEvent(earlyEvent);

11. finishBeanFactoryInitialization(beanFactory); 初始化所以剩下的单实例bean

1. beanFactory.preInstantiateSingletons(); 初始化所以剩下的单实例bean
2. 获取容器中的所有beanName，依次进行初始化和创建对象
3. 获取bean的定义信息RootBeanDefinition
4. bean不是抽象的，是单实例的，不是懒加载的

   • 判断是不是FactoryBean，是否实现FactoryBean

   • 不是工厂bean, 通过getBean(beanName)创建对象

     1. DefaultListableBeanFactory getBean(beanName);IOC.getBean()
     2. 调父类AbstractBeanFactory doGetBean(name, null, null, false);
     3. 先获取单例池中保存的单实例bean，如果能获取到说明这个bean之前被创建过
     4. 缓存中获取不到，开始创建流程
     5. 标记当前bean已经被创建 markBeanAsCreated(beanName);
     6. 获取当前bean的定义信息
     7. 获取当前bean依赖的其他bean;如果有按照getBean()把依赖的Bean先创建出来
     8. 启动单实例bean的创建：

     if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { return createBean(beanName, mbd, args);

      1. AbstractAutowireCapableBeanFactory createBean(beanName, mbd, args)；
      2. Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 让BeanPostProcessor先拦截创建代理对象
       执行【InstantiationAwareBeanPostProcessor】； 解析配置类会有使用
       先触发 postProcessBeforeInstantiation(beanClass, beanName);
       后执行 postProcessAfterInitialization(result, beanName);
      3. 如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象 调用4;
      4. Object beanInstance = doCreateBean(beanName, mbdToUse, args);
              1. 【创建bean实例】 createBeanInstance(beanName, mbd, args);
                 利用工厂方法或者构造器创建出对象
              2. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
                 调用MergedBeanDefinitionPostProcessors
                 bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
              3. 提前暴露一个对象
              4. 添加一个缓存
                 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
              5. 【给bean属性赋值】 populateBean(beanName, mbd, instanceWrapper);   
                  1. 拿到 InstantiationAwareBeanPostProcessor后置处理器
                      postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)
                  2. 拿到 InstantiationAwareBeanPostProcessor后置处理器
                      postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                  3. 应用bean属性的值； 为属性利用setter方法进行赋值
                      applyPropertyValues(beanName, mbd, bw, pvs);  
              6. 【bean初始化】initializeBean(beanName, exposedObject, mbd);
                  1. 【执行Aware接口方法】invokeAwareMethods(beanName, bean); 执行 xxxAwarexx方法
                      BeanNameAware  EnvironmentAware ImportAware BeanFactoryAware etc
                  2. 【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
                      @PostConstruct 
                      BeanPostProcessor.postProcessBeforeInitialization(result, beanName);  
                  3. 【执行】 invokeInitMethods(beanName, wrappedBean, mbd); 
                      1. 是否是InitializingBean接口的实现； 执行接口规定的初始化方法  
                         ((InitializingBean) bean).afterPropertiesSet();
                      2. 是否自定义初始化方法； xml 中配置  init-method的
                         invokeCustomInitMethod(beanName, bean, mbd);
                  4. 【执行后置处理器初始化之后】 applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
                      BeanPostProcessor.postProcessAfterInitialization(result, beanName); 
              7. registerDisposableBeanIfNecessary(beanName, bean, mbd); 注册bean的销毁方法
                  实现 DisposableBean接口的destroy()
      5. 将创建的bean添加的到缓存中 sharedInstance = getSingleton(beanName, () -> {})
          protected void addSingleton(String beanName, Object singletonObject) {
        		synchronized (this.singletonObjects) {
        			this.singletonObjects.put(beanName, singletonObject);
        			this.singletonFactories.remove(beanName);
        			this.earlySingletonObjects.remove(beanName);
        			this.registeredSingletons.add(beanName);
        		}
        	}
     

     9. 所有的bean都使用getBean创建完成以后 检查所有的bean是SmartInitializingSingleton接口的 @EventListener 如果是执行 afterSingletonsInstantiated();

12. finishRefresh(); 完成bean的初始化创建工作， IOC容器就创建完成

1. initLifecycleProcessor(); 初始化和生命周期有关的后置处理器； LifecycleProcessor 默认在容器中找是否有LifecycleProcessor类型的组件，没有创建默认的DefaultLifecycleProcessor。创建完成会加入的容器中 写一个LifecycleProcessor实现类，可以在BeanFactory刷新完成，关闭的时候调用 void onRefresh(); void onClose();
2. getLifecycleProcessor().onRefresh(); 拿到前面生命周期处理器（监听BeanFactory），回调onRefresh()
3. publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成事件
4. LiveBeansView.registerApplicationContext(this); Participate in LiveBeansView MBean, if active.

---

总结

1. Spring容器在启动的时候，先回保存所以注册进来的Bean的定义信息
   1. xml 注册bean; <bean>
   2. 注解注册bean 例如 @Component，@Bean，@Service
2. Spring容器会在何时的时机创建这些Bean
   1. 用到这个bean的时候，利用getBean创建bean,创建好以后保存在容器中
   2. 统一创建剩下所有的bean的时候，finishBeanFactoryInitialization(beanFactory)
3. 后置处理器： 每个bean创建完成，都会使用各种后置处理器进行处理来增强Bean的功能
   1. AutowiredAnnotationBeanPostProcessor： 处理自动注入
   2. AnnotationAwareAspectJAutoProxyCreator: AOP代理功能
4. 事件驱动
   1. ApplicationListener: 事件监听
   2. ApplicationEventMulticaster：事件派发器