全面开战系列之Spring源码---Bean实例化流程(四)

 

文章目录

• 系列文章目录
• 前言
• 一、FactoryBean
• 二、实例化Bean过程  
•        2.1.缓存
•        2.2.实例化bean
•        2.3.属性装配
•        2.4.回调接口
• 三、总结         

 

---

系列文章目录

•  全面开战系列之Spring源码---Spring概述(一）

• 全面开战系列之Spring源码---IOC启动流程(二)

• 全面开战系列之Spring源码---IOC实例化前的准备工作(三)

 

前言

本篇主要分析bean实例化的大体过程，主要分为缓存，构造函数实例化bean，属性装配，回调生命周期接口这4个模块。对于各个模块的具体细节实现，在之后的章节会详细分析。本篇先把各个流程串起来，然后各个击破！

 

一、FactoryBean

spring提供了FactoryBean接口实现自定义实例化bean功能。来看看FactoryBean接口

public interface FactoryBean {
   @Nullable
   T getObject() throws Exception;

   @Nullable
   Class getObjectType();

   default boolean isSingleton() {
      return true;
   }

}

重写getObject()方法即可自定义 生成bean。

如何获取由FactoryBean的getObject()方法生成的bean?  

ApplicationContext.getBean(name); 其中这个 name 必须以 "&"开头，如 &student(之后看源码就知道)。

如何获取FactoryBean本身实现类？

ApplicationContext.getBean(name); 其中这个name 就是实现类的类名，无需特殊处理

接下来分析源码

在之前的文章，有分析到AbstractApplicationContext中的 refresh()，这个方法包含了IOC的整个启动过程。其中，有一个 finishBeanFactoryInitialization(),这个方法负责bean实例化过程。

AbstractApplicationContext.finishBeanFactoryInitialization()

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // Initialize conversion service for this context.
   //这种类型的bean最实用的场景就是用来将前端传过来的参数和后端的controller方法上的参数格式转换的时候使用
   // 如 String 转 Date
   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));
   }

   // Register a default embedded value resolver if no bean post-processor
   // (such as a PropertyPlaceholderConfigurer bean) registered any before:
   // at this point, primarily for resolution in annotation attribute values.
   //利用EmbeddedValueResolver可以很方便的实现读取配置文件的属性:${}
   if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
   }

   // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
   //先初始化 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);

   // Allow for caching all bean definition metadata, not expecting further changes.
   //冻结所有的bean定义，即已注册的bean定义将不会被修改或后处理
   beanFactory.freezeConfiguration();

   // Instantiate all remaining (non-lazy-init) singletons.
   //初始化
   beanFactory.preInstantiateSingletons();
}

关注最后一行代码,beanFactory.preInstantiateSingletons(); 即DefaultListableBeanFactory.preInstantiateSingletons()

public void preInstantiateSingletons() throws BeansException {
   if (logger.isTraceEnabled()) {
      logger.trace("Pre-instantiating singletons in " + this);
   }

   // Iterate over a copy to allow for init methods which in turn register new bean definitions.
   // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
   // this.beanDefinitionNames 保存了所有的 beanNames
   List beanNames = new ArrayList<>(this.beanDefinitionNames);

   // Trigger initialization of all non-lazy singleton beans...，遍历BeanName,实例化
   for (String beanName : beanNames) {
      // 该方法的merge是指如果bean类继承有父类，那么就将它所有的父类的bd融合成一个RootBeanDefinition返回
      // 合并父 Bean 中的配置，主要是  中的 parent属性
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      //非抽象类，单例，非懒加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         if (isFactoryBean(beanName)) {//如果是factoryBean,则需要加& 才能使用getBean
            //在 beanName 前面加上“&” 符号
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
               final FactoryBean factory = (FactoryBean) bean;
               boolean isEagerInit;
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                  isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                              ((SmartFactoryBean) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean) factory).isEagerInit());
               }
               if (isEagerInit) {
                  getBean(beanName);
               }
            }
         }
         else {  // 不是FactoryBean的直接使用此方法进行初始化
            getBean(beanName);
         }
      }
   }

   // Trigger post-initialization callback for all applicable beans...
   // 如果bean实现了 SmartInitializingSingleton 接口的，那么在这里得到回调
   for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
      if (singletonInstance instanceof SmartInitializingSingleton) {
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction