spring源碼解析bean初始化與依賴注入一

前言

本文轉自「天河聊技術」微信公衆號

本次主要介紹bean初始化與依賴注入

 

正文

找到這個方法org.springframework.context.support.AbstractApplicationContext#refresh這行代碼

finishBeanFactoryInitialization(beanFactory);

初始化非延遲初始化的單例對象。

 

進入到這個方法

org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
      // Initialize conversion service for this context.爲上下文設置轉換服務
      if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
//       給beanFactory設置轉換器
         beanFactory.setConversionService(
               beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
      }

      // Register a default embedded value resolver if no bean post-processor
      // (such as a PropertyPlaceholderConfigurer bean) registered any before:
      // at this point, primarily for resolution in annotation attribute values.
//    注入嵌入式值解析器
      if (!beanFactory.hasEmbeddedValueResolver()) {
         beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
      }

      // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. 初始化LoadTimeWeaverAware bean
      String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
      for (String weaverAwareName : weaverAwareNames) {
         getBean(weaverAwareName);
      }

      // Stop using the temporary ClassLoader for type matching.中止使用臨時類加載器進行類型匹配。
      beanFactory.setTempClassLoader(null);

      // Allow for caching all bean definition metadata, not expecting further changes.容許緩存全部bean定義元數據，而不指望進一步更改。
      beanFactory.freezeConfiguration();

      // Instantiate all remaining (non-lazy-init) singletons.實例化全部剩餘的(非延遲-init)單例。
      beanFactory.preInstantiateSingletons();
   }

找到這行代碼

beanFactory.preInstantiateSingletons();

實例化非延遲加載的單例bean

進入到這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons

@Override
   public void preInstantiateSingletons() throws BeansException {
      if (this.logger.isDebugEnabled()) {
         this.logger.debug("Pre-instantiating singletons in " + this);
      }

      // 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.
//    迭代一個副本，以容許init方法，它反過來註冊新的bean定義。雖然這可能不是常規工廠引導的一部分，但它能夠正常工做。
      List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

      // Trigger initialization of all non-lazy singleton beans...觸發當即加載的bean初始化
      for (String beanName : beanNames) {
         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//       非抽象、非延遲加載的bean當即加載
         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
               Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
               if (bean instanceof FactoryBean) {
                  final FactoryBean<?> factory = (FactoryBean<?>) bean;
                  boolean isEagerInit;
                  if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                     isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                 ((SmartFactoryBean<?>) factory)::isEagerInit,
                           getAccessControlContext());
                  }
                  else {
                     isEagerInit = (factory instanceof SmartFactoryBean &&
                           ((SmartFactoryBean<?>) factory).isEagerInit());
                  }
                  if (isEagerInit) {
                     getBean(beanName);
                  }
               }
            }
            else {
               getBean(beanName);
            }
         }
      }

      // Trigger post-initialization callback for all applicable beans...爲全部適用的bean觸發後初始化回調…
      for (String beanName : beanNames) {
         Object singletonInstance = getSingleton(beanName);
         if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
               AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
//                單例bean建立完成後回調
                  smartSingleton.afterSingletonsInstantiated();
                  return null;
               }, getAccessControlContext());
            }
            else {
               smartSingleton.afterSingletonsInstantiated();
            }
         }
      }
   }

找到這行代碼

若是是當即加載
                  if (isEagerInit) {
                     getBean(beanName);
                  }

org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)

@Override
public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

進入這個方法

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
         @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

      final String beanName = transformedBeanName(name);
      Object bean;

      // Eagerly check singleton cache for manually registered singletons.爲手動註冊的singleton檢查單例緩存。
      Object sharedInstance = getSingleton(beanName);
      if (sharedInstance != null && args == null) {
         if (logger.isDebugEnabled()) {
//          bean是否正在建立
            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();
//       檢查bean定義是否在beanFactory
         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.beanName=&beanName
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
//             遞歸調用
               return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                     nameToLookup, requiredType, args, typeCheckOnly);
            }
            else 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);
         }

         try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.當前依賴的bean初始化
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
               for (String dep : dependsOn) {
//                肯定依賴的bean是否已經初始化
                  if (isDependent(beanName, dep)) {
                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                           "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                  }
//                註冊依賴的bean
                  registerDependentBean(dep, beanName);
//                遞歸調用
                  getBean(dep);
               }
            }

            // Create bean instance.建立bean對象
            if (mbd.isSingleton()) {
               sharedInstance = getSingleton(beanName, () -> {
                  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()) {
//             bean定義爲原型模式
               // 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 name '" + scopeName + "'");
               }
               try {
                  Object scopedInstance = scope.get(beanName, () -> {
                     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);
               }
            }
         }
         catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
         }
      }

      // Check if required type matches the type of the actual bean instance.檢查所需類型是否與實際bean實例的類型匹配。
      if (requiredType != null && !requiredType.isInstance(bean)) {
         try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
               throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
         }
         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;
   }

找到這行代碼

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

protected Object getObjectForBeanInstance(
         Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

      // Don't let calling code try to dereference the factory if the bean isn't a factory.//若是bean不是工廠，不要讓調用代碼破壞工廠。
      if (BeanFactoryUtils.isFactoryDereference(name)) {
         if (beanInstance instanceof NullBean) {
            return beanInstance;
         }
         if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
         }
      }

      // Now we have the bean instance, which may be a normal bean or a FactoryBean.
      // If it's a FactoryBean, we use it to create a bean instance, unless the
      // caller actually wants a reference to the factory.
      //如今咱們有了bean實例，它多是一個普通的bean或一個FactoryBean。
//若是它是一個FactoryBean，咱們使用它來建立一個bean實例，除非。
//打電話的人實際上想要一個關於工廠的資料。
      if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
         return beanInstance;
      }

      Object object = null;
      if (mbd == null) {
//       先從緩存中獲取對象
         object = getCachedObjectForFactoryBean(beanName);
      }
      if (object == null) {
         // Return bean instance from factory.
         FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
         // Caches object obtained from FactoryBean if it is a singleton.從FactoryBean中獲取的緩存對象，若是它是一個單例對象。
         if (mbd == null && containsBeanDefinition(beanName)) {
            mbd = getMergedLocalBeanDefinition(beanName);
         }
         boolean synthetic = (mbd != null && mbd.isSynthetic());
//       從factoryBean中獲取對象
         object = getObjectFromFactoryBean(factory, beanName, !synthetic);
      }
      return object;
   }

找到這行代碼

//        先從緩存中獲取對象
         object = getCachedObjectForFactoryBean(beanName);

若是是factoryBean，從中緩存中獲取對象

找到這行代碼

object = getObjectFromFactoryBean(factory, beanName, !synthetic);

若是緩存中沒有就從beanFactory中獲取

進入這個方法

org.springframework.beans.factory.support.FactoryBeanRegistrySupport#getObjectFromFactoryBean

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//    若是單例對象
      if (factory.isSingleton() && containsSingleton(beanName)) {
         synchronized (getSingletonMutex()) {
//          先從緩存中獲取
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
//             從factoryBean中獲取
               object = doGetObjectFromFactoryBean(factory, beanName);
               // Only post-process and store if not put there already during getObject() call above
               // (e.g. because of circular reference processing triggered by custom getBean calls)
               Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
               if (alreadyThere != null) {
                  object = alreadyThere;
               }
               else {
//                是否須要後續處理
                  if (shouldPostProcess) {
                     try {
                        object = postProcessObjectFromFactoryBean(object, beanName);
                     }
                     catch (Throwable ex) {
                        throw new BeanCreationException(beanName,
                              "Post-processing of FactoryBean's singleton object failed", ex);
                     }
                  }
                  this.factoryBeanObjectCache.put(beanName, object);
               }
            }
            return object;
         }
      }
      else {
         Object object = doGetObjectFromFactoryBean(factory, beanName);
         if (shouldPostProcess) {
            try {
               object = postProcessObjectFromFactoryBean(object, beanName);
            }
            catch (Throwable ex) {
               throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
            }
         }
         return object;
      }
   }

返回到這個方法

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean這一行代碼

註冊依賴的bean
                  registerDependentBean(dep, beanName);

找到這一行代碼

return createBean(beanName, mbd, args);

進入這個方法

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])

@Override
   protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
         throws BeanCreationException {

      if (logger.isDebugEnabled()) {
         logger.debug("Creating instance of bean '" + beanName + "'");
      }
      RootBeanDefinition mbdToUse = mbd;

      // Make sure bean class is actually resolved at this point, and
      // clone the bean definition in case of a dynamically resolved Class
      // which cannot be stored in the shared merged bean definition.
      Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
      if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
         mbdToUse = new RootBeanDefinition(mbd);
         mbdToUse.setBeanClass(resolvedClass);
      }

      // Prepare method overrides.
      try {
         mbdToUse.prepareMethodOverrides();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(mbdToUse.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, mbdToUse);
         if (bean != null) {
            return bean;
         }
      }
      catch (Throwable ex) {
         throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
               "BeanPostProcessor before instantiation of bean failed", ex);
      }

      try {
//       bean建立
         Object beanInstance = doCreateBean(beanName, mbdToUse, args);
         if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean '" + beanName + "'");
         }
         return beanInstance;
      }
      catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
         // A previously detected exception with proper bean creation context already,
         // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
         throw ex;
      }
      catch (Throwable ex) {
         throw new BeanCreationException(
               mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
      }
   }

找到這行代碼

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

bean初始化以前的一些操做，主要是對beanProccessors的處理

@Nullable
   protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
      Object bean = null;
      if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
         // Make sure bean class is actually resolved at this point.
         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
//             調用bean初始化前處理器
               bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
               if (bean != null) {
//                bean初始化之後調用處理器
                  bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
               }
            }
         }
         mbd.beforeInstantiationResolved = (bean != null);
      }
      return bean;
   }

找到這一行代碼

//        bean建立
         Object beanInstance = doCreateBean(beanName, mbdToUse, args);

下次接着介紹。

 

 

最後

 

本次介紹到這裏，以上內容僅供參考。