spring源码---IOC:refresh()总结

最新推荐文章于 2022-07-14 19:36:18 发布

w-小菜

最新推荐文章于 2022-07-14 19:36:18 发布

阅读量248

点赞数

分类专栏： spring

本文链接：https://blog.csdn.net/W1427259949/article/details/108018629

版权

spring 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

二，obtainFreshBeanFactory()

该过程用于xml方式，解析Bean,获取beanDefinition,该过程在xml方式注册bean里面详细讲述了，请回看。

三，prepareBeanFactory(beanFactory)

BeanFactory的预准备工作(BeanFactory进行一些设置);

prepareBeanFactory()代码内容很多，总结如下

　　1)、设置BeanFactory的类加载器、支持表达式解析器...

　　2)、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】

　　3)、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx;

　　4)、注册可以解析的自动装配;我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext

　　5)、添加BeanPostProcessor【ApplicationListenerDetector】

　　6)、添加编译时的AspectJ;

　　7)、给BeanFactory中注册一些能用的组件;

　　environment【ConfigurableEnvironment】、

　　systemProperties【Map】、

　　systemEnvironment【Map】

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // Tell the internal bean factory to use the context's class loader etc.
   beanFactory.setBeanClassLoader(getClassLoader());
  ....    各种beanFactory的属性设置

   // Register early post-processor for detecting inner beans as ApplicationListeners.
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // Detect a LoadTimeWeaver and prepare for weaving, if found.
   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      // Set a temporary ClassLoader for type matching.
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }

   // Register default environment beans.
   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());
   }
}

后面的，都在做一些设置属性处理，我们这里就不再一点一点的看了，我们直接来到重点，第十一步：初始化非懒加载单例bean。

//4. 为容器的某些子类指定特殊的post事件 处理器--【不重要】
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
//6.为 BeanFactory 注册post事件处理器
registerBeanPostProcessors(beanFactory);
// 7. 初始化信息源，和国际化相关
initMessageSource();
// 8. 初始化容器事件 传播器
initApplicationEventMulticaster();
// 9. 调用子类的某些特殊bean 的初始化方法 【空的】
onRefresh();
// 10. 为事件传播器注册事件 监听器
registerListeners();

五，invokeBeanFactoryPostProcessor()

在annotation注解使用的方式用，该步骤里面会调用Configuration...PostProcessor类进行处理配置类，然后获得BeanDefinition，该过程在前面的解析配置类中已经详细说明，请回看

六，registerBeanPostProcessor()

对于后置处理器，在xml方式中，是不存在那么多问题的，但是注解方式，就需要类来处理bean中的注解，所以需要在Bean初始化，或者实例化的时候，进行前后的操作，相对于xml来说，就显得有点复杂，而xml的复杂是体现在xml文件的解析地方，所以xml和annotation的解析，都是很麻烦的！

该步骤功能：实际上就是创建BeanPostProcessor对象，保存在容器中，创建对象，自然就是getBean()，创建之前它已经存在于beanDefinitionMap中，

下面四个是注册之前的BeanPostProcessor，重点是ConfigurationClassPostProcessor处理器，用来处理配置类，现在我们需要处理aop的通知类，还有@Autowired等等注解，所以需要增加新的PostProcessor。

第六步源码：

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

调用后置处理器代理类进行注册操作：

public static void registerBeanPostProcessors(...) {
   //1.从beanDefinition中获取 全部后置处理器，这里就进行了分类获取
   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    //获得总 PostProcessor数量
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    //准备四个容器存放 PostProcessor，这里体现了三个级别，和一个内部类，但是很有意思的一个地方是，普通bean和排序bean只存放了 beanName，而另外两个存放了实例！
   List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
   List<String> orderedPostProcessorNames = new ArrayList<>();
   List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    //2.遍历开始解析，分类存放
   for (String ppName : postProcessorNames) {
      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { //优先级别
         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); // getBean  实例化
         priorityOrderedPostProcessors.add(pp); //添加
         if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
         }
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { //普通排序级别
         orderedPostProcessorNames.add(ppName);
      }
      else { //最普通
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   //3.注册   
    //3.1 注册最优先的
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

     //3.2 注册排序bean 先实例化
   List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
   for (String ppName : orderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      orderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   //3.3 注册普通bean，先实例化
   List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
   for (String ppName : nonOrderedPostProcessorNames) {
      ....
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

   //3.4 注册内部bean，
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

  //最后，直接New一个处理器 放入 监听探测器
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

其实整体内容不复杂，上面很多都是重复操作，

1.获取beanPostProcessor name列表：根据类型获取bean，这个在之前使用过，注意传入的第一个参数Type，就是实现了这个接口的类，会被查找到。

public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
   if (!isConfigurationFrozen() || type == null || !allowEagerInit) { //不正常情况
      return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
   }
   Map<Class<?>, String[]> cache =
         (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
   String[] resolvedBeanNames = cache.get(type); //缓存中直接获取
   if (resolvedBeanNames != null) {
      return resolvedBeanNames;
   } //缓存未命中
   resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
   if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {
      cache.put(type, resolvedBeanNames);
   }
   return resolvedBeanNames;
}

2.注册registerBeanProcessor()

private static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
   for (BeanPostProcessor postProcessor : postProcessors) {
      beanFactory.addBeanPostProcessor(postProcessor);
   }
}

传入的是列表，自然需要遍历添加，添加逻辑比较简单，就是调用DefaultBeanFactory的registerBeanPostProcessor()

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
   this.beanPostProcessors.remove(beanPostProcessor);
   if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
      this.hasInstantiationAwareBeanPostProcessors = true;
   }
   if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
      this.hasDestructionAwareBeanPostProcessors = true;
   }
   this.beanPostProcessors.add(beanPostProcessor);
}

3.getBean()实例化过程，这个待后面分析

注册完毕之后，测试demo中解析出来的beanPostProccesor的效果：

可见，优先级别的是三个autowired,required,common。而解析aop通知类的，是排序bean。

执行完毕后的 beanPostProcessor:

这里发现了ApplicationListenerDetector本来是在第三位的，在第六步注册过程中，删除了之后又重新放进入，所以跑到了第七位，由于是直接new的，所以下面的alreadyCreated中不存在。

现在已经创建的bean，该步骤创建了下面四个bean，第一个bean是用来解析配置类的。

总结：

6、registerBeanPostProcessors(beanFactory)：注册bean的后置处理器来方便拦截创建bean的创建

1）先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

2）给容器中加别的BeanPostProcessor

3）优先注册实现了PriorityOrdered接口的BeanPostProcessor

4）再给容器中注册实现了Ordered接口的BeanPostProcessor

5）注册没实现优先级接口的BeanPostProcessor

6）注册BeanPostProcessor。实际上就是创建BeanPostProcessor对象，保存在容器中

创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】

1）创建Bean实例

2）populateBean(beanName,mbd,instanceWrapper);给bean的各种属性赋值

3）initializeBean：初始化bean

1）invokeAwareMethods():处理Aware接口的方法回调

2）applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization()

3）invokeInitMethods()：执行自定义的初始化方法

4）applyBeanPostProcessorsAfterInitialization()：执行后置处理器的postProcessAfterInitialization()

4）BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功：–》aspectJAdvisorsBuilder

7）把BeanPostProcessor注册到BeanFactory中：beanFactory.addBeanPostProcessor(postProcessor);

十一、finishBeanFactoryInitialization(beanFactory)

初始化所有剩下的单实例bean;

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   //1.初始化此上下文的转换服务
   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
      beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
   }
   //2.如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注册属性值的解析
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }
   //3. 初始化loadTimeWeaverAware bean实例对象
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

   // Stop using the temporary ClassLoader for type matching.
   beanFactory.setTempClassLoader(null);
   //4. 冻结所有bean定义，注册bean定义不会被修改或进一步处理，因为马上要创建bean实例对象
   beanFactory.freezeConfiguration();
   //5. 实例化所有剩余（非懒加载）单例对象
   beanFactory.preInstantiateSingletons();
}

重点方法是第五个，实例化bean，它的代码位于DefaultListableBeanFactory类中，也就是保存beanDefinition的类

public void preInstantiateSingletons() throws BeansException {
//获得所有名字
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
   //遍历BeanNames， 触发所以非懒加载单例bean 的初始化
   for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    //条件 判断
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            //工厂bean，处理稍微复杂一点，我们直接看下面的普通bean
         if (isFactoryBean(beanName)) {
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) { //是否是FactoryBean
               final FactoryBean<?> factory = (FactoryBean<?>) bean;
               boolean isEagerInit; //判断这个factoryBean 是否需要急切的初始化
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                  isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                              ((SmartFactoryBean<?>) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean<?>) factory).isEagerInit());
               }
               if (isEagerInit) {
                  getBean(beanName);
               }
            }
         }
         else { //普通bean
            getBean(beanName);
         }
      }
   }

   // Trigger post-initialization callback for all applicable beans...
    //回调 初始化后的方法
   ...
}

该方法总结如下：

1)、获取容器中的所有Bean，依次进行初始化和创建对象

2)、获取Bean的定义信息;RootBeanDefinition

3)、Bean不是抽象的，是单实例的，是懒加载;

　1)、判断是否是FactoryBean;是否是实现FactoryBean接口的Bean;

　2)、不是工厂Bean。利用getBean(beanName);创建对象

0、getBean(beanName); ioc.getBean();

也就是分为FactoryBean和普通Bean，对于普通的Bean,调用getBean()方法，位于AbstractBeanFactory类中（父类）

public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

在这里，doGetBean()方法，就是我们自动注入，也就是第二章DI中涉及到的内容了，这里我们就不继续展开了，我们可以直接看下面的getBean()方法的追踪。

十二、finishRefresh()

完成BeanFactory的初始化创建工作;IOC容器就创建完成;

protected void finishRefresh() {
   // Clear context-level resource caches (such as ASM metadata from scanning).
   clearResourceCaches();
   // 初始化和生命周期有关的后置处理器
   initLifecycleProcessor();
   // 拿到前面定义的生命周期处理器
   getLifecycleProcessor().onRefresh();
   // Publish the final event.发布容器刷新完成事件
   publishEvent(new ContextRefreshedEvent(this));
   // Participate in LiveBeansView MBean, if active.
   LiveBeansView.registerApplicationContext(this);
}

参考链接：https://www.cnblogs.com/gnz49/p/11399606.html（refresh()流程，总结很到位）