https://zhuanlan.zhihu.com/p/66719191

1 AbstractBeanFactory.getBean 主流程

  1. @Override
  2. public Object getBean(String name) throws BeansException {
  3.     return doGetBean(name, null, null, false);
  4. }

第二个参数表示bean的Class类型，第三个表示创建bean需要的参数，最后一个表示不需要进行类型检查。

  1.     protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
  2.             @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  4.         //1 提取beanName
  5.         //去除&符号，因为当配置文件中<bean>的class属性配置的实现类是FactoryBean时
  6.         //通过getBean()方法返回的不是FactoryBean本身，
  7.         //而是FactoryBean#getObject()方法所返回的对象
  8.         //相当于FactoryBean#getObject()代理了getBean()方法
  9.         //如果希望获取FactoryBean的实例，需要在beanName前加上“&”符号，即getBean("&beanName")
  10.         //在这里要获取的是bean的实例，所以要去掉&符号
  11.         final String beanName = transformedBeanName(name);
  12.         Object bean;
  14.         // Eagerly check singleton cache for manually registered singletons.
  16.         //2 率先直接从单例缓存或objectFactory中提取bean，容器内部初始化和非初始化（手动调用）过程也都被调用
  17.         //如果是原型bean，直接获得不到，进入创建bean的else流程
  18.         Object sharedInstance = getSingleton(beanName);
  19.         // 3 getbean 主流程
  20.         // 3.1 如果存在该单例bean且属性为空，直接返回
  21.         if (sharedInstance != null && args == null) {
  22.             if (logger.isTraceEnabled()) {
  23.                 // 3.1.1循环依赖
  24.                 if (isSingletonCurrentlyInCreation(beanName)) {
  25.                     logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  26.                             "' that is not fully initialized yet - a consequence of a circular reference");
  27.                 }
  28.                 // 3.1.2不存在循环依赖
  29.                 else {
  30.                     logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  31.                 }
  32.             }
  33.             // 3.1.3 getObjectForBeanInstance
  34.            //如果从缓存中得到了bean的原始状态，则需要对bean进行实例化。
  35.            //缓存中记录的只是最原始的bean状态，并不一定是我们最终想要的bean。
  36.            //假如我们需要对工厂bean进行处理，那么这里得到的其实是工厂bean的初始状态
  37.            //但是我们正真需要的是工程bean中定义的factory-method方法中返回的bean
  38.            //而getObjectForBeanInstance就是完成这个工作的
  39.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  40.         }
  41.         // 3.2 非单例，或者单例第一次创建，或单例已存在参数不为空
  42.         else {
  43.             // Fail if we're already creating this bean instance:
  44.             // We're assumably within a circular reference.
  45.             // 3.2.1 检查循环依赖是否合法
  46.             //只有单例才会解决bean的循环依赖问题
  47.             //原型bean 依赖的存在bean正在创建 非法
  48.             if (isPrototypeCurrentlyInCreation(beanName)) {
  49.                 throw new BeanCurrentlyInCreationException(beanName);
  50.             }
  52.             // Check if bean definition exists in this factory.
  53.             // 3.2.2 beanName不在本容器内，检查父容器，委托给父工厂中寻找，甚至创建
  54.             BeanFactory parentBeanFactory = getParentBeanFactory();
  55.             //如果当前bean不在当前beanfactory的beanDefinitionMap，委托给父工厂中寻找，甚至创建
  56.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  57.                 // Not found -> check parent.
  58.                 String nameToLookup = originalBeanName(name);
  59.                 if (parentBeanFactory instanceof AbstractBeanFactory) {
  60.                     return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  61.                             nameToLookup, requiredType, args, typeCheckOnly);
  62.                 }
  63.                 else if (args != null) {
  64.                     // Delegation to parent with explicit args.
  65.                     return (T) parentBeanFactory.getBean(nameToLookup, args);
  66.                 }
  67.                 else if (requiredType != null) {
  68.                     // No args -> delegate to standard getBean method.
  69.                     return parentBeanFactory.getBean(nameToLookup, requiredType);
  70.                 }
  71.                 else {
  72.                     return (T) parentBeanFactory.getBean(nameToLookup);
  73.                 }
  74.             }
  75.             //3.2.3标记已经该bean创建了
  76.             // 清除合并父beanDefiniton的标志，把创建的beanName加入
  77.             if (!typeCheckOnly) {
  78.                 markBeanAsCreated(beanName);
  79.             }
  80.             // 3.2.4 合并父beanDefiniton和递归get依赖的bean
  81.             try {
  82.                 //读取bean的标签对应的BeanDefinition，子bean的话合并父属性
  83.                 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  84.                 checkMergedBeanDefinition(mbd, beanName, args);
  86.                 // Guarantee initialization of beans that the current bean depends on.
  87.                 String[] dependsOn = mbd.getDependsOn();
  88.                 if (dependsOn != null) {
  89.                     for (String dep : dependsOn) {
  90.                         if (isDependent(beanName, dep)) {
  91.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  92.                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  93.                         }
  95.                         //注册依赖和递归获得bean的顺序与3.0版本相反
  96.                         //注册依赖关系
  97.                         registerDependentBean(dep, beanName);
  98.                         try {
  99.                             //递归调用 get依赖的bean
  100.                             getBean(dep);
  101.                         }
  102.                         catch (NoSuchBeanDefinitionException ex) {
  103.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  104.                                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  105.                         }
  106.                     }
  107.                 }
  109.                 // Create bean instance.
  110.                 // 3.2.5 创建bean
  111.                 //3.2.5 .1 单例bean
  112.                 if (mbd.isSingleton()) {
  113.                     sharedInstance = getSingleton(beanName, () -> {
  114.                         try {
  115.                             return createBean(beanName, mbd, args);
  116.                         }
  117.                         catch (BeansException ex) {
  118.                             // Explicitly remove instance from singleton cache: It might have been put there
  119.                             // eagerly by the creation process, to allow for circular reference resolution.
  120.                             // Also remove any beans that received a temporary reference to the bean.
  121.                             destroySingleton(beanName);
  122.                             throw ex;
  123.                         }
  124.                     });
  125.                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  126.                 }
  127.                 //3.2.5 .2 原型bean
  128.                 else if (mbd.isPrototype()) {
  129.                     // It's a prototype -> create a new instance.
  130.                     Object prototypeInstance = null;
  131.                     try {
  132.                         beforePrototypeCreation(beanName);
  133.                         prototypeInstance = createBean(beanName, mbd, args);
  134.                     }
  135.                     finally {
  136.                         afterPrototypeCreation(beanName);
  137.                     }
  138.                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  139.                 }
  140.                 //3.2.5 .3 其他scope的bean
  141.                 else {
  142.                     String scopeName = mbd.getScope();
  143.                     final Scope scope = this.scopes.get(scopeName);
  144.                     if (scope == null) {
  145.                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  146.                     }
  147.                     try {
  148.                         Object scopedInstance = scope.get(beanName, () -> {
  149.                             beforePrototypeCreation(beanName);
  150.                             try {
  151.                                 return createBean(beanName, mbd, args);
  152.                             }
  153.                             finally {
  154.                                 afterPrototypeCreation(beanName);
  155.                             }
  156.                         });
  157.                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  158.                     }
  159.                     catch (IllegalStateException ex) {
  160.                         throw new BeanCreationException(beanName,
  161.                                 "Scope '" + scopeName + "' is not active for the current thread; consider " +
  162.                                 "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  163.                                 ex);
  164.                     }
  165.                 }
  166.             }
  167.             catch (BeansException ex) {
  168.                 cleanupAfterBeanCreationFailure(beanName);
  169.                 throw ex;
  170.             }
  171.         }
  173.         // Check if required type matches the type of the actual bean instance.
  174.         //4 转换bean为需要的类型，不满足抛出异常
  175.         if (requiredType != null && !requiredType.isInstance(bean)) {
  176.             try {
  178.                 T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  179.                 if (convertedBean == null) {
  180.                     throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  181.                 }
  182.                 return convertedBean;
  183.             }
  184.             catch (TypeMismatchException ex) {
  185.                 if (logger.isTraceEnabled()) {
  186.                     logger.trace("Failed to convert bean '" + name + "' to required type '" +
  187.                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
  188.                 }
  189.                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  190.             }
  191.         }
  192.         return (T) bean;
  193.     }

2 两个 getSingleton方法

2.1 从一级缓存获得bean（解决循环依赖第一步）

  1. //先从singletonObjects寻找，如果找不到，再从earlySingletonObjects寻找，
  2. //仍然找不到，那就从singletonFactories寻找对应的制造singleton的工厂，
  3. //然后调用工厂的getObject方法，造出对应的SingletonBean，并放入earlySingletonObjects中
  1.     //单例Bean的缓存，一级缓存 bean name 对应 bean 实例
  2.     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  4.     /** Cache of singleton factories: bean name to ObjectFactory. */
  6.     //ObjectFactory的缓存，bean name 对应 特定ObjectFactory;
  7.     //ObjectFactory的getObject方法返回bean的实例 ObjectFactory通过getObject方法获取到了earlySingletonBean
  8.     //然后在由earlySingletonBean成为bean的实例
  9.     // 有人叫二级缓存
  10.     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  12.     /** Cache of early singleton objects: bean name to bean instance. */
  14.     //早期bean实例的缓存,beanName对应 early bean instance
  15.     //是singletonFactory 制造出来的 singleton的缓存 有人叫三级缓存
  16.     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
  20.     @Nullable
  21.     protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  22.         Object singletonObject = this.singletonObjects.get(beanName);
  23.         if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  24.             synchronized (this.singletonObjects) {
  25.                 singletonObject = this.earlySingletonObjects.get(beanName);
  26.                 if (singletonObject == null && allowEarlyReference) {
  27.                     ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  28.                     if (singletonFactory != null) {
  29.                         singletonObject = singletonFactory.getObject();
  30.                         this.earlySingletonObjects.put(beanName, singletonObject);
  31.                         this.singletonFactories.remove(beanName);
  32.                     }
  33.                 }
  34.             }
  35.         }
  36.         return singletonObject;
  37.     }

2.2 create新的bean与几个缓存交互

  1.     public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  2.         Assert.notNull(beanName, "Bean name must not be null");
  3.         synchronized (this.singletonObjects) {
  4.             Object singletonObject = this.singletonObjects.get(beanName);
  5.             //1 从缓存拿，拿不到创建
  6.             if (singletonObject == null) {
  7.                 if (this.singletonsCurrentlyInDestruction) {
  8.                     throw new BeanCreationNotAllowedException(beanName,
  9.                             "Singleton bean creation not allowed while singletons of this factory are in destruction " +
  10.                             "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
  11.                 }
  12.                 if (logger.isDebugEnabled()) {
  13.                     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
  14.                 }
  15.                 //2 创建bean前置检查，如已经存在正在创建的bean且inCreationCheckExclusions（web容器中）中不存在该bean，则抛出异常
  16.                 beforeSingletonCreation(beanName);
  17.                 boolean newSingleton = false;
  18.                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  19.                 if (recordSuppressedExceptions) {
  20.                     this.suppressedExceptions = new LinkedHashSet<>();
  21.                 }
  22.                 //3 利用ObjectFactory创建新的单例bean
  23.                 try {
  24.                     singletonObject = singletonFactory.getObject();
  25.                     newSingleton = true;
  26.                 }
  27.                 catch (IllegalStateException ex) {
  28.                     // Has the singleton object implicitly appeared in the meantime ->
  29.                     // if yes, proceed with it since the exception indicates that state.
  30.                     singletonObject = this.singletonObjects.get(beanName);
  31.                     if (singletonObject == null) {
  32.                         throw ex;
  33.                     }
  34.                 }
  35.                 catch (BeanCreationException ex) {
  36.                     if (recordSuppressedExceptions) {
  37.                         for (Exception suppressedException : this.suppressedExceptions) {
  38.                             ex.addRelatedCause(suppressedException);
  39.                         }
  40.                     }
  41.                     throw ex;
  42.                 }
  43.                 finally {
  44.                     if (recordSuppressedExceptions) {
  45.                         this.suppressedExceptions = null;
  46.                     }
  47.                     //4 创建bean前置检查，如移除正在创建的bean失败且inCreationCheckExclusions（web容器中）中不存在该bean，则抛出异常
  48.                     afterSingletonCreation(beanName);
  49.                 }
  50.                 //5 成功的创建了新的bean则加入缓存
  51.                 if (newSingleton) {
  52.                     addSingleton(beanName, singletonObject);
  53.                 }
  54.             }
  55.             return singletonObject;
  56.         }
  57.     }

3 createBean

源码位于AbstractAutowireCapableBeanFactory.createBean

  1.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  2.             throws BeanCreationException {
  4.         if (logger.isTraceEnabled()) {
  5.             logger.trace("Creating instance of bean '" + beanName + "'");
  6.         }
  7.         RootBeanDefinition mbdToUse = mbd;
  9.         // Make sure bean class is actually resolved at this point, and
  10.         // clone the bean definition in case of a dynamically resolved Class
  11.         // which cannot be stored in the shared merged bean definition.
  12.         //1 获得bean的class对象，根据beanName或beandefiniton属性解析class
  13.          //    克隆那些因动态解析类的情况下,不能存储在共享合并bean定义的beandefinition，动态支持
  14.         Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  15.         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  16.             mbdToUse = new RootBeanDefinition(mbd);
  17.             mbdToUse.setBeanClass(resolvedClass);
  18.         }
  20.         // Prepare method overrides.
  21.         //2 lookup-overrides 和 replace-overrides处理 检查方法覆盖是否合法
  22.         try {
  23.             mbdToUse.prepareMethodOverrides();
  24.         }
  25.         catch (BeanDefinitionValidationException ex) {
  26.             throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  27.                     beanName, "Validation of method overrides failed", ex);
  28.         }
  30.         try {
  31.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  32.             //3 给 InstantiationAwareBeanPostProcessor一个机会 返回代理单例对象代替当前对象
  33.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  34.             //为特殊的bean提够短路功能，如aop
  35.             if (bean != null) {
  36.                 return bean;
  37.             }
  38.         }
  39.         catch (Throwable ex) {
  40.             throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  41.                     "BeanPostProcessor before instantiation of bean failed", ex);
  42.         }
  44.         try {
  45.             // 4 具体创建bean
  46.             Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  47.             if (logger.isTraceEnabled()) {
  48.                 logger.trace("Finished creating instance of bean '" + beanName + "'");
  49.             }
  50.             return beanInstance;
  51.         }
  52.         catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
  53.             // A previously detected exception with proper bean creation context already,
  54.             // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
  55.             throw ex;
  56.         }
  57.         catch (Throwable ex) {
  58.             throw new BeanCreationException(
  59.                     mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  60.         }
  61.     }

3.1 InstantiationAwareBeanPostProcessor

给 InstantiationAwareBeanPostProcessor一个机会 返回代理单例对象代替当前对象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//为特殊的bean提够短路功能，如aop
if (bean != null) {
return bean;
}

  1.     protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
  2.         Object bean = null;
  3.         //未被初始化
  4.         if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
  5.             // Make sure bean class is actually resolved at this point.
  6.             // Synthetic特殊的bean，临时的bean。spring自己的bean
  7.             if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  8.                 Class<?> targetType = determineTargetType(beanName, mbd);
  9.                 if (targetType != null) {
  10.                     // 核心逻辑
  11.                     // 1 创建实例的前置处理
  12.                     bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
  13.                     // 2 创建实例的后置处理
  14.                     if (bean != null) {
  15.                         bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
  16.                     }
  17.                 }
  18.             }
  19.             mbd.beforeInstantiationResolved = (bean != null);
  20.         }
  21.         return bean;
  22.     }

3.2 doCreateBean

4 bean对象后置处理器：BeanPostProcessor

Bean后置处理器：负责对已创建好的bean对象进行加工处理。

主要是可以对新创建的bean实例进行修改，提供了一个类似于hook机制，对创建好的bean对象实例进行修改。 另外，不要将BeanPostProcessor标记为延迟初始化。因为如果这样做，Spring容器将不会注册它们，自定义逻辑也就无法得到应用。假如你在元素的定义中使用了’default-lazy-init’属性，请确信你的各个BeanPostProcessor标记为’lazy-init=”false”‘。

  1. public interface BeanPostProcessor {
  2.     //bean初始化方法调用前被调用 在创建好bean实例，但是在任何初始化回调执行之前，如InitializingBean的afterPropertiesSet，先执行该方法。
  3.     Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
  4.     //bean初始化方法调用后被调用 在创建好bean实例，并且所有的初始化回调都执行完了，如InitializingBean的afterPropertiesSet，再执行该方法
  5.     Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
  6. }
  7. public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
  9.     @Nullable
  10.     default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  11.         return null;
  12.     }
  15.     default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
  16.         return true;
  17.     }
  20.     @Nullable
  21.     default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
  22.             throws BeansException {
  24.         return null;
  25.     }
  27.     @Deprecated
  28.     @Nullable
  29.     default PropertyValues postProcessPropertyValues(
  30.             PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
  32.         return pvs;
  33.     }
  34. }

ApplicationContext会自动检测当前存在的beanPostProcessors，并应用在创建的bean实例上。

注解处理相关的BeanPostProcessor
通常用于在创建好bean对象实例后，处理这个bean上面的注解。同时也可以对bean对象进行其他功能拓展。
BeanPostProcessor的注册
定义：在注解配置工具类AnnotationConfigUtils的静态方法registerAnnotationConfigProcessors方法中，定义注解的处理器的注册逻辑。
调用：在BeanFactoryPostProcessor中调用这个静态方法来完成将特定的BeanPostProcessor实现类，注册到ApplicationContext的BeanPostProcessor列表：
1 AutowiredAnnotationBeanPostProcessor:处理bean对象的依赖注入关系，即从BeanFactory获取该bean所依赖的bean，然后注入到该bean对应的成员变量中。

2 CommonAnnotationBeanPostProcessor：该bean中所使用了的JDK定义的注解的处理，如方法中的@PostConstruct，@PreDestroy，成员变量上的@Resource等。

3 PersistenceAnnotationBeanPostProcessor（JPA时添加）：JPA相关bean的持久化处理。