Spring IOC BeanFactory 源码分析

IOC 概念

• BeanFactory 。基础类型IoC容器，提供完整的IoC服务支持。
• ApplicationContext 。 ApplicationContext 在 BeanFactory 的基础上构建，是相对比较高级的容器实现，除了拥有 BeanFactory 的所有支持， ApplicationContext 还提供了其他高级特性，比如事件发布、国际化信息支持等

本篇只讲BeanFactory

IOC 容器 BeanFactory

这里不采用xml方式，而是手动注册BeanDefinition，更加清晰 Bean 的构建过程，略过繁琐的xml解析过程。

public static void main(String[] args) {
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

    RootBeanDefinition userDefinition = new RootBeanDefinition(UserServiceImpl.class);
    RootBeanDefinition accountDefinition = new RootBeanDefinition(AccountServiceImpl.class);
    RootBeanDefinition integralDefinition = new RootBeanDefinition(IntegralServiceImpl.class);

    // 注册BeanDefinition
    beanFactory.registerBeanDefinition("userService", userDefinition);
    beanFactory.registerBeanDefinition("accountService", accountDefinition);
    beanFactory.registerBeanDefinition("integralDefinition", integralDefinition);

    // 1.构造方法注入方式
    ConstructorArgumentValues argValues = new ConstructorArgumentValues();
    argValues.addIndexedArgumentValue(0, integralDefinition);
    userDefinition.setConstructorArgumentValues(argValues);

    //2.setter方法注入方式
    MutablePropertyValues propertyValues = new MutablePropertyValues();
    propertyValues.addPropertyValue("accountService", new RuntimeBeanReference("accountService"));
    userDefinition.setPropertyValues(propertyValues);

    UserService userService = beanFactory.getBean("userService", UserService.class);
    System.out.println(userService.getName());
    System.out.println(userService.getMoney());
    System.out.println(userService.getIntegral());
}

注册BeanDefinition

// 1、校验
// 2、检测是否已经通过其他方式注册过，如果是，则判断是否可以覆盖等等。
// 3、已经开始创建bean，加锁
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);

添加属性依赖

BeanDefinition 中设置依赖

• 构造方法注入

• setter方法注入

  需要提供setter方法

如下

public UserServiceImpl(IntegralService integralService) {
    this.integralService = integralService;
}
public void setAccountService(AccountService accountService) {
    this.accountService = accountService;
}

创建获取bean

因为 BeanFactory 采用延迟加载的机制，bean 不会随着容器的初始化而初始化，而是在获取 bean 的时候去容器和父容器中查找，若找不到，便会查找相应的 BeanDefination ，并构建 bean。

AbstractBeanFactory#doGetBean

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    // name可能是别名或者是FactoryBean名字，获取真实bean名字
   final String beanName = transformedBeanName(name);
   Object bean;

   // 查找已经注册的bean，这个getSingleton方法是解决循环依赖的关键点。
   Object sharedInstance = getSingleton(beanName);
   if (sharedInstance != null && args == null) {
       // 根据获取的bean是否是FactoryBean，去直接返回还是调用FactoryBean#getObject
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }

   else {
      // 当前bean是 Prototype 并且正在创建，说明循环引用，报错
      // 这里的逻辑是 BeanFactory 创建bean的过程中都会将beanName放在一个集合中（Prototype型是放在ThreadLocal中），完成后会移掉，创建bean的过程中，若是发现集合中存在当前正在创建的bean，则说明该bean创建的过程中，间接引用到自身，构成循环引用。
      if (isPrototypeCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
      }

      // bean definition 不在自己中，且parentBeanFactory存在，则在parentBeanFactory中查找
      BeanFactory parentBeanFactory = getParentBeanFactory();
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
         // 调用parentBeanFactory的getBean方法，逻辑一样
          ...
      }

      if (!typeCheckOnly) {
         markBeanAsCreated(beanName);
      }

      try {
          // 像xml配置中可以设置继承，在这里合并BeanDefinition，
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);

         // 确保初始化当前bean所依赖的bean。
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
            ...
         }

         // 创建单例bean
         if (mbd.isSingleton()) {
             // 创建、获取单例，后面分析
            sharedInstance = getSingleton(beanName, () -> {
               try {
                  return createBean(beanName, mbd, args);
               }
               catch (BeansException ex) {
                  // 显式地从单例缓存中删除实例:它可能是由创建过程早期地放在那里的，以允许循环引用解析。并且删除收到对bean的临时引用的任何bean。
                  destroySingleton(beanName);
                  throw ex;
               }
            });
            // 根据获取的bean是否是FactoryBean，去直接返回还是调用FactoryBean#getObject
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }

          // 创建 Prototype bean
         else if (mbd.isPrototype()) {
            // prototype是每次获取时创建
            Object prototypeInstance = null;
            try {
               beforePrototypeCreation(beanName);
               prototypeInstance = createBean(beanName, mbd, args);
            }
            finally {
               afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
         }

          // 其他Scope，在BeanFactory中只有"singleton"和"prototype"两种，默认为"singleton"，其他的scope都是实现Scope接口，并通过 registerScope 方法注册，像RequestScope、SessionScope等，通过Scope的实现获取bean，是一种策略模式
         else {
            String scopeName = mbd.getScope();
            final Scope scope = this.scopes.get(scopeName);
            if (scope == null) {
               throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
            }
            try {
               Object scopedInstance = scope.get(beanName, () -> {
                  beforePrototypeCreation(beanName);
                  try {
                     return createBean(beanName, mbd, args);
                  }
                  finally {
                     afterPrototypeCreation(beanName);
                  }
               });
               bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
            }
            catch (IllegalStateException ex) {
               throw new BeanCreationException(...);
            }
         }
      }
      catch (BeansException ex) {
         cleanupAfterBeanCreationFailure(beanName);
         throw ex;
      }
   }

   // 检查所需的类型是否与实际bean实例的类型匹配。返回需要的类型
   if (requiredType != null && !requiredType.isInstance(bean)) {
      try {
         T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
         if (convertedBean == null) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
         }
         return convertedBean;
      }
      catch (TypeMismatchException ex) {
         // log
      }
   }
   return (T) bean;
}

DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)方法是解决bean循环依赖的关键点，方法代码

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

对于创建bean的过程单独分析。

创建单例

// 返回以给定名称已注册的(原始，可能为FactoryBean)单例对象，如果还没有注册，创建并且注册一个新的。
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            // 当前创建的bean正在销毁
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(...);
            }
            // singletonsCurrentlyInCreation集合添加当前正在构建的beanName，如果添加失败，则当前bean正在创建，则抛异常 -> 循环引用
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
                // 调用传入的工厂获取object
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch ...
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                // singletonsCurrentlyInCreation集合移除当前正在构建的beanName
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 新建的bean注册到容器中
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    // log
    RootBeanDefinition mbdToUse = mbd;

    // 直接获取class或者根据类名获取class
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // Prepare method overrides.
    try {
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(...);
    }

    try {
        // 让BeanPostProcessors有机会返回一个代理而不是目标bean实例。
        // InstantiationAwareBeanPostProcessor拦截bean的构建，返回值不为空，则直接返回
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(...);
    }

    try {
        // 真正构建bean
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        // A previously detected exception with proper bean creation context already,
        // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(...);
    }
}

AbstractAutowireCapableBeanFactory#doCreateBean方法

这个方法是真正创建bean的方法，流程如下

image

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {

   // 实例化bean，BeanFactory中以BeanWrapper包装bean以及bean的一些信息
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
      // 实例化bean对象
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   // 原始的bean实例
   final Object bean = instanceWrapper.getWrappedInstance();
   Class<?> beanType = instanceWrapper.getWrappedClass();
   if (beanType != NullBean.class) {
      mbd.resolvedTargetType = beanType;
   }

   // 允许PostProcessor修改合并的bean definition，MergedBeanDefinitionPostProcessor修改
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(...);
         }
         mbd.postProcessed = true;
      }
   }

   // 此时bean实例已经存在，但是对bean后续尚未完成，此时提前将bean暴露出来，是为了解决bean的循环引用
   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
         isSingletonCurrentlyInCreation(beanName));
   if (earlySingletonExposure) {
      // log
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
   }

   //初始化bean实例。
   Object exposedObject = bean;
   try {
      // 填充bean属性
      populateBean(beanName, mbd, instanceWrapper);
      // 1、检查Aware接口并注入依赖
      // 2、调用容器中BeanPostProcessor#postProcessBeforeInitialization方法
      // 3、是InitializingBean，则调用afterPropertiesSet方法
      // 4、有自定义initMethodName方法，则调用
      // 5、调用容器中BeanPostProcessor#postProcessAfterInitialization方法
      exposedObject = initializeBean(beanName, exposedObject, mbd);
   }
   catch (Throwable ex) {
       ...
   }

   // ...
   if (earlySingletonExposure) {
      Object earlySingletonReference = getSingleton(beanName, false);
      if (earlySingletonReference != null) {
         if (exposedObject == bean) {
            exposedObject = earlySingletonReference;
         }
         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            String[] dependentBeans = getDependentBeans(beanName);
            Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
            for (String dependentBean : dependentBeans) {
               if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                  actualDependentBeans.add(dependentBean);
               }
            }
            // 还是有依赖未解决，报错
            if (!actualDependentBeans.isEmpty()) {
               throw new BeanCurrentlyInCreationException(...);
            }
         }
      }
   }

   // 注册销毁回调接口
   try {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(...);
   }

   return exposedObject;
}

每一个步骤单独分析

1、实例化bean对象

AbstractAutowireCapableBeanFactory#createBeanInstance

// 为指定的bean创建一个新实例，使用适当的实例化策略：工厂方法、构造函数或简单实例化。 
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // 解析bean class
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());}

    // 有指定的Supplier获取bean
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }
    // 有配置指定的工厂方法
    if (mbd.getFactoryMethodName() != null)  {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // 检查是否已解析构造器
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            return instantiateBean(beanName, mbd);
        }
    }

    // SmartInstantiationAwareBeanPostProcessor拦截决定Constructors
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null ||
        mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
        // 构造函数autowire
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // 没有特殊处理:简单地使用无参数构造函数。
    return instantiateBean(beanName, mbd);
}

构造函数依赖时会去查找、构建依赖的bean，若此时循环引用则抛出异常，因为此时本bean的构建已开始但尚未实例化，bean容器中找不到本bean的实例，又不可能再去重新创建一个同类型的bean，所以容器无法解决此依赖。

2、设置Bean属性

AbstractAutowireCapableBeanFactory#populateBean

// 为bean实例填充在bean definition中定义的属性
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    ...

    // InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation 拦截bean属性的填充，在
    // doCreateBean之前InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
    // 拦截beande构造
    ...
        
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
        mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

        // 根据名称添加属性值。
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }

        // 根据类型添加属性值。
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }

        pvs = newPvs;
    }

    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

    if (hasInstAwareBpps || needsDepCheck) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        if (hasInstAwareBpps) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvs == null) {
                        return;
                    }
                }
            }
        }
        if (needsDepCheck) {
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }
    }

    if (pvs != null) {
        // 填充依赖属性
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

AbstractAutowireCapableBeanFactory#initializeBean方法包括包括了5个步骤：检查Aware接口并注入依赖、调用容器中BeanPostProcessor#postProcessBeforeInitialization方法、是InitializingBean，则调用afterPropertiesSet方法、有自定义initMethodName方法，则调用、调用容器中BeanPostProcessor#postProcessAfterInitialization方法

3、检查Aware接口并注入依赖

private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ClassLoader bcl = getBeanClassLoader();
         if (bcl != null) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
         }
      }
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}

这里检查bean是否实现BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口，如果有实现，则调用接口方法，设置相应的属性，Aware接口的其他子类并未在此设置，在 ApplicationContext 中有很多其他的Aware，一般通过给下一步的 BeanPostProcessors 添加 BeanPostProcessor ，然后由相应的 Processor 处理，伪码如下：

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Aware) {
            if (bean instanceof MyAware) {
                ((MyAware) bean).process();
            }
        }
        return null;
    }
}

4、BeanPostProcessor 前置处理

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

遍历beanPostProcessors，调用其前置处理方法。如果前置方法不返回空，则把返回结果设为当前bean，这里是Spring AOP 的实现点，只要在 beanProcessor 的前置方法返回传入的 bean 的代理对象，代理对象实现 bean 增强，那么后续使用将调用该 bean 增强后的方法，也就完成了切面的工作，同理 beanProcessor 的后置方法也能完成同样的工作。

5、调用init方法

// 所以属性设置完，开始初始化
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {

    // 实现了InitializingBean 接口，则调用afterPropertiesSet方法
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        ...
        ((InitializingBean) bean).afterPropertiesSet();
        ...
    }

    if (mbd != null && bean.getClass() != NullBean.class) {
        String initMethodName = mbd.getInitMethodName();
        // 有自定义InitMethodName，则反射调用，完成初始化
        if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

从InitializingBean的继承结构中可以看到，InitializingBean的实现类还是很多的，也就说明在 Spring 内部bean的初始化都在其afterPropertiesSet方法内。在看Spring MVC源码的时候，RequestMappingHandlerMapping在处理 Controller 请求路径映射时便是在afterPropertiesSet中处理的。

6、BeanPostProcessor 后置处理

后置处理和前置处理类似

7、注册销毁回调接口

如果bean实现了DisposableBean或者AutoCloseable接口，或者有自定义的destroyMethodName属性，或者有DestructionAwareBeanPostProcessor判断需要销毁bean，则将bean注册到相应的销毁集合中，在容器 shutdown 或者调用destroySingletons()，方法的时候将会销毁

//将给定的bean添加到工厂的可销毁bean列表中
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
    if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
        if (mbd.isSingleton()) {
            // 注册到销毁bean集合中
            registerDisposableBean(beanName,
                                   new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        }
        else {
            // 注册到自定义的scope中
            Scope scope = this.scopes.get(mbd.getScope());
            if (scope == null) {
                throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
            }
            scope.registerDestructionCallback(beanName,
                                              new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
        }
    }
}
// 判断是否需要添加到销毁bean的集合中
protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
   return (bean.getClass() != NullBean.class &&
         (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() &&
               DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
}

那么到此一个bean的构建就完成了。返回bean容器的bean。

总结

• bean由BeanDefinition定义，BeanDefinition注册到BeanDefinitionRegistry中
• BeanFactory是“懒加载”机制，获取bean的时候才去查找，若无，则创建
• InstantiationAwareBeanPostProcessor 处理时机为bean实例化前后，可以拦截bean的实例化
• Prototype型，在创建bean之前先将beanName放在一个Set中（在ThreadLocal中）创建完成移除。如果Set已存在该beanName，则说明存在循环引用，如A -> B -> ... -> A
• Singleton型，singletonsCurrentlyInCreation集合在BeanFactory中，创建之前若此集合中存在该beanName则循环引用
• 如果bean是含参构造函数，则先解决参数依赖，若此时参数依赖当前bean则直接报错，因当前bean无法实例化，也就无法提前暴露到singletonFactories中，所以容器无法解决
• 属性依赖的bean，通过获取提前暴露到singletonFactories的singletonFactory，调用方法获取bean实例，完成依赖
• Aware接口完成系统注入，BeanFactory包括3个：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware，自定义可以通过BeanPostProcessor完成
• InitializingBean接口及自定义initMethodName属性完成bean的初始化
• BeanPostProcessor 处理时机为bean实例化之后，初始化前后，可以处理并替换bean（AOP实现）
• DisposableBean接口、AutoCloseable接口及destroyMethodName属性完成bean的销毁工作
• 容器中保存的是bean的包装BeanWrapper