Spring源码分析：非懒加载的单例Bean初始化过程（上）

上文【Spring源码分析】Bean加载流程概览，比较详细地分析了Spring上下文加载的代码入口，并且在AbstractApplicationContext的refresh方法中，点出了finishBeanFactoryInitialization方法完成了对于所有非懒加载的Bean的初始化。

finishBeanFactoryInitialization方法中调用了DefaultListableBeanFactory的preInstantiateSingletons方法，本文针对preInstantiateSingletons进行分析，解读一下Spring是如何初始化Bean实例对象出来的。

DefaultListableBeanFactory的preInstantiateSingletons方法

DefaultListableBeanFactory的preInstantiateSingletons方法，顾名思义，初始化所有的单例Bean，看一下方法的定义：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

public void preInstantiateSingletons() throws BeansException {     if (this.logger.isInfoEnabled()) {         this.logger.info("Pre-instantiating singletons in " + this);     }     synchronized (this.beanDefinitionMap) {         // Iterate over a copy to allow for init methods which in turn register new bean definitions.         // While this may not be part of the regular factory bootstrap, it does otherwise work fine.         List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);         for (String beanName : beanNames) {             RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);             if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {                 if (isFactoryBean(beanName)) {                     final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);                     boolean isEagerInit;                     if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {                         isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {                             public Boolean run() {                                 return ((SmartFactoryBean) factory).isEagerInit();                             }                         }, getAccessControlContext());                     }                     else {                         isEagerInit = (factory instanceof SmartFactoryBean &&                                 ((SmartFactoryBean) factory).isEagerInit());                     }                     if (isEagerInit) {                         getBean(beanName);                     }                 }                 else {                     getBean(beanName);                 }             }         }     } }

前面的代码比较简单，根据beanName拿到BeanDefinition（即Bean的定义）。由于此方法实例化的是所有非懒加载的单例Bean，因此要实例化Bean，必须满足11行的三个定义：

（1）不是抽象的

（2）必须是单例的

（3）必须是非懒加载的

接着简单看一下第12行~第29行的代码，这段代码主要做的是一件事情：首先判断一下Bean是否FactoryBean的实现，接着判断Bean是否SmartFactoryBean的实现，假如Bean是SmartFactoryBean的实现并且eagerInit（这个单词字面意思是渴望加载，找不到一个好的词语去翻译，意思就是定义了这个Bean需要立即加载的意思）的话，会立即实例化这个Bean。Java开发人员不需要关注这段代码，因为SmartFactoryBean基本不会用到，我翻译一下Spring官网对于SmartFactoryBean的定义描述：

• FactoryBean接口的扩展接口。接口实现并不表示是否总是返回单独的实例对象，比如FactoryBean.isSingleton()实现返回false的情况并不清晰地表示每次返回的都是单独的实例对象
• 不实现这个扩展接口的简单FactoryBean的实现，FactoryBean.isSingleton()实现返回false总是简单地告诉我们每次返回的都是单独的实例对象，暴露出来的对象只能够通过命令访问
• 注意：这个接口是一个有特殊用途的接口，主要用于框架内部使用与Spring相关。通常，应用提供的FactoryBean接口实现应当只需要实现简单的FactoryBean接口即可，新方法应当加入到扩展接口中去

代码示例

为了后面的代码分析方便，事先我定义一个Bean：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

package org.xrq.action;   import org.springframework.beans.factory.BeanClassLoaderAware; import org.springframework.beans.factory.BeanNameAware; import org.springframework.beans.factory.InitializingBean;   public class MultiFunctionBean implements InitializingBean, BeanNameAware, BeanClassLoaderAware {       private int    propertyA;       private int    propertyB;       public int getPropertyA() {         return propertyA;     }       public void setPropertyA(int propertyA) {         this.propertyA = propertyA;     }       public int getPropertyB() {         return propertyB;     }       public void setPropertyB(int propertyB) {         this.propertyB = propertyB;     }       public void initMethod() {         System.out.println("Enter MultiFunctionBean.initMethod()");     }       @Override     public void setBeanClassLoader(ClassLoader classLoader) {         System.out.println("Enter MultiFunctionBean.setBeanClassLoader(ClassLoader classLoader)");     }       @Override     public void setBeanName(String name) {         System.out.println("Enter MultiFunctionBean.setBeanName(String name)");     }       @Override     public void afterPropertiesSet() throws Exception {         System.out.println("Enter MultiFunctionBean.afterPropertiesSet()");     }       @Override     public String toString() {         return "MultiFunctionBean [propertyA=" + propertyA + ", propertyB=" + propertyB + "]";     }   }

定义对应的spring.xml：

1 2 3 4 5 6 7 8 9 10

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">       <bean id="multiFunctionBean" class="org.xrq.action.MultiFunctionBean" init-method="initMethod" />   </beans>

利用这个MultiFunctionBean，我们可以用来探究Spring加载Bean的多种机制。

doGetBean方法构造Bean流程

上面把getBean之外的代码都分析了一下，看代码就可以知道，获取Bean对象实例，都是通过getBean方法，getBean方法最终调用的是DefaultListableBeanFactory的父类AbstractBeanFactory类的doGetBean方法，因此这部分重点分析一下doGetBean方法是如何构造出一个单例的Bean的。

看一下doGetBean方法的代码实现，比较长：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136

protected <T> T doGetBean(         final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)         throws BeansException {       final String beanName = transformedBeanName(name);     Object bean;       // Eagerly check singleton cache for manually registered singletons.     Object sharedInstance = getSingleton(beanName);     if (sharedInstance != null && args == null) {         if (logger.isDebugEnabled()) {             if (isSingletonCurrentlyInCreation(beanName)) {                 logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +                         "' that is not fully initialized yet - a consequence of a circular reference");             }             else {                 logger.debug("Returning cached instance of singleton bean '" + beanName + "'");             }         }         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);     }       else {         // Fail if we're already creating this bean instance:         // We're assumably within a circular reference.         if (isPrototypeCurrentlyInCreation(beanName)) {             throw new BeanCurrentlyInCreationException(beanName);         }           // Check if bean definition exists in this factory.         BeanFactory parentBeanFactory = getParentBeanFactory();         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {             // Not found -> check parent.             String nameToLookup = originalBeanName(name);             if (args != null) {                 // Delegation to parent with explicit args.                 return (T) parentBeanFactory.getBean(nameToLookup, args);             }             else {                 // No args -> delegate to standard getBean method.                 return parentBeanFactory.getBean(nameToLookup, requiredType);             }         }           if (!typeCheckOnly) {             markBeanAsCreated(beanName);         }           final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);         checkMergedBeanDefinition(mbd, beanName, args);           // Guarantee initialization of beans that the current bean depends on.         String[] dependsOn = mbd.getDependsOn();         if (dependsOn != null) {             for (String dependsOnBean : dependsOn) {                 getBean(dependsOnBean);                 registerDependentBean(dependsOnBean, beanName);             }         }           // Create bean instance.         if (mbd.isSingleton()) {             sharedInstance = getSingleton(beanName, new ObjectFactory() {                 public Object getObject() throws BeansException {                     try {                         return createBean(beanName, mbd, args);                     }                     catch (BeansException ex) {                         // Explicitly remove instance from singleton cache: It might have been put there                         // eagerly by the creation process, to allow for circular reference resolution.                         // Also remove any beans that received a temporary reference to the bean.                         destroySingleton(beanName);                         throw ex;                     }                 }             });             bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);         }           else if (mbd.isPrototype()) {             // It's a prototype -> create a new instance.             Object prototypeInstance = null;             try {                 beforePrototypeCreation(beanName);                 prototypeInstance = createBean(beanName, mbd, args);             }             finally {                 afterPrototypeCreation(beanName);             }             bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);         }           else {             String scopeName = mbd.getScope();             final Scope scope = this.scopes.get(scopeName);             if (scope == null) {                 throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");             }             try {                 Object scopedInstance = scope.get(beanName, new ObjectFactory() {                     public Object getObject() throws BeansException {                             beforePrototypeCreation(beanName);                         try {                             return createBean(beanName, mbd, args);                         }                         finally {                             afterPrototypeCreation(beanName);                         }                     }                 });                 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);             }             catch (IllegalStateException ex) {                 throw new BeanCreationException(beanName,                         "Scope '" + scopeName + "' is not active for the current thread; " +                         "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",                         ex);             }         }     }       // Check if required type matches the type of the actual bean instance.     if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {         try {             return getTypeConverter().convertIfNecessary(bean, requiredType);         }         catch (TypeMismatchException ex) {             if (logger.isDebugEnabled()) {                 logger.debug("Failed to convert bean '" + name + "' to required type [" +                         ClassUtils.getQualifiedName(requiredType) + "]", ex);             }             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());         }     }     return (T) bean; }

首先第9行~第21行的代码，第9行的代码就不进去看了，简单说一下：首先检查一下本地的单例缓存是否已经加载过Bean，没有的话再检查earlySingleton缓存是否已经加载过Bean（又是early，不好找到词语翻译），没有的话执行后面的逻辑。

接着第26行~第50行，这里执行的都是一些基本的检查和简单的操作，包括bean是否是prototype的（prototype的Bean当前创建会抛出异常）、是否抽象的、将beanName加入alreadyCreated这个Set中等。

接着第53行~第59行，我们经常在bean标签中看到depends-on这个属性，就是通过这段保证了depends-on依赖的Bean会优先于当前Bean被加载。

接着第62行~第78行、第80行~第91行、第93行~第120行有三个判断，显然上面的MultiFunctionBean是一个单例的Bean也是本文探究的重点，因此执行第62行~第78行的逻辑。getSingleton方法不贴了，有一些前置的判断，很简单的逻辑，重点就是调用了ObjectFactory的getObject()方法来获取到单例Bean对象，方法的实现是调用了createBean方法，createBean方法是AbstractBeanFactory的子类AbstractAutowireCapableBeanFactory的一个方法，看一下它的方法实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)         throws BeanCreationException {       if (logger.isDebugEnabled()) {         logger.debug("Creating instance of bean '" + beanName + "'");     }     // Make sure bean class is actually resolved at this point.     resolveBeanClass(mbd, beanName);       // Prepare method overrides.     try {         mbd.prepareMethodOverrides();     }     catch (BeanDefinitionValidationException ex) {         throw new BeanDefinitionStoreException(mbd.getResourceDescription(),                 beanName, "Validation of method overrides failed", ex);     }       try {         // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.         Object bean = resolveBeforeInstantiation(beanName, mbd);         if (bean != null) {             return bean;         }     }     catch (Throwable ex) {         throw new BeanCreationException(mbd.getResourceDescription(), beanName,                 "BeanPostProcessor before instantiation of bean failed", ex);     }       Object beanInstance = doCreateBean(beanName, mbd, args);     if (logger.isDebugEnabled()) {         logger.debug("Finished creating instance of bean '" + beanName + "'");     }     return beanInstance; }

前面的代码都没什么意义，代码执行到第31行：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {     // Instantiate the bean.     BeanWrapper instanceWrapper = null;     if (mbd.isSingleton()) {         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);     }     if (instanceWrapper == null) {         instanceWrapper = createBeanInstance(beanName, mbd, args);     }     final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);     Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);       // Allow post-processors to modify the merged bean definition.     synchronized (mbd.postProcessingLock) {         if (!mbd.postProcessed) {             applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);             mbd.postProcessed = true;         }     }       // Eagerly cache singletons to be able to resolve circular references     // even when triggered by lifecycle interfaces like BeanFactoryAware.     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&             isSingletonCurrentlyInCreation(beanName));     if (earlySingletonExposure) {         if (logger.isDebugEnabled()) {             logger.debug("Eagerly caching bean '" + beanName +                     "' to allow for resolving potential circular references");         }         addSingletonFactory(beanName, new ObjectFactory() {             public Object getObject() throws BeansException {                 return getEarlyBeanReference(beanName, mbd, bean);             }         });     }       // Initialize the bean instance.     Object exposedObject = bean;     try {         populateBean(beanName, mbd, instanceWrapper);         if (exposedObject != null) {             exposedObject = initializeBean(beanName, exposedObject, mbd);         }     }     catch (Throwable ex) {         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {             throw (BeanCreationException) ex;         }         else {             throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", 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<String>(dependentBeans.length);                 for (String dependentBean : dependentBeans) {                     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {                         actualDependentBeans.add(dependentBean);                     }                 }                 if (!actualDependentBeans.isEmpty()) {                     throw new BeanCurrentlyInCreationException(beanName,                             "Bean with name '" + beanName + "' has been injected into other beans [" +                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +                             "] in its raw version as part of a circular reference, but has eventually been " +                             "wrapped. This means that said other beans do not use the final version of the " +                             "bean. This is often the result of over-eager type matching - consider using " +                             "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");                 }             }         }     }       // Register bean as disposable.     try {         registerDisposableBeanIfNecessary(beanName, bean, mbd);     }     catch (BeanDefinitionValidationException ex) {         throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);     }       return exposedObject; }

代码跟踪到这里，已经到了主流程，接下来分段分析doCreateBean方法的代码。

创建Bean实例

第8行的createBeanInstance方法，会创建出Bean的实例，并包装为BeanWrapper，看一下createBeanInstance方法，只贴最后一段比较关键的：

1 2 3 4 5 6 7 8 9 10

// Need to determine the constructor... Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null ||         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {     return autowireConstructor(beanName, mbd, ctors, args); }   // No special handling: simply use no-arg constructor. return instantiateBean(beanName, mbd);

意思是bean标签使用构造函数注入属性的话，执行第6行，否则执行第10行。MultiFunctionBean使用默认构造函数，使用setter注入属性，因此执行第10行代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {     try {         Object beanInstance;         final BeanFactory parent = this;         if (System.getSecurityManager() != null) {             beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {                 public Object run() {                     return getInstantiationStrategy().instantiate(mbd, beanName, parent);                 }             }, getAccessControlContext());         }         else {             beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);         }         BeanWrapper bw = new BeanWrapperImpl(beanInstance);         initBeanWrapper(bw);         return bw;     }     catch (Throwable ex) {         throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);     } }

代码执行到13行：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {     // Don't override the class with CGLIB if no overrides.     if (beanDefinition.getMethodOverrides().isEmpty()) {         Constructor<?> constructorToUse;         synchronized (beanDefinition.constructorArgumentLock) {             constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;             if (constructorToUse == null) {                 final Class clazz = beanDefinition.getBeanClass();                 if (clazz.isInterface()) {                     throw new BeanInstantiationException(clazz, "Specified class is an interface");                 }                 try {                     if (System.getSecurityManager() != null) {                         constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {                             public Constructor run() throws Exception {                                 return clazz.getDeclaredConstructor((Class[]) null);                             }                         });                     }                     else {                         constructorToUse = clazz.getDeclaredConstructor((Class[]) null);                     }                     beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;                 }                 catch (Exception ex) {                     throw new BeanInstantiationException(clazz, "No default constructor found", ex);                 }             }         }         return BeanUtils.instantiateClass(constructorToUse);     }     else {         // Must generate CGLIB subclass.         return instantiateWithMethodInjection(beanDefinition, beanName, owner);     } }

整段代码都在做一件事情，就是选择一个使用的构造函数。当然第9行顺带做了一个判断：实例化一个接口将报错。

最后调用到30行，看一下代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {     Assert.notNull(ctor, "Constructor must not be null");     try {         ReflectionUtils.makeAccessible(ctor);         return ctor.newInstance(args);     }     catch (InstantiationException ex) {         throw new BeanInstantiationException(ctor.getDeclaringClass(),                 "Is it an abstract class?", ex);     }     catch (IllegalAccessException ex) {         throw new BeanInstantiationException(ctor.getDeclaringClass(),                 "Is the constructor accessible?", ex);     }     catch (IllegalArgumentException ex) {         throw new BeanInstantiationException(ctor.getDeclaringClass(),                 "Illegal arguments for constructor", ex);     }     catch (InvocationTargetException ex) {         throw new BeanInstantiationException(ctor.getDeclaringClass(),                 "Constructor threw exception", ex.getTargetException());     } }

通过反射生成Bean的实例。看到前面有一步makeAccessible，这意味着即使Bean的构造函数是private、protected的，依然不影响Bean的构造。

最后注意一下，这里被实例化出来的Bean并不会直接返回，而是会被包装为BeanWrapper继续在后面使用。