show: stepversion: 1.0
enable_checker: true

浅谈SpringFramework Bean创建过程

文章前言

提示：在前面的学习中，我们对BeanFactory的创建过程有了一个熟悉，其实实际的操作不止创建BeanFactory，调用的过程也实现了将xml解析为Document对象，再转换成BeanDefinition（很重要，Spring的Bean），并注册到BeanFactory，接着本文带着疑问学习一下Spring中的Bean（BeanDefinition）是怎么创建实例出来的？
提示：以下是本篇文章正文内容，下面案例可供参考

BeanDefinition实例过程简介

上一章学习了obtainFreshBeanFactory这个方法，经过这个方法，xml配置信息已经转换成一个BeanDefinition，但是BeanDefinition还没实例，属性也没配置，只是配置信息被提取出来，而且注册到BeanFactory
在这里插入图片描述
在之前文章学习，我们知道了，Bean的实例完成是在finishBeanFactoryInitialization这一步，当然是针对非懒加载的单例bean，多例的情况，后面有时间再来学习
在这里插入图片描述

finishBeanFactoryInitialization实现

ok，有了前面的简单了解，可以开始学习finishBeanFactoryInitialization的创建过程：通过代码，一步步跟，看看BeanDefinition是怎么初始化的？bean属性是怎么填充的？

  1. /**
  2.  * Finish the initialization of this context's bean factory,
  3.  * initializing all remaining singleton beans.
  4.  */
  5. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  6.     // Initialize conversion service for this context.
  7.     // 初始化ConversionService，这个bean用于将前端传过来的参数和后端的 controller 方法上的参数进行绑定
  8.     if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  9.             beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  10.         beanFactory.setConversionService(
  11.                 beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  12.     }
  14.     // Register a default embedded value resolver if no bean post-processor
  15.     // (such as a PropertyPlaceholderConfigurer bean) registered any before:
  16.     // at this point, primarily for resolution in annotation attribute values.
  17.     if (!beanFactory.hasEmbeddedValueResolver()) {
  18.         beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  19.     }
  21.     // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  22.     // 先初始化LoadTimeWeaverAware 类型的Bean
  23.     // AspectJ 的内容，IoC的源码学习，先跳过
  24.     String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  25.     for (String weaverAwareName : weaverAwareNames) {
  26.         getBean(weaverAwareName);
  27.     }
  29.     // Stop using the temporary ClassLoader for type matching.
  30.     beanFactory.setTempClassLoader(null);
  32.     // Allow for caching all bean definition metadata, not expecting further changes.
  33.     // 冻结配置，不让bean 定义解析、加载、注册
  34.     beanFactory.freezeConfiguration();
  36.     // Instantiate all remaining (non-lazy-init) singletons.
  37.     // 实例所有非懒加载的单例Bean
  38.     beanFactory.preInstantiateSingletons();
  39. }

{@link org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons}

  1. @Override
  2. public void preInstantiateSingletons() throws BeansException {
  3.     if (logger.isDebugEnabled()) {
  4.         logger.debug("Pre-instantiating singletons in " + this);
  5.     }
  7.     // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  8.     // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  9.     // 获取beanName列表，this.beanDefinitionNames 保存了所有的 beanNames
  10.     List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  12.     // Trigger initialization of all non-lazy singleton beans...
  13.     // 触发所有非懒加载的单例bean初始化操作（lazy-init=false）
  14.     for (String beanName : beanNames) {
  15.         // 合并rootBean中的配置， <bean id="a" class="a" parent="p" />
  16.         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  17.         // 非抽象（abstract = false）、非懒加载（lazy-init=false）的单例Bean（scope=singleton）
  18.         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  19.             // 处理FactoryBean，注意对比BeanFactory和FactoryBean
  20.             if (isFactoryBean(beanName)) {
  21.                 // factoryBean调用在beanName加载前缀符号‘&’
  22.                 // 为什么要加‘&’，应该是做下标记，不过在bean创建过程要进行转换，详情请看下文
  23.                 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  24.                 if (bean instanceof FactoryBean) {
  25.                     FactoryBean<?> factory = (FactoryBean<?>) bean;
  26.                     boolean isEagerInit;
  27.                     // FactoryBean是SmartFactoryBean 的基类
  28.                     if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  29.                         isEagerInit = AccessController.doPrivileged(
  30.                                 (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  31.                                 getAccessControlContext());
  32.                     }
  33.                     else {
  34.                         isEagerInit = (factory instanceof SmartFactoryBean &&
  35.                                 ((SmartFactoryBean<?>) factory).isEagerInit());
  36.                     }
  37.                     if (isEagerInit) {
  38.                         getBean(beanName);
  39.                     }
  40.                 }
  41.             }
  42.             else {
  43.                 // 普通的Bean，调这个方法进行实例，往下跟
  44.                 getBean(beanName);
  45.             }
  46.         }
  47.     }
  49.     // Trigger post-initialization callback for all applicable beans...
  50.     // SmartInitializingSingleton 的基类在这里回调
  51.     for (String beanName : beanNames) {
  52.         Object singletonInstance = getSingleton(beanName);
  53.         if (singletonInstance instanceof SmartInitializingSingleton) {
  54.             SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  55.             if (System.getSecurityManager() != null) {
  56.                 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  57.                     smartSingleton.afterSingletonsInstantiated();
  58.                     return null;
  59.                 }, getAccessControlContext());
  60.             }
  61.             else {
  62.                 smartSingleton.afterSingletonsInstantiated();
  63.             }
  64.         }
  65.     }
  66. }

AbstractBeanFactory.java：
{@link org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean}

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

{@link org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean}

  1. /**
  2.  * Return an instance, which may be shared or independent, of the specified bean.
  3.  * @param name the name of the bean to retrieve
  4.  * @param requiredType the required type of the bean to retrieve
  5.  * @param args arguments to use when creating a bean instance using explicit arguments
  6.  * (only applied when creating a new instance as opposed to retrieving an existing one)
  7.  * @param typeCheckOnly whether the instance is obtained for a type check,
  8.  * not for actual use
  9.  * @return an instance of the bean
  10.  * @throws BeansException if the bean could not be created
  11.  */
  12. @SuppressWarnings("unchecked")
  13. protected <T> T doGetBean(
  14.         String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
  15.         throws BeansException {
  16.     //  处理BeanName，前面说的FactoryBean带‘&’符号，要在这里进行转换
  17.     String beanName = transformedBeanName(name);
  18.     Object bean;
  20.     // Eagerly check singleton cache for manually registered singletons.
  21.     // 从map（singletonObjects）里获取单例bean，确定是否已经存在对应实例
  22.     Object sharedInstance = getSingleton(beanName);
  23.     if (sharedInstance != null && args == null) {
  24.         if (logger.isDebugEnabled()) {
  25.             if (isSingletonCurrentlyInCreation(beanName)) {
  26.                 logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
  27.                         "' that is not fully initialized yet - a consequence of a circular reference");
  28.             }
  29.             else {
  30.                 logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
  31.             }
  32.         }
  33.         // 两种情况：普通的bean，直接从singletonObjects返回sharedInstance
  34.         //如果是FactoryBean，返回其创建的对象实例
  35.         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  36.     }
  38.     else {
  39.         // Fail if we're already creating this bean instance:
  40.         // We're assumably within a circular reference.
  41.         // 为了避免循环引用，遇到这种情况，直接抛出异常
  42.         if (isPrototypeCurrentlyInCreation(beanName)) {
  43.             throw new BeanCurrentlyInCreationException(beanName);
  44.         }
  46.         // Check if bean definition exists in this factory.
  47.         // 检查BeanFactory是否存在这个BeanDefinition
  48.         BeanFactory parentBeanFactory = getParentBeanFactory();
  49.         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  50.             // Not found -> check parent.
  51.             // 当前容器找不到BeanDefinition，去parent容器查询
  52.             String nameToLookup = originalBeanName(name);
  53.             if (parentBeanFactory instanceof AbstractBeanFactory) {
  54.                 return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  55.                         nameToLookup, requiredType, args, typeCheckOnly);
  56.             }
  57.             else if (args != null) {
  58.                 // Delegation to parent with explicit args.
  59.                 // 返回parent容器的查询结果
  60.                 return (T) parentBeanFactory.getBean(nameToLookup, args);
  61.             }
  62.             else {
  63.                 // No args -> delegate to standard getBean method.
  64.                 return parentBeanFactory.getBean(nameToLookup, requiredType);
  65.             }
  66.         }
  68.         if (!typeCheckOnly) {
  69.             //typeCheckOnly为false的情况，将beanName放在一个alreadyCreated的集合
  70.             markBeanAsCreated(beanName);
  71.         }
  73.         try {
  74.             RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  75.             checkMergedBeanDefinition(mbd, beanName, args);
  77.             // Guarantee initialization of beans that the current bean depends on.
  78.             // 校验是否配置了 depends-on
  79.             String[] dependsOn = mbd.getDependsOn();
  80.             if (dependsOn != null) {
  81.                 for (String dep : dependsOn) {
  82.                     // 存在循环引用的情况，要抛出异常
  83.                     if (isDependent(beanName, dep)) {
  84.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  85.                                 "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  86.                     }
  87.                     // 正常情况，注册依赖关系
  88.                     registerDependentBean(dep, beanName);
  89.                     try {
  90.                         // 初始化被依赖项
  91.                         getBean(dep);
  92.                     }
  93.                     catch (NoSuchBeanDefinitionException ex) {
  94.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  95.                                 "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  96.                     }
  97.                 }
  98.             }
  100.             // Create bean instance.
  101.             // 单例的Bean
  102.             if (mbd.isSingleton()) {
  103.                 sharedInstance = getSingleton(beanName, () -> {
  104.                     try {
  105.                         // 创建单例bean
  106.                         return createBean(beanName, mbd, args);
  107.                     }
  108.                     catch (BeansException ex) {
  109.                         // Explicitly remove instance from singleton cache: It might have been put there
  110.                         // eagerly by the creation process, to allow for circular reference resolution.
  111.                         // Also remove any beans that received a temporary reference to the bean.
  112.                         destroySingleton(beanName);
  113.                         throw ex;
  114.                     }
  115.                 });
  116.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  117.             }
  118.             // 多例的Bean，scope = protoType
  119.             else if (mbd.isPrototype()) {
  120.                 // It's a prototype -> create a new instance.
  121.                 Object prototypeInstance = null;
  122.                 try {
  123.                     beforePrototypeCreation(beanName);
  124.                      // 执行多例Bean创建
  125.                     prototypeInstance = createBean(beanName, mbd, args);
  126.                 }
  127.                 finally {
  128.                     afterPrototypeCreation(beanName);
  129.                 }
  130.                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  131.             }
  132.             // 如果不是单例bean也不是多例的bean，委托给对应的实现类
  133.             else {
  134.                 String scopeName = mbd.getScope();
  135.                 if (!StringUtils.hasLength(scopeName)) {
  136.                     throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
  137.                 }
  138.                 Scope scope = this.scopes.get(scopeName);
  139.                 if (scope == null) {
  140.                     throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  141.                 }
  142.                 try {
  143.                     Object scopedInstance = scope.get(beanName, () -> {
  144.                         beforePrototypeCreation(beanName);
  145.                         try {
  146.                             // 执行bean创建
  147.                             return createBean(beanName, mbd, args);
  148.                         }
  149.                         finally {
  150.                             afterPrototypeCreation(beanName);
  151.                         }
  152.                     });
  153.                     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  154.                 }
  155.                 catch (IllegalStateException ex) {
  156.                     throw new BeanCreationException(beanName,
  157.                             "Scope '" + scopeName + "' is not active for the current thread; consider " +
  158.                             "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  159.                             ex);
  160.                 }
  161.             }
  162.         }
  163.         catch (BeansException ex) {
  164.             cleanupAfterBeanCreationFailure(beanName);
  165.             throw ex;
  166.         }
  167.     }
  169.     // Check if required type matches the type of the actual bean instance.
  170.     // 检查一下类型是否正确，不正确抛出异常，正确返回实例
  171.     if (requiredType != null && !requiredType.isInstance(bean)) {
  172.         try {
  173.             T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  174.             if (convertedBean == null) {
  175.                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  176.             }
  177.             return convertedBean;
  178.         }
  179.         catch (TypeMismatchException ex) {
  180.             if (logger.isDebugEnabled()) {
  181.                 logger.debug("Failed to convert bean '" + name + "' to required type '" +
  182.                         ClassUtils.getQualifiedName(requiredType) + "'", ex);
  183.             }
  184.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  185.         }
  186.     }
  187.     return (T) bean;
  188. }

补充前面说的FactoryBean带‘&’符号问题可以在transformedBeanName看到原因
{@link org.springframework.beans.factory.support.AbstractBeanFactory#transformedBeanName}

  1. /**
  2.  * Return the bean name, stripping out the factory dereference prefix if necessary,
  3.  * and resolving aliases to canonical names.
  4.  * @param name the user-specified name
  5.  * @return the transformed bean name
  6.  */
  7. protected String transformedBeanName(String name) {
  8.     // 往下跟
  9.     return canonicalName(BeanFactoryUtils.transformedBeanName(name));
  10. }
  1. /**
  2.  * Return the actual bean name, stripping out the factory dereference
  3.  * prefix (if any, also stripping repeated factory prefixes if found).
  4.  * @param name the name of the bean
  5.  * @return the transformed name
  6.  * @see BeanFactory#FACTORY_BEAN_PREFIX
  7.  */
  8. public static String transformedBeanName(String name) {
  9.     Assert.notNull(name, "'name' must not be null");
  10.     String beanName = name;
  11.     // FactoryBean的beanName是带‘&’的
  12.     while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
  13.         beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
  14.     }
  15.     return beanName;
  16. }

{@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean}

  1. /**
  2.  * Central method of this class: creates a bean instance,
  3.  * populates the bean instance, applies post-processors, etc.
  4.  * @see #doCreateBean
  5.  */
  6. @Override
  7. protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  8.         throws BeanCreationException {
  10.     if (logger.isDebugEnabled()) {
  11.         logger.debug("Creating instance of bean '" + beanName + "'");
  12.     }
  13.     RootBeanDefinition mbdToUse = mbd;
  15.     // Make sure bean class is actually resolved at this point, and
  16.     // clone the bean definition in case of a dynamically resolved Class
  17.     // which cannot be stored in the shared merged bean definition.
  18.     // ClassLoader加载BeanDefinition 
  19.     Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  20.     if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  21.         mbdToUse = new RootBeanDefinition(mbd);
  22.         mbdToUse.setBeanClass(resolvedClass);
  23.     }
  25.     // Prepare method overrides.
  26.     // 处理方法覆盖
  27.     //  todo 涉及bean 定义中的 <lookup-method />  和 <replaced-method />，先放过
  28.     try {
  29.         mbdToUse.prepareMethodOverrides();
  30.     }
  31.     catch (BeanDefinitionValidationException ex) {
  32.         throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  33.                 beanName, "Validation of method overrides failed", ex);
  34.     }
  36.     try {
  37.         // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  38.         // todo 让InstantiationAwareBeanPostProcessor这个后置处理器有机会返回一个代理的实例，这个ioc源码学习先放过
  39.         Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  40.         if (bean != null) {
  41.             return bean;
  42.         }
  43.     }
  44.     catch (Throwable ex) {
  45.         throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  46.                 "BeanPostProcessor before instantiation of bean failed", ex);
  47.     }
  49.     try {
  50.         // 重头戏，doCreateBean是实践执行bean创建的
  51.         Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  52.         if (logger.isDebugEnabled()) {
  53.             logger.debug("Finished creating instance of bean '" + beanName + "'");
  54.         }
  55.         return beanInstance;
  56.     }
  57.     catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
  58.         // A previously detected exception with proper bean creation context already,
  59.         // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
  60.         throw ex;
  61.     }
  62.     catch (Throwable ex) {
  63.         throw new BeanCreationException(
  64.                 mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  65.     }
  66. }

继续跟doCreateBean

  1. /**
  2.  * Actually create the specified bean. Pre-creation processing has already happened
  3.  * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
  4.  * <p>Differentiates between default bean instantiation, use of a
  5.  * factory method, and autowiring a constructor.
  6.  * @param beanName the name of the bean
  7.  * @param mbd the merged bean definition for the bean
  8.  * @param args explicit arguments to use for constructor or factory method invocation
  9.  * @return a new instance of the bean
  10.  * @throws BeanCreationException if the bean could not be created
  11.  * @see #instantiateBean
  12.  * @see #instantiateUsingFactoryMethod
  13.  * @see #autowireConstructor
  14.  */
  15. protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  16.         throws BeanCreationException {
  18.     // Instantiate the bean.
  19.     BeanWrapper instanceWrapper = null;
  20.     if (mbd.isSingleton()) {
  21.         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  22.     }
  23.     // 不是FactoryBean的情况
  24.     if (instanceWrapper == null) {
  25.         // 创建Bean实例，但是还没设置属性
  26.         instanceWrapper = createBeanInstance(beanName, mbd, args);
  27.     }
  28.     Object bean = instanceWrapper.getWrappedInstance();
  29.     Class<?> beanType = instanceWrapper.getWrappedClass();
  30.     if (beanType != NullBean.class) {
  31.         mbd.resolvedTargetType = beanType;
  32.     }
  34.     // Allow post-processors to modify the merged bean definition.
  35.     // 涉及到MergedBeanDefinitionPostProcessor，先跳过 todo
  36.     synchronized (mbd.postProcessingLock) {
  37.         if (!mbd.postProcessed) {
  38.             try {
  39.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  40.             }
  41.             catch (Throwable ex) {
  42.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  43.                         "Post-processing of merged bean definition failed", ex);
  44.             }
  45.             mbd.postProcessed = true;
  46.         }
  47.     }
  49.     // Eagerly cache singletons to be able to resolve circular references
  50.     // even when triggered by lifecycle interfaces like BeanFactoryAware.
  51.     // 循环依赖的问题，先跳过 todo
  52.     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  53.             isSingletonCurrentlyInCreation(beanName));
  54.     if (earlySingletonExposure) {
  55.         if (logger.isDebugEnabled()) {
  56.             logger.debug("Eagerly caching bean '" + beanName +
  57.                     "' to allow for resolving potential circular references");
  58.         }
  59.         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  60.     }
  62.     // Initialize the bean instance.
  63.     Object exposedObject = bean;
  64.     try {
  65.         // 关键一步，Bean属性填充
  66.         populateBean(beanName, mbd, instanceWrapper);
  67.         // 调用初始化方法，应用BeanPostProcess后置处理器
  68.         exposedObject = initializeBean(beanName, exposedObject, mbd);
  69.     }
  70.     catch (Throwable ex) {
  71.         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  72.             throw (BeanCreationException) ex;
  73.         }
  74.         else {
  75.             throw new BeanCreationException(
  76.                     mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  77.         }
  78.     }
  80.     if (earlySingletonExposure) {
  81.         Object earlySingletonReference = getSingleton(beanName, false);
  82.         if (earlySingletonReference != null) {
  83.             if (exposedObject == bean) {
  84.                 exposedObject = earlySingletonReference;
  85.             }
  86.             else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  87.                 String[] dependentBeans = getDependentBeans(beanName);
  88.                 Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  89.                 for (String dependentBean : dependentBeans) {
  90.                     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  91.                         actualDependentBeans.add(dependentBean);
  92.                     }
  93.                 }
  94.                 if (!actualDependentBeans.isEmpty()) {
  95.                     throw new BeanCurrentlyInCreationException(beanName,
  96.                             "Bean with name '" + beanName + "' has been injected into other beans [" +
  97.                             StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  98.                             "] in its raw version as part of a circular reference, but has eventually been " +
  99.                             "wrapped. This means that said other beans do not use the final version of the " +
  100.                             "bean. This is often the result of over-eager type matching - consider using " +
  101.                             "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
  102.                 }
  103.             }
  104.         }
  105.     }
  107.     // Register bean as disposable.
  108.     try {
  109.         registerDisposableBeanIfNecessary(beanName, bean, mbd);
  110.     }
  111.     catch (BeanDefinitionValidationException ex) {
  112.         throw new BeanCreationException(
  113.                 mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  114.     }
  116.     return exposedObject;
  117. }

看一下关键的createBeanInstance方法，这是创建bean实例的方法：

  1. /**
  2.  * Create a new instance for the specified bean, using an appropriate instantiation strategy:
  3.  * factory method, constructor autowiring, or simple instantiation.
  4.  * @param beanName the name of the bean
  5.  * @param mbd the bean definition for the bean
  6.  * @param args explicit arguments to use for constructor or factory method invocation
  7.  * @return a BeanWrapper for the new instance
  8.  * @see #obtainFromSupplier
  9.  * @see #instantiateUsingFactoryMethod
  10.  * @see #autowireConstructor
  11.  * @see #instantiateBean
  12.  */
  13. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
  14.     // Make sure bean class is actually resolved at this point.
  15.     // 确保classloader加载了此bean class
  16.     Class<?> beanClass = resolveBeanClass(mbd, beanName);
  17.     // 校验这个bean权限是否是public的
  18.     if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  19.         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  20.                 "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
  21.     }
  23.     Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
  24.     if (instanceSupplier != null) {
  25.         return obtainFromSupplier(instanceSupplier, beanName);
  26.     }
  28.     if (mbd.getFactoryMethodName() != null) {
  29.         // 采用工厂方法实例化
  30.         return instantiateUsingFactoryMethod(beanName, mbd, args);
  31.     }
  33.     // Shortcut when re-creating the same bean...
  34.     // 判断是否第一次构建，第一次构建采用无参构造函数，还是构造函数依赖注入
  35.     boolean resolved = false;
  36.     boolean autowireNecessary = false;
  37.     if (args == null) {
  38.         synchronized (mbd.constructorArgumentLock) {
  39.             if (mbd.resolvedConstructorOrFactoryMethod != null) {
  40.                 resolved = true;
  41.                 autowireNecessary = mbd.constructorArgumentsResolved;
  42.             }
  43.         }
  44.     }
  45.     if (resolved) {
  46.         if (autowireNecessary) {
  47.             // 构造函数注入
  48.             return autowireConstructor(beanName, mbd, null, null);
  49.         }
  50.         else {
  51.             // 无参构造函数
  52.             return instantiateBean(beanName, mbd);
  53.         }
  54.     }
  56.     // Candidate constructors for autowiring?
  57.     // 判断是否采用有参构造函数
  58.     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  59.     if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
  60.             mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  61.         // 有参构造函数依赖注入
  62.         return autowireConstructor(beanName, mbd, ctors, args);
  63.     }
  65.     // No special handling: simply use no-arg constructor.
  66.     // 调用无参构造函数
  67.     return instantiateBean(beanName, mbd);
  68. }

跳最简单的无参构造函数注入方法instantiateBean：

  1. /**
  2.  * Instantiate the given bean using its default constructor.
  3.  * @param beanName the name of the bean
  4.  * @param mbd the bean definition for the bean
  5.  * @return a BeanWrapper for the new instance
  6.  */
  7. protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
  8.     try {
  9.         Object beanInstance;
  10.         if (System.getSecurityManager() != null) {
  11.             beanInstance = AccessController.doPrivileged(
  12.                     (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
  13.                     getAccessControlContext());
  14.         }
  15.         else {
  16.             // 重点，实例过程
  17.             beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
  18.         }
  19.         // BeanWrapper封装一下，返回
  20.         BeanWrapper bw = new BeanWrapperImpl(beanInstance);
  21.         initBeanWrapper(bw);
  22.         return bw;
  23.     }
  24.     catch (Throwable ex) {
  25.         throw new BeanCreationException(
  26.                 mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
  27.     }
  28. }

{@link org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate}

  1. @Override
  2. public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  3.     // Don't override the class with CGLIB if no overrides.
  4.     // 不存在方法覆写的情况，利用java的反射（JDK API）就能实现实例，方法覆写详情参考lookup-method 和 replaced-method
  5.     if (!bd.hasMethodOverrides()) {
  6.         Constructor<?> constructorToUse;
  7.         synchronized (bd.constructorArgumentLock) {
  8.             constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
  9.             if (constructorToUse == null) {
  10.                 final Class<?> clazz = bd.getBeanClass();
  11.                 if (clazz.isInterface()) {
  12.                     throw new BeanInstantiationException(clazz, "Specified class is an interface");
  13.                 }
  14.                 try {
  15.                     if (System.getSecurityManager() != null) {
  16.                         constructorToUse = AccessController.doPrivileged(
  17.                                 (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
  18.                     }
  19.                     else {
  20.                         constructorToUse = clazz.getDeclaredConstructor();
  21.                     }
  22.                     bd.resolvedConstructorOrFactoryMethod = constructorToUse;
  23.                 }
  24.                 catch (Throwable ex) {
  25.                     throw new BeanInstantiationException(clazz, "No default constructor found", ex);
  26.                 }
  27.             }
  28.         }
  29.         // 调用BeanUtils对构造方法进行实例
  30.         return BeanUtils.instantiateClass(constructorToUse);
  31.     }
  32.     else {
  33.         // Must generate CGLIB subclass.
  34.         // 存在方法覆写的情况：SimpleInstantiationStrategy并没有提供实例化支持（JDK不支持），
  35.         // 只能通过动态代理CGLIB实现，这是一个模板方法，给子类继承实现
  36.         return instantiateWithMethodInjection(bd, beanName, owner);
  37.     }
  38. }

ok，前面是对bean实例过程的描述，接着继续跟一个关键点，Bean属性的填充，代码往上翻，找到{@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean}找到代码populateBean(beanName, mbd, instanceWrapper);

  1. /**
  2.  * Populate the bean instance in the given BeanWrapper with the property values
  3.  * from the bean definition.
  4.  * @param beanName the name of the bean
  5.  * @param mbd the bean definition for the bean
  6.  * @param bw the BeanWrapper with bean instance
  7.  */
  8. protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
  9.     if (bw == null) {
  10.         // bean是否有属性
  11.         if (mbd.hasPropertyValues()) {
  12.             throw new BeanCreationException(
  13.                     mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
  14.         }
  15.         else {
  16.             // Skip property population phase for null instance.
  17.             return;
  18.         }
  19.     }
  21.     // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
  22.     // state of the bean before properties are set. This can be used, for example,
  23.     // to support styles of field injection.
  24.     // 这个校验有点看不太懂 先跳过 todo
  25.     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  26.         for (BeanPostProcessor bp : getBeanPostProcessors()) {
  27.             if (bp instanceof InstantiationAwareBeanPostProcessor) {
  28.                 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  29.                 // 返回false，代表不需要进行后续的属性设值，也不需要调用后置处理器
  30.                 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
  31.                     return;
  32.                 }
  33.             }
  34.         }
  35.     }
  37.     PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
  39.     int resolvedAutowireMode = mbd.getResolvedAutowireMode();
  40.     if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  41.         MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  42.         // Add property values based on autowire by name if applicable.
  43.         // 通过beanname找到属性值
  44.         if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
  45.             autowireByName(beanName, mbd, bw, newPvs);
  46.         }
  47.         // Add property values based on autowire by type if applicable.
  48.         // 通用类型装配
  49.         if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  50.             autowireByType(beanName, mbd, bw, newPvs);
  51.         }
  52.         pvs = newPvs;
  53.     }
  55.     boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
  56.     boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
  58.     if (hasInstAwareBpps || needsDepCheck) {
  59.         if (pvs == null) {
  60.             pvs = mbd.getPropertyValues();
  61.         }
  62.         PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  63.         if (hasInstAwareBpps) {
  64.             for (BeanPostProcessor bp : getBeanPostProcessors()) {
  65.                 if (bp instanceof InstantiationAwareBeanPostProcessor) {
  66.                     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  67.                     // 后置处理器的内容，很重要的方面，不过内容比较多，先跳过
  68.                     pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
  69.                     if (pvs == null) {
  70.                         return;
  71.                     }
  72.                 }
  73.             }
  74.         }
  75.         if (needsDepCheck) {
  76.             checkDependencies(beanName, mbd, filteredPds, pvs);
  77.         }
  78.     }
  80.     if (pvs != null) {
  81.         //设置 bean 实例的属性值
  82.         applyPropertyValues(beanName, mbd, bw, pvs);
  83.     }
  84. }

文章归纳

提示：这里对文章进行归纳：ok，本文对BeanDefinition的实例过程进行简单的学习，Spring源码比较复杂，需要慢慢积累，才能对整个框架有很好的理解，这款框架有一个很值得学习的地方是很好地做到的面向接口编程，很多地方也用到了模板方法设计模式，工厂模式，等等，很好地应用了设计模式，针对BeanDefinition创建的过程，都有提供一些接口给子类拓展，框架就显得灵活，可拓展