devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Spring源码】IOC容器实现(5)--Bean对象的创建_非抽象非单例并且非

作者：AllinToyou | 2024-03-15 14:08:20

赞

踩

非抽象非单例并且非

前言

Github：https://github.com/yihonglei/thinking-in-spring

在前面文章中分析了容器初始化过程，已经建立了一个可以使用的容器。

1）BeanDefinition的Resource定位

2）BeanDefinition的载入和解析

3）BeanDefinition的注册

一 Bean对象创建概要   

    容器初始化的工作主要是在IOC容器中建立了BeanDefinition数据映射，并通过HashMap持有数据，

BeanDefinition都在beanDefinitionMap里被检索和使用。在IOC容器BeanFactory中，有一个getBean的接口定义，

通过这个接口实现可以获取到Bean对象。但是，这个Bean对象并不是一个普通的Bean对象，它是一个处理完依赖关系

后的Bean对象。所以一个getBean()实现里面，分为两个大步骤来处理返回用户需要的Bean对象：

1）根据BeanDefinition创建Bean对象，也即Bean对象的创建。

2）创建出来的Bean是一个还没有建立依赖关系的Bean，所有需要完成依赖关系建立，叫做Bean依赖注入。

本文先分析如何根据BeanDefinition数据结构创建用户需要的Bean，并且搞清楚Bean的创建时机，因为有些人说Bean在第一次

使用时进行创建的，有些人又说在IOC容器初始化的时候就给创建好了，然而并不都对。

Bean的创建时机分为两大类：

1）非抽象，并且单例，并且非懒加载（Spring Bean默认单例Singleton，非懒加载）的对象是在IOC容器初始化时通过

refresh()#finishBeanFactoryInitialization()完成创建的，创建完后放在本地缓存里面，用的时候直接取即可，

这么做是因为在初始化的时候，可能就需要使用Bean，同时，可以提高使用时获取的效率；

如果想在使用时才进行初始化，可以设置@Scope("prototype")为原型模式或者加上@Lazy默认是true懒加载。

初始化时创建的Bean放在Map里面，private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

使用时直接从Map缓存获取。

2）而非单例或懒加载对象都是在第一次使用时，getBean()的时候创建的；

二 创建Bean

在IOC容器初始化的refresh()方法第11大步，有个独立的方法，就是处理Bean创建的，即bean实例化处理。

refresh()#finishBeanFactoryInitialization()源码：

  1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  2. 	// Initialize conversion service for this context.
  3. 	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
  4. 			beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
  5. 		beanFactory.setConversionService(
  6. 				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  7. 	}
  8.  
  9. 	// Register a default embedded value resolver if no bean post-processor
  10. 	// (such as a PropertyPlaceholderConfigurer bean) registered any before:
  11. 	// at this point, primarily for resolution in annotation attribute values.
  12. 	if (!beanFactory.hasEmbeddedValueResolver()) {
  13. 		beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
  14. 			@Override
  15. 			public String resolveStringValue(String strVal) {
  16. 				return getEnvironment().resolvePlaceholders(strVal);
  17. 			}
  18. 		});
  19. 	}
  20.  
  21. 	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  22. 	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  23. 	for (String weaverAwareName : weaverAwareNames) {
  24. 		getBean(weaverAwareName);
  25. 	}
  26.  
  27. 	// Stop using the temporary ClassLoader for type matching.
  28. 	beanFactory.setTempClassLoader(null);
  29.  
  30. 	// Allow for caching all bean definition metadata, not expecting further changes.
  31. 	beanFactory.freezeConfiguration();
  32.  
  33. 	// Instantiate all remaining (non-lazy-init) singletons. 初始化时创建Bean的入口
  34. 	beanFactory.preInstantiateSingletons();
  35. }

DefaultListableBeanFactory#preInstantiateSingletons()源码：

  1. @Override
  2. public void preInstantiateSingletons() throws BeansException {
  3. 	if (this.logger.isDebugEnabled()) {
  4. 		this.logger.debug("Pre-instantiating singletons in " + this);
  5. 	}
  6.  
  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. 	List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
  10.  
  11. 	// Trigger initialization of all non-lazy singleton beans...
  12. 	for (String beanName : beanNames) {
  13. 		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  14. 		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  15. 			if (isFactoryBean(beanName)) {
  16. 				final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
  17. 				boolean isEagerInit;
  18. 				if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  19. 					isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
  20. 						@Override
  21. 						public Boolean run() {
  22. 							return ((SmartFactoryBean<?>) factory).isEagerInit();
  23. 						}
  24. 					}, getAccessControlContext());
  25. 				}
  26. 				else {
  27. 					isEagerInit = (factory instanceof SmartFactoryBean &&
  28. 							((SmartFactoryBean<?>) factory).isEagerInit());
  29. 				}
  30. 				if (isEagerInit) {
  31. 					getBean(beanName);
  32. 				}
  33. 			}
  34. 			else {
  35. 				// 在这里，调用getBean()进行bean实例创建
  36. 				getBean(beanName);
  37. 			}
  38. 		}
  39. 	}
  40.  
  41. 	// Trigger post-initialization callback for all applicable beans...
  42. 	for (String beanName : beanNames) {
  43. 		Object singletonInstance = getSingleton(beanName);
  44. 		if (singletonInstance instanceof SmartInitializingSingleton) {
  45. 			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  46. 			if (System.getSecurityManager() != null) {
  47. 				AccessController.doPrivileged(new PrivilegedAction<Object>() {
  48. 					@Override
  49. 					public Object run() {
  50. 						smartSingleton.afterSingletonsInstantiated();
  51. 						return null;
  52. 					}
  53. 				}, getAccessControlContext());
  54. 			}
  55. 			else {
  56. 				smartSingleton.afterSingletonsInstantiated();
  57. 			}
  58. 		}
  59. 	}
  60. }

接下来真正创建Bean的入口就是getBean()，跟你第一次使用Bean的getBean()是一个入口，只是一个在初始化时调用，

一个在第一次使用时调用，所以，是一套代码，原理一样。

下面从就从BeanFactory入手去看getBean()的实现。

BeanFactory源码：

  1. package org.springframework.beans.factory;
  2. import org.springframework.beans.BeansException;
  3. import org.springframework.core.ResolvableType;
  4. public interface BeanFactory {
  5. 	String FACTORY_BEAN_PREFIX = "&";
  6. 	Object getBean(String name) throws BeansException;
  7. 	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
  8. 	<T> T getBean(Class<T> requiredType) throws BeansException;
  9. 	Object getBean(String name, Object... args) throws BeansException;
  10. 	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
  11. 	boolean containsBean(String name);
  12. 	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
  13. 	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
  14. 	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
  15. 	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
  16. 	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
  17. 	String[] getAliases(String name);
  18. }

从getBean(String name)最简单明了的方法入手看实现，该方法在很多类中有实现，重点研究AbstractBeanFactory

中的实现方法。

AbstractBeanFactory.getBean()方法源码：

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

AbstractBeanFactory.doGetBean()方法源码：

  1. protected <T> T doGetBean(
  2.       final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
  3.       throws BeansException {
  4.  
  5.    final String beanName = transformedBeanName(name);
  6.    Object bean;
  7.  
  8.    // Eagerly check singleton cache for manually registered singletons.
  9.    // 先从缓存中获得Bean，处理那些已经被创建过的单间模式的Bean,对这种Bean的请求不需要重复地创建
  10.    Object sharedInstance = getSingleton(beanName);
  11.    if (sharedInstance != null && args == null) {
  12.       if (logger.isDebugEnabled()) {
  13.          if (isSingletonCurrentlyInCreation(beanName)) {
  14.             logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
  15.                   "' that is not fully initialized yet - a consequence of a circular reference");
  16.          }
  17.          else {
  18.             logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
  19.          }
  20.       }
  21.     // 这里的getObjectForBeanInstance完成的是FactoryBean的相关处理，以取得FactoryBean的生产结果
  22.       bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  23.    }
  24.  
  25.    else {
  26.       // Fail if we're already creating this bean instance:
  27.       // We're assumably within a circular reference.
  28.       if (isPrototypeCurrentlyInCreation(beanName)) {
  29.          throw new BeanCurrentlyInCreationException(beanName);
  30.       }
  31.  
  32.       // Check if bean definition exists in this factory.
  33.       /**
  34.        * 对IOC容器中的BeanDefinition是否存在进行检查，检查是否能在当前的BeanFactory中取得需要的Bean。  
  35.        * 如果在当前的工厂中取不到，则到双亲BeanFactory中去取；
  36.        * 如果当前的双亲工厂取不到，就顺着双亲BeanFactory链一直向上查找
  37.        */
  38.       BeanFactory parentBeanFactory = getParentBeanFactory();
  39.       if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  40.          // Not found -> check parent.
  41.          String nameToLookup = originalBeanName(name);
  42.          if (args != null) {
  43.             // Delegation to parent with explicit args.
  44.             return (T) parentBeanFactory.getBean(nameToLookup, args);
  45.          }
  46.          else {
  47.             // No args -> delegate to standard getBean method.
  48.             return parentBeanFactory.getBean(nameToLookup, requiredType);
  49.          }
  50.       }
  51.  
  52.       if (!typeCheckOnly) {
  53.          markBeanAsCreated(beanName);
  54.       }
  55.  
  56.       try {
  57.      // 根据Bean的名字获取BeanDefinition
  58.          final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  59.          checkMergedBeanDefinition(mbd, beanName, args);
  60.  
  61.          // Guarantee initialization of beans that the current bean depends on.
  62.      // 获取当前Bean的所有依赖Bean，这样会触发getBean的递归调用，直到渠道一个没有任何依赖的Bean为止
  63.          String[] dependsOn = mbd.getDependsOn();
  64.          if (dependsOn != null) {
  65.             for (String dep : dependsOn) {
  66.                if (isDependent(beanName, dep)) {
  67.                   throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  68.                         "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  69.                }
  70.                registerDependentBean(dep, beanName);
  71.                getBean(dep);
  72.             }
  73.          }
  74.      
  75.          // Create bean instance.
  76.       // 以下是创建Bean实例
  77.        // 创建sigleton bean
  78.          if (mbd.isSingleton()) {
  79.             sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
  80.                @Override
  81.                public Object getObject() throws BeansException {
  82.                   try {
  83.                      return createBean(beanName, mbd, args);
  84.                   }
  85.                   catch (BeansException ex) {
  86.                      // Explicitly remove instance from singleton cache: It might have been put there
  87.                      // eagerly by the creation process, to allow for circular reference resolution.
  88.                      // Also remove any beans that received a temporary reference to the bean.
  89.                      destroySingleton(beanName);
  90.                      throw ex;
  91.                   }
  92.                }
  93.             });
  94.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  95.          }
  96.      // 创建prototype bean
  97.          else if (mbd.isPrototype()) {
  98.             // It's a prototype -> create a new instance.
  99.             Object prototypeInstance = null;
  100.             try {
  101.                beforePrototypeCreation(beanName);
  102.                prototypeInstance = createBean(beanName, mbd, args);
  103.             }
  104.             finally {
  105.                afterPrototypeCreation(beanName);
  106.             }
  107.             bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  108.          }
  109.      
  110.          else {
  111.             String scopeName = mbd.getScope();
  112.             final Scope scope = this.scopes.get(scopeName);
  113.             if (scope == null) {
  114.                throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  115.             }
  116.             try {
  117.                Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
  118.                   @Override
  119.                   public Object getObject() throws BeansException {
  120.                      beforePrototypeCreation(beanName);
  121.                      try {
  122.                         return createBean(beanName, mbd, args);
  123.                      }
  124.                      finally {
  125.                         afterPrototypeCreation(beanName);
  126.                      }
  127.                   }
  128.                });
  129.                bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  130.             }
  131.             catch (IllegalStateException ex) {
  132.                throw new BeanCreationException(beanName,
  133.                      "Scope '" + scopeName + "' is not active for the current thread; consider " +
  134.                      "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  135.                      ex);
  136.             }
  137.          }
  138.       }
  139.       catch (BeansException ex) {
  140.          cleanupAfterBeanCreationFailure(beanName);
  141.          throw ex;
  142.       }
  143.    }
  144.  
  145.    // Check if required type matches the type of the actual bean instance.
  146.   // 对创建的Bean进行类型检查，如果没有问题，就返回这个新创建的Bean，这个Bean已经是包含依赖关系的Bean
  147.    if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
  148.       try {
  149.          return getTypeConverter().convertIfNecessary(bean, requiredType);
  150.       }
  151.       catch (TypeMismatchException ex) {
  152.          if (logger.isDebugEnabled()) {
  153.             logger.debug("Failed to convert bean '" + name + "' to required type '" +
  154.                   ClassUtils.getQualifiedName(requiredType) + "'", ex);
  155.          }
  156.          throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  157.       }
  158.    }
  159.    return (T) bean;
  160. }

   getBean()方法只是创建对象的起点，doGetBean()只是getBean()的具体执行，在doGetBean()中会调用createBean()

方法，在这个过程中，Bean对象会依据BeanDefinition定义的要求生成。AbstractBeanFactory中的createBean是一个

抽象方法，具体的实现在AbstractAutowireCapableBeanFactory中。

AbstractAutowireCapableBeanFactory.createBean()方法源码：

  1. @Override
  2. protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
  3.    if (logger.isDebugEnabled()) {
  4.       logger.debug("Creating instance of bean '" + beanName + "'");
  5.    }
  6.    RootBeanDefinition mbdToUse = mbd;
  7.  
  8.    // Make sure bean class is actually resolved at this point, and
  9.    // clone the bean definition in case of a dynamically resolved Class
  10.    // which cannot be stored in the shared merged bean definition.
  11.    // 判断需要创建的Bean是否可以实例化，
  12.    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  13.    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  14.       mbdToUse = new RootBeanDefinition(mbd);
  15.       mbdToUse.setBeanClass(resolvedClass);
  16.    }
  17.  
  18.    // Prepare method overrides.
  19.    try {
  20.       mbdToUse.prepareMethodOverrides();
  21.    }
  22.    catch (BeanDefinitionValidationException ex) {
  23.       throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  24.             beanName, "Validation of method overrides failed", ex);
  25.    }
  26.  
  27.    try {
  28.       // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  29.       // 如果Bean配置了PostProcessor，则返回一个proxy代理对象
  30.       Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  31.       if (bean != null) {
  32.          return bean;
  33.       }
  34.    }
  35.    catch (Throwable ex) {
  36.       throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  37.             "BeanPostProcessor before instantiation of bean failed", ex);
  38.    }
  39.   // 创建Bean的调用
  40.    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  41.    if (logger.isDebugEnabled()) {
  42.       logger.debug("Finished creating instance of bean '" + beanName + "'");
  43.    }
  44.    return beanInstance;
  45. }

AbstractAutowireCapableBeanFactory.doCreateBean()方法源码：

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
  2.       throws BeanCreationException {
  3.  
  4.    // Instantiate the bean.
  5.    // 这个BeanWrapper是用来持有创建出来的Bean对象
  6.    BeanWrapper instanceWrapper = null;
  7.    // 如果是Singleton，先把缓存中的同名Bean清除
  8.    if (mbd.isSingleton()) {
  9.       instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  10.    }
  11.    // 通过createBeanInstance()创建Bean
  12.    if (instanceWrapper == null) {
  13.       instanceWrapper = createBeanInstance(beanName, mbd, args);
  14.    }
  15.    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
  16.    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
  17.    mbd.resolvedTargetType = beanType;
  18.  
  19.    // Allow post-processors to modify the merged bean definition.
  20.    synchronized (mbd.postProcessingLock) {
  21.       if (!mbd.postProcessed) {
  22.          try {
  23.             applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  24.          }
  25.          catch (Throwable ex) {
  26.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  27.                   "Post-processing of merged bean definition failed", ex);
  28.          }
  29.          mbd.postProcessed = true;
  30.       }
  31.    }
  32.  
  33.    // Eagerly cache singletons to be able to resolve circular references
  34.    // even when triggered by lifecycle interfaces like BeanFactoryAware.
  35.    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  36.          isSingletonCurrentlyInCreation(beanName));
  37.    if (earlySingletonExposure) {
  38.       if (logger.isDebugEnabled()) {
  39.          logger.debug("Eagerly caching bean '" + beanName +
  40.                "' to allow for resolving potential circular references");
  41.       }
  42.       addSingletonFactory(beanName, new ObjectFactory<Object>() {
  43.          @Override
  44.          public Object getObject() throws BeansException {
  45.             return getEarlyBeanReference(beanName, mbd, bean);
  46.          }
  47.       });
  48.    }
  49.  
  50.    // Initialize the bean instance.
  51.    // 对Bean进行初始化，这个exposedObject在初始化以后会返回座位依赖注入完成后的Bean
  52.    Object exposedObject = bean;
  53.    try {
  54.       populateBean(beanName, mbd, instanceWrapper);
  55.       if (exposedObject != null) {
  56.          exposedObject = initializeBean(beanName, exposedObject, mbd);
  57.       }
  58.    }
  59.    catch (Throwable ex) {
  60.       if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  61.          throw (BeanCreationException) ex;
  62.       }
  63.       else {
  64.          throw new BeanCreationException(
  65.                mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  66.       }
  67.    }
  68.  
  69.    if (earlySingletonExposure) {
  70.       Object earlySingletonReference = getSingleton(beanName, false);
  71.       if (earlySingletonReference != null) {
  72.          if (exposedObject == bean) {
  73.             exposedObject = earlySingletonReference;
  74.          }
  75.          else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  76.             String[] dependentBeans = getDependentBeans(beanName);
  77.             Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
  78.             for (String dependentBean : dependentBeans) {
  79.                if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  80.                   actualDependentBeans.add(dependentBean);
  81.                }
  82.             }
  83.             if (!actualDependentBeans.isEmpty()) {
  84.                throw new BeanCurrentlyInCreationException(beanName,
  85.                      "Bean with name '" + beanName + "' has been injected into other beans [" +
  86.                      StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  87.                      "] in its raw version as part of a circular reference, but has eventually been " +
  88.                      "wrapped. This means that said other beans do not use the final version of the " +
  89.                      "bean. This is often the result of over-eager type matching - consider using " +
  90.                      "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
  91.             }
  92.          }
  93.       }
  94.    }
  95.  
  96.    // Register bean as disposable.
  97.    try {
  98.       registerDisposableBeanIfNecessary(beanName, bean, mbd);
  99.    }
  100.    catch (BeanDefinitionValidationException ex) {
  101.       throw new BeanCreationException(
  102.             mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  103.    }
  104.  
  105.    return exposedObject;
  106. }

看下真正创建Bean对象的方法createBeanInstance()，该方法会生成包含Java对象的Bean，这个Bean生成有很多

中方式，可以通过工厂方法生成，也可以通过容器的Autowire特性生成，这些生成方式都是由相关的BeanDefinition

来指定的。看下以下正在创建对象的源码。

AbstractAutowireCapableBeanFactory.createBeanInstance()方法源码：

  1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
  2.    // Make sure bean class is actually resolved at this point.
  3.    // 确认需要创建的Bean实例的类可以实例化
  4.    Class<?> beanClass = resolveBeanClass(mbd, beanName);
  5.   // 以下通过工厂方法对Bean进行实例化
  6.    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  7.       throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  8.             "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
  9.    }
  10.  
  11.    if (mbd.getFactoryMethodName() != null)  {
  12.       return instantiateUsingFactoryMethod(beanName, mbd, args);
  13.    }
  14.    
  15.    // Shortcut when re-creating the same bean...
  16.    // 重新创建Bean的快捷方式
  17.    boolean resolved = false;
  18.    boolean autowireNecessary = false;
  19.    if (args == null) {
  20.       synchronized (mbd.constructorArgumentLock) {
  21.          if (mbd.resolvedConstructorOrFactoryMethod != null) {
  22.             resolved = true;
  23.             autowireNecessary = mbd.constructorArgumentsResolved;
  24.          }
  25.       }
  26.    }
  27.    if (resolved) {
  28.       if (autowireNecessary) {
  29.          return autowireConstructor(beanName, mbd, null, null);
  30.       }
  31.       else {
  32.          return instantiateBean(beanName, mbd);
  33.       }
  34.    }
  35.  
  36.    // Need to determine the constructor...
  37.    // 以下使用构造函数对Bean进行实例化
  38.    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  39.    if (ctors != null ||
  40.          mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
  41.          mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
  42.       return autowireConstructor(beanName, mbd, ctors, args);
  43.    }
  44.  
  45.    // No special handling: simply use no-arg constructor.
  46.    // 使用默认的构造器函数对Bean进行实例化
  47.    return instantiateBean(beanName, mbd);
  48. }

instantiateBean()方法采用默认构造器实例化bean的过程。

AbstractAutowireCapableBeanFactory.instantiateBean()方法源码：

  1. protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
  2.    try {
  3.       Object beanInstance;
  4.       final BeanFactory parent = this;
  5.       if (System.getSecurityManager() != null) {
  6.          beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
  7.             @Override
  8.             public Object run() {
  9.                return getInstantiationStrategy().instantiate(mbd, beanName, parent);
  10.             }
  11.          }, getAccessControlContext());
  12.       }
  13.       else {
  14.          beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
  15.       }
  16.       BeanWrapper bw = new BeanWrapperImpl(beanInstance);
  17.       initBeanWrapper(bw);
  18.       return bw;
  19.    }
  20.    catch (Throwable ex) {
  21.       throw new BeanCreationException(
  22.             mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
  23.    }
  24. }

类中使用默认的实例化策略进行实例化，默认采用CGLIB对Bean进行实例化。CGLIB是一个常用的字节码

生成器的类库，它提供了一些列的API来提供生成和转换Java的字节码的功能。

SimpleInstantiationStrategy.instantiate()方法源码：

  1. @Override
  2. public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
  3.    // Don't override the class with CGLIB if no overrides.
  4.    if (bd.getMethodOverrides().isEmpty()) {
  5.       // 获取指定的构造器或者生产对象工厂方法来对Bean进行实例化
  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(new PrivilegedExceptionAction<Constructor<?>>() {
  17.                      @Override
  18.                      public Constructor<?> run() throws Exception {
  19.                         return clazz.getDeclaredConstructor((Class[]) null);
  20.                      }
  21.                   });
  22.                }
  23.                else {
  24.                   constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
  25.                }
  26.                bd.resolvedConstructorOrFactoryMethod = constructorToUse;
  27.             }
  28.             catch (Throwable ex) {
  29.                throw new BeanInstantiationException(clazz, "No default constructor found", ex);
  30.             }
  31.          }
  32.       }
  33.     // 通过BeanUtils进行实例化，这个BeanUtils实例化通过Constructor来实例化Bean，
  34.       // 在BeanUtils中可以看到具体的调用ctor.newInstance(args)
  35.       return BeanUtils.instantiateClass(constructorToUse);
  36.    }
  37.    else {
  38.       // Must generate CGLIB subclass.
  39.     // 使用CGLIB进行实例化
  40.       return instantiateWithMethodInjection(bd, beanName, owner);
  41.    }
  42. }

BeanUtils.instantiateClass()源码：

  1. public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
  2.    Assert.notNull(ctor, "Constructor must not be null");
  3.    try {
  4.       ReflectionUtils.makeAccessible(ctor);
  5.       return ctor.newInstance(args);
  6.    }
  7.    catch (InstantiationException ex) {
  8.       throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
  9.    }
  10.    catch (IllegalAccessException ex) {
  11.       throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
  12.    }
  13.    catch (IllegalArgumentException ex) {
  14.       throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
  15.    }
  16.    catch (InvocationTargetException ex) {
  17.       throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
  18.    }
  19. }

如果感兴趣，可以一直追溯newInstance()方法，最后调用一个Native方法创建对象。

到此，Bean对象创建完成。

参考文献

1、《Spring技术内幕》

2、《Spring实战》

3、Spring官网API

4、Spring源码

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/241555
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号