spring源码分析之——spring bean的获取

前面分析了bean解析的过程,知道了bean都是以beandefinition的形式放在bean factory里面的。下面来看一下bean具体的获取过程。

 

Spring 提供了一个获取bean的工具方法:

WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc).getBean(String beanName);

OK,稍微追踪了一下代码,发现着落在了AbstraceBeanFactory下面:

Java代码  

  1. public Object getBean(String name) throws BeansException {  
  2.     return doGetBean(name, nullnullfalse);  
  3. }  
  4.        private <T> T doGetBean(  
  5.         final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)  
  6.         throws BeansException {  
  7.   
  8.     final String beanName = transformedBeanName(name);  
  9.     Object bean;  
  10.   
  11.     // Eagerly check singleton cache for manually registered singletons.  
  12.     Object sharedInstance = getSingleton(beanName);  
  13.     if (sharedInstance != null && args == null) {  
  14.         if (logger.isDebugEnabled()) {  
  15.             if (isSingletonCurrentlyInCreation(beanName)) {  
  16.                 logger.debug(“Returning eagerly cached instance of singleton bean ‘” + beanName +  
  17.                         “‘ that is not fully initialized yet – a consequence of a circular reference”);  
  18.             }  
  19.             else {  
  20.                 logger.debug(“Returning cached instance of singleton bean ‘” + beanName + “‘”);  
  21.             }  
  22.         }  
  23.         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);  
  24.     }  
  25.   
  26.     else {  
  27.         // Fail if we’re already creating this bean instance:  
  28.         // We’re assumably within a circular reference.  
  29.         if (isPrototypeCurrentlyInCreation(beanName)) {  
  30.             throw new BeanCurrentlyInCreationException(beanName);  
  31.         }  
  32.   
  33.         // Check if bean definition exists in this factory.  
  34.         BeanFactory parentBeanFactory = getParentBeanFactory();  
  35.         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {  
  36.             // Not found -> check parent.  
  37.             String nameToLookup = originalBeanName(name);  
  38.             if (args != null) {  
  39.                 // Delegation to parent with explicit args.  
  40.                 return (T) parentBeanFactory.getBean(nameToLookup, args);  
  41.             }  
  42.             else {  
  43.                 // No args -> delegate to standard getBean method.  
  44.                 return parentBeanFactory.getBean(nameToLookup, requiredType);  
  45.             }  
  46.         }  
  47.   
  48.         if (!typeCheckOnly) {  
  49.             markBeanAsCreated(beanName);  
  50.         }  
  51.   
  52.         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);  
  53.         checkMergedBeanDefinition(mbd, beanName, args);  
  54.   
  55.         // Guarantee initialization of beans that the current bean depends on.  
  56.         String[] dependsOn = mbd.getDependsOn();  
  57.         if (dependsOn != null) {  
  58.             for (String dependsOnBean : dependsOn) {  
  59.                 getBean(dependsOnBean);  
  60.                 registerDependentBean(dependsOnBean, beanName);  
  61.             }  
  62.         }  
  63.   
  64.         // Create bean instance.  
  65.         if (mbd.isSingleton()) {  
  66.             sharedInstance = getSingleton(beanName, new ObjectFactory() {  
  67.                 public Object getObject() throws BeansException {  
  68.                     try {  
  69.                         return createBean(beanName, mbd, args);  
  70.                     }  
  71.                     catch (BeansException ex) {  
  72.                         // Explicitly remove instance from singleton cache: It might have been put there  
  73.                         // eagerly by the creation process, to allow for circular reference resolution.  
  74.                         // Also remove any beans that received a temporary reference to the bean.  
  75.                         destroySingleton(beanName);  
  76.                         throw ex;  
  77.                     }  
  78.                 }  
  79.             });  
  80.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  
  81.         }  
  82.   
  83.         else if (mbd.isPrototype()) {  
  84.             // It’s a prototype -> create a new instance.  
  85.             Object prototypeInstance = null;  
  86.             try {  
  87.                 beforePrototypeCreation(beanName);  
  88.                 prototypeInstance = createBean(beanName, mbd, args);  
  89.             }  
  90.             finally {  
  91.                 afterPrototypeCreation(beanName);  
  92.             }  
  93.             bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);  
  94.         }  
  95.   
  96.         else {  
  97.             String scopeName = mbd.getScope();  
  98.             final Scope scope = this.scopes.get(scopeName);  
  99.             if (scope == null) {  
  100.                 throw new IllegalStateException(“No Scope registered for scope ‘” + scopeName + “‘”);  
  101.             }  
  102.             try {  
  103.                 Object scopedInstance = scope.get(beanName, new ObjectFactory() {  
  104.                     public Object getObject() throws BeansException {  
  105.                         beforePrototypeCreation(beanName);  
  106.                         try {  
  107.                             return createBean(beanName, mbd, args);  
  108.                         }  
  109.                         finally {  
  110.                             afterPrototypeCreation(beanName);  
  111.                         }  
  112.                     }  
  113.                 });  
  114.                 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);  
  115.             }  
  116.             catch (IllegalStateException ex) {  
  117.                 throw new BeanCreationException(beanName,  
  118.                         “Scope ‘” + scopeName + “‘ is not active for the current thread; “ +  
  119.                         “consider defining a scoped proxy for this bean if you intend to refer to it from a singleton”,  
  120.                         ex);  
  121.             }  
  122.         }  
  123.     }  
  124.   
  125.     // Check if required type matches the type of the actual bean instance.  
  126.     if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {  
  127.         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());  
  128.     }  
  129.     return (T) bean;  
  130. }  

   doGetBean….呃,好长的方法。慢慢研究一下。

   Object sharedInstance = getSingleton(beanName);

   这个方法首先去已经缓存了的Singleton里面寻找,如果没有,就到手工注入的singleton缓存里面寻找,如果没有,

   再到缓存的FactoryBean类型的singleton里面寻找,如果还没有…继续doGetBean里面的下一步。

 

   接下来如果当前beanfactory有parent,就到parentBeanFactory里面寻找,如果找不到,继续…

 

   接下来就是获取spring里面当初解析出来的bean模板:RootBeanDefinition。然后

   在当前factory下面注册一下依赖关系,下面就到了关键的步骤了,根据bean是singleton还是Prototype或者其他什么scope类型来分别定义bean的获取过程。下面以singleton为例来进行分析。

 

   注意一下代码:

 

Java代码  

  1. if (mbd.isSingleton()) {  
  2.                 sharedInstance = getSingleton(beanName, new ObjectFactory() {  
  3.                     public Object getObject() throws BeansException {  
  4.                         try {  
  5.                             return createBean(beanName, mbd, args);  
  6.                         }  
  7.                         catch (BeansException ex) {  
  8.                             // Explicitly remove instance from singleton cache: It might have been put there  
  9.                             // eagerly by the creation process, to allow for circular reference resolution.  
  10.                             // Also remove any beans that received a temporary reference to the bean.  
  11.                             destroySingleton(beanName);  
  12.                             throw ex;  
  13.                         }  
  14.                     }  
  15.                 });  
  16.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  
  17.             }  

 

    可见bean的生成委托给了createBean(name,mdb,args)方法。

    这个方法的实现是在子类AbstractAutowireCapableBeanFactory里面。

 

 

Java代码  

  1. protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)  
  2.             throws BeanCreationException {  
  3.   
  4.         if (logger.isDebugEnabled()) {  
  5.             logger.debug(“Creating instance of bean ‘” + beanName + “‘”);  
  6.         }  
  7.         // Make sure bean class is actually resolved at this point.  
  8.         resolveBeanClass(mbd, beanName);  
  9.   
  10.         // Prepare method overrides.  
  11.         try {  
  12.             mbd.prepareMethodOverrides();  
  13.         }  
  14.         catch (BeanDefinitionValidationException ex) {  
  15.             throw new BeanDefinitionStoreException(mbd.getResourceDescription(),  
  16.                     beanName, “Validation of method overrides failed”, ex);  
  17.         }  
  18.   
  19.         try {  
  20.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.  
  21.             Object bean = resolveBeforeInstantiation(beanName, mbd);  
  22.             if (bean != null) {  
  23.                 return bean;  
  24.             }  
  25.         }  
  26.         catch (Throwable ex) {  
  27.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,  
  28.                     “BeanPostProcessor before instantiation of bean failed”, ex);  
  29.         }  
  30.   
  31.         Object beanInstance = doCreateBean(beanName, mbd, args);  
  32.         if (logger.isDebugEnabled()) {  
  33.             logger.debug(“Finished creating instance of bean ‘” + beanName + “‘”);  
  34.         }  
  35.         return beanInstance;  
  36.     }  

 

   从上面的代码可以看出,先调用了resolveBeforeInstantiation方法。如果返回一个非空对象,那么就直接返回这个对象。 于是分析一下这个方法:

 

Java代码  

  1. protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {  
  2.         Object bean = null;  
  3.         if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {  
  4.             // Make sure bean class is actually resolved at this point.  
  5.             if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  
  6.                 bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);  
  7.                 if (bean != null) {  
  8.                     bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);  
  9.                 }  
  10.             }  
  11.             mbd.beforeInstantiationResolved = (bean != null);  
  12.         }  
  13.         return bean;  
  14.     }  

 

 

  是不是似曾相识哪?那就对了 ! Aop的实现的核心啊,回想一下AbstractAutoProxyCreator,就是实现了InstantiationAwareBeanPostProcessor接口。从AbstractAutoProxyCreator的postProcessBeforeInstantiation代码可以很容易的看出,如果bean需要代理,那么返回一个代理类,否则返回Null.

 结合当前代码,那就是如果产生了代理类,那么试着调用beanpostprocessors的postProcessAfterInitialization方法,然后返回这个代理类。从这里也可以看出,如果被代理的类定义了postProcessBeforeInitialization,init等方法,将根本没有调用的机会! 所以被代理类在实现BeanPostProcessor,InitilizingBean等接口时要非常小心。否则可能发现有些方法根本没有回调。

 

当然了,不一定非要产生代理类,也有可能有其他的实现了InstantiationAwareBeanPostProcessor接口的类也返回非空,这里就不详细分析。我大致看了一下,至少我看的几个实现了InstantiationAwareBeanPostProcessor接口的类是返回null的,除了AbstractAutoProxyCreator.

 

下面继续。如果调用InstantiationAwareBeanPostProcessor后依然返回Null,那么就继续下面的步骤,也就是激动人心的bean的instantiation过程了!这里是调用了doCreateBean(beanName, mbd, args)方法:

 

 

Java代码  

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {  
  2.         // Instantiate the bean.  
  3.         BeanWrapper instanceWrapper = null;  
  4.         if (mbd.isSingleton()) {  
  5.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
  6.         }  
  7.         if (instanceWrapper == null) {  
  8.             instanceWrapper = createBeanInstance(beanName, mbd, args);  
  9.         }  
  10.         final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);  
  11.         Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);  
  12.   
  13.         // Allow post-processors to modify the merged bean definition.  
  14.         synchronized (mbd.postProcessingLock) {  
  15.             if (!mbd.postProcessed) {  
  16.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
  17.                 mbd.postProcessed = true;  
  18.             }  
  19.         }  
  20.   
  21.         // Eagerly cache singletons to be able to resolve circular references  
  22.         // even when triggered by lifecycle interfaces like BeanFactoryAware.  
  23.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&  
  24.                 isSingletonCurrentlyInCreation(beanName));  
  25.         if (earlySingletonExposure) {  
  26.             if (logger.isDebugEnabled()) {  
  27.                 logger.debug(“Eagerly caching bean ‘” + beanName +  
  28.                         “‘ to allow for resolving potential circular references”);  
  29.             }  
  30.             addSingletonFactory(beanName, new ObjectFactory() {  
  31.                 public Object getObject() throws BeansException {  
  32.                     return getEarlyBeanReference(beanName, mbd, bean);  
  33.                 }  
  34.             });  
  35.         }  
  36.   
  37.         // Initialize the bean instance.  
  38.         Object exposedObject = bean;  
  39.         try {  
  40.             populateBean(beanName, mbd, instanceWrapper);  
  41.             if (exposedObject != null) {  
  42.                 exposedObject = initializeBean(beanName, exposedObject, mbd);  
  43.             }  
  44.         }  
  45.         catch (Throwable ex) {  
  46.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {  
  47.                 throw (BeanCreationException) ex;  
  48.             }  
  49.             else {  
  50.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName, “Initialization of bean failed”, ex);  
  51.             }  
  52.         }  
  53.   
  54.         if (earlySingletonExposure) {  
  55.             Object earlySingletonReference = getSingleton(beanName, false);  
  56.             if (earlySingletonReference != null) {  
  57.                 if (exposedObject == bean) {  
  58.                     exposedObject = earlySingletonReference;  
  59.                 }  
  60.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {  
  61.                     String[] dependentBeans = getDependentBeans(beanName);  
  62.                     Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);  
  63.                     for (String dependentBean : dependentBeans) {  
  64.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {  
  65.                             actualDependentBeans.add(dependentBean);  
  66.                         }  
  67.                     }  
  68.                     if (!actualDependentBeans.isEmpty()) {  
  69.                         throw new BeanCurrentlyInCreationException(beanName,  
  70.                                 “Bean with name ‘” + beanName + “‘ has been injected into other beans [“ +  
  71.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +  
  72.                                 “] in its raw version as part of a circular reference, but has eventually been “ +  
  73.                                 “wrapped. This means that said other beans do not use the final version of the “ +  
  74.                                 “bean. This is often the result of over-eager type matching – consider using “ +  
  75.                                 “‘getBeanNamesOfType’ with the ‘allowEagerInit’ flag turned off, for example.”);  
  76.                     }  
  77.                 }  
  78.             }  
  79.         }  
  80.   
  81.         // Register bean as disposable.  
  82.         try {  
  83.             registerDisposableBeanIfNecessary(beanName, bean, mbd);  
  84.         }  
  85.         catch (BeanDefinitionValidationException ex) {  
  86.             throw new BeanCreationException(mbd.getResourceDescription(), beanName, “Invalid destruction signature”, ex);  
  87.         }  
  88.   
  89.         return exposedObject;  
  90.     }  

 

    汗~又是一个长方法。慢慢分析。

    这个方法大致分为这么几步:

    1. 产生一个beanwrapper.

    2. 调用实现了MergedBeanDefinitionPostProcessors接口的类

    3. populateBean

    4. 初始化bean

    5. 注册产生的bean

    下面分别就前几个步骤进行分析。

   1.  产生beanwrapper

 

Java代码  

  1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {  
  2.         // Make sure bean class is actually resolved at this point.  
  3.         Class beanClass = resolveBeanClass(mbd, beanName);  
  4.   
  5.         if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {  
  6.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,  
  7.                     “Bean class isn’t public, and non-public access not allowed: “ + beanClass.getName());  
  8.         }  
  9.   
  10.         if (mbd.getFactoryMethodName() != null)  {  
  11.             return instantiateUsingFactoryMethod(beanName, mbd, args);  
  12.         }  
  13.   
  14.         // Shortcut when re-creating the same bean…  
  15.         if (mbd.resolvedConstructorOrFactoryMethod != null && args == null) {  
  16.             if (mbd.constructorArgumentsResolved) {  
  17.                 return autowireConstructor(beanName, mbd, nullnull);  
  18.             }  
  19.             else {  
  20.                 return instantiateBean(beanName, mbd);  
  21.             }  
  22.         }  
  23.   
  24.         // Need to determine the constructor…  
  25.         Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);  
  26.         if (ctors != null ||  
  27.                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||  
  28.                 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {  
  29.             return autowireConstructor(beanName, mbd, ctors, args);  
  30.         }  
  31.   
  32.         // No special handling: simply use no-arg constructor.  
  33.         return instantiateBean(beanName, mbd);  
  34.     }  

 

   在这里可以看出,如果为bean定义了factoryMehtod或者constructor,那么将分别根据factoryMethod或construcgtor完成bean的初始化。否则调用如下方法:

 

Java代码  

  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.                     public Object run() {  
  8.                         return getInstantiationStrategy().instantiate(mbd, beanName, parent);  
  9.                     }  
  10.                 }, getAccessControlContext());  
  11.             }  
  12.             else {  
  13.                 beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);  
  14.             }  
  15.             BeanWrapper bw = new BeanWrapperImpl(beanInstance);  
  16.             initBeanWrapper(bw);  
  17.             return bw;  
  18.         }  
  19.         catch (Throwable ex) {  
  20.             throw new BeanCreationException(mbd.getResourceDescription(), beanName, “Instantiation of bean failed”, ex);  
  21.         }  
  22.     }  

 

    这里有一个InstantiationStrategy接口,这个接口定了bean初始化的策略。比如在

    当前类AbstractAutowireCapableBeanFactory下面一开始就定义了一个变量:

 

Java代码  

  1. private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();  

   可见,默认的初始化策略是CglibSubclassingInstantiationStrategy。

    这个策略的特殊之处就在于如果bean需要有method injection,那么就通过cglib代理的方式产生原本的bean class的一个子类从而实现method override.

   OK,至此BeanWrapper的生成基本清晰了。

 

下面就是实现了MergedBeanDefinitionPostProcessors的类的调用了。这个接口的具体意思我还不是很清楚。稍后研究一下补全。

 

然后就是populateBean. 这个方法就是把BeanDefinition里面维护的bean的属性populate到beanwrapper里面。

 

接下来就是bean的初始化:

 if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);

 

了解bean的初始化流程还是蛮有意义的:

 

Java代码  

  1. protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {  
  2.         if (System.getSecurityManager() != null) {  
  3.             AccessController.doPrivileged(new PrivilegedAction<Object>() {  
  4.                 public Object run() {  
  5.                     invokeAwareMethods(beanName, bean);  
  6.                     return null;  
  7.                 }  
  8.             }, getAccessControlContext());  
  9.         }  
  10.         else {  
  11.             invokeAwareMethods(beanName, bean);  
  12.         }  
  13.           
  14.         Object wrappedBean = bean;  
  15.         if (mbd == null || !mbd.isSynthetic()) {  
  16.             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
  17.         }  
  18.   
  19.         try {  
  20.             invokeInitMethods(beanName, wrappedBean, mbd);  
  21.         }  
  22.         catch (Throwable ex) {  
  23.             throw new BeanCreationException(  
  24.                     (mbd != null ? mbd.getResourceDescription() : null),  
  25.                     beanName, “Invocation of init method failed”, ex);  
  26.         }  
  27.   
  28.         if (mbd == null || !mbd.isSynthetic()) {  
  29.             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
  30.         }  
  31.         return wrappedBean;  
  32.     }  

 

   可见初始化顺序是: XXAware接口的实现->postProcessBeforeInitialization->InitializingBean的afterPropertiesSet-> custom Init方法->postProcessAfterInitialization

  OK.这就是bean初始化的顺序啦!

  最后当然就是bean的注册了!

 

Java代码  

  1. protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {  
  2.         AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);  
  3.         if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {  
  4.             if (mbd.isSingleton()) {  
  5.                 // Register a DisposableBean implementation that performs all destruction  
  6.                 // work for the given bean: DestructionAwareBeanPostProcessors,  
  7.                 // DisposableBean interface, custom destroy method.  
  8.                 registerDisposableBean(beanName,  
  9.                         new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));  
  10.             }  
  11.             else {  
  12.                 // A bean with a custom scope…  
  13.                 Scope scope = this.scopes.get(mbd.getScope());  
  14.                 if (scope == null) {  
  15.                     throw new IllegalStateException(“No Scope registered for scope ‘” + mbd.getScope() + “‘”);  
  16.                 }  
  17.                 scope.registerDestructionCallback(beanName,  
  18.                         new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));  
  19.             }  
  20.         }  
  21.     }  

 

   这里面涉及到了bean以及与scope相关的生命周期的管理,需要单独分析一下。下篇文章再分析。

    原文作者:Spring Boot
    原文地址: https://blog.csdn.net/notOnlyRush/article/details/49803341
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞