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

前言

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

本次接着上次的bean初始化、依賴注入接着介紹

 

正文

上一次跟蹤到這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#createOptionalDependency爲指定的依賴項建立一個包裝器

private Optional<?> createOptionalDependency(
         DependencyDescriptor descriptor, @Nullable String beanName, final Object... args) {

      DependencyDescriptor descriptorToUse = new NestedDependencyDescriptor(descriptor) {
         @Override
         public boolean isRequired() {
            return false;
         }
         @Override
         public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) {
            return (!ObjectUtils.isEmpty(args) ? beanFactory.getBean(beanName, args) :
                  super.resolveCandidate(beanName, requiredType, beanFactory));
         }
      };
//    解析依賴
      return Optional.ofNullable(doResolveDependency(descriptorToUse, beanName, null, null));
   }

找到這行代碼

//     解析依賴
      return Optional.ofNullable(doResolveDependency(descriptorToUse, beanName, null, null));

進入這個方法

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

@Nullable
   public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
         @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

//    獲取注入點
      InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
      try {
         Object shortcut = descriptor.resolveShortcut(this);
         if (shortcut != null) {
            return shortcut;
         }

         Class<?> type = descriptor.getDependencyType();
//       默認值沒有依賴
         Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
         if (value != null) {
            if (value instanceof String) {
               String strVal = resolveEmbeddedValue((String) value);
               BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
//             表達式解析
               value = evaluateBeanDefinitionString(strVal, bd);
            }
            TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
            return (descriptor.getField() != null ?
//                調用轉換器進行轉換
                  converter.convertIfNecessary(value, type, descriptor.getField()) :
                  converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
         }

         Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
         if (multipleBeans != null) {
            return multipleBeans;
         }

         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
         if (matchingBeans.isEmpty()) {
            if (isRequired(descriptor)) {
               raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
            }
            return null;
         }

         String autowiredBeanName;
         Object instanceCandidate;

         if (matchingBeans.size() > 1) {
            autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
            if (autowiredBeanName == null) {
//             找到不autowiredBeanName，報錯沒有惟一的bean
               if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
                  return descriptor.resolveNotUnique(type, matchingBeans);
               }
               else {
                  // In case of an optional Collection/Map, silently ignore a non-unique case:
                  // possibly it was meant to be an empty collection of multiple regular beans
                  // (before 4.3 in particular when we didn't even look for collection beans).
                  return null;
               }
            }
            instanceCandidate = matchingBeans.get(autowiredBeanName);
         }
         else {
            // We have exactly one match.
            Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
            autowiredBeanName = entry.getKey();
            instanceCandidate = entry.getValue();
         }

         if (autowiredBeanNames != null) {
            autowiredBeanNames.add(autowiredBeanName);
         }
         if (instanceCandidate instanceof Class) {
            instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
         }
         Object result = instanceCandidate;
         if (result instanceof NullBean) {
            if (isRequired(descriptor)) {
               raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
            }
            result = null;
         }
         if (!ClassUtils.isAssignableValue(type, result)) {
            throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
         }
         return result;
      }
      finally {
         ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
      }
   }

找到這個方法

//        解析多元化的bean注入 collection，map，array
         Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);

@Nullable
   private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
         @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {

      Class<?> type = descriptor.getDependencyType();
      if (type.isArray()) {
         Class<?> componentType = type.getComponentType();
         ResolvableType resolvableType = descriptor.getResolvableType();
         Class<?> resolvedArrayType = resolvableType.resolve();
         if (resolvedArrayType != null && resolvedArrayType != type) {
            type = resolvedArrayType;
            componentType = resolvableType.getComponentType().resolve();
         }
         if (componentType == null) {
            return null;
         }
//       查找自動注入的bean實例
         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
               new MultiElementDescriptor(descriptor));
         if (matchingBeans.isEmpty()) {
            return null;
         }
         if (autowiredBeanNames != null) {
            autowiredBeanNames.addAll(matchingBeans.keySet());
         }
         TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
         Object result = converter.convertIfNecessary(matchingBeans.values(), type);
         if (getDependencyComparator() != null && result instanceof Object[]) {
            Arrays.sort((Object[]) result, adaptDependencyComparator(matchingBeans));
         }
         return result;
      }
      else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
         Class<?> elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
         if (elementType == null) {
            return null;
         }
         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
               new MultiElementDescriptor(descriptor));
         if (matchingBeans.isEmpty()) {
            return null;
         }
         if (autowiredBeanNames != null) {
            autowiredBeanNames.addAll(matchingBeans.keySet());
         }
         TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
         Object result = converter.convertIfNecessary(matchingBeans.values(), type);
         if (getDependencyComparator() != null && result instanceof List) {
            ((List<?>) result).sort(adaptDependencyComparator(matchingBeans));
         }
         return result;
      }
      else if (Map.class == type) {
         ResolvableType mapType = descriptor.getResolvableType().asMap();
         Class<?> keyType = mapType.resolveGeneric(0);
         if (String.class != keyType) {
            return null;
         }
         Class<?> valueType = mapType.resolveGeneric(1);
         if (valueType == null) {
            return null;
         }
         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
               new MultiElementDescriptor(descriptor));
         if (matchingBeans.isEmpty()) {
            return null;
         }
         if (autowiredBeanNames != null) {
            autowiredBeanNames.addAll(matchingBeans.keySet());
         }
         return matchingBeans;
      }
      else {
         return null;
      }
   }

找到這一行代碼

//        查找自動注入的bean實例
         Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,

進入這個方法

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

protected Map<String, Object> findAutowireCandidates(
         @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {

      String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
            this, requiredType, true, descriptor.isEager());
      Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
      for (Class<?> autowiringType : this.resolvableDependencies.keySet()) {
         if (autowiringType.isAssignableFrom(requiredType)) {
            Object autowiringValue = this.resolvableDependencies.get(autowiringType);
//          動態代理獲取對象
            autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
            if (requiredType.isInstance(autowiringValue)) {
               result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
               break;
            }
         }
      }
      for (String candidate : candidateNames) {
         if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
            addCandidateEntry(result, candidate, descriptor, requiredType);
         }
      }
      if (result.isEmpty() && !indicatesMultipleBeans(requiredType)) {
         // Consider fallback matches if the first pass failed to find anything...若是第一次傳球沒有找到任何東西，能夠考慮退場。
         DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
         for (String candidate : candidateNames) {
            if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor)) {
               addCandidateEntry(result, candidate, descriptor, requiredType);
            }
         }
         if (result.isEmpty()) {
            // Consider self references as a final pass...把自我推薦看成最終的通行證……
            // but in the case of a dependency collection, not the very same bean itself.可是在依賴項集合的狀況下，不是很是相同的bean自己。
            for (String candidate : candidateNames) {
               if (isSelfReference(beanName, candidate) &&
                     (!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
                     isAutowireCandidate(candidate, fallbackDescriptor)) {
                  addCandidateEntry(result, candidate, descriptor, requiredType);
               }
            }
         }
      }
      return result;
   }

進入這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#getBeanNamesForType(java.lang.Class<?>, boolean, boolean)

@Override
public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
   if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
      return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
   }
   Map<Class<?>, String[]> cache =
         (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
   String[] resolvedBeanNames = cache.get(type);
   if (resolvedBeanNames != null) {
      return resolvedBeanNames;
   }
   resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
   if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {
      cache.put(type, resolvedBeanNames);
   }
   return resolvedBeanNames;
}

進入這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#doGetBeanNamesForType根據類型獲取beanNames

private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
      List<String> result = new ArrayList<>();

      // Check all bean definitions.檢查全部的bean定義
      for (String beanName : this.beanDefinitionNames) {
         // Only consider bean as eligible if the bean name
         // is not defined as alias for some other bean.
//       若是beanName不是別名
         if (!isAlias(beanName)) {
            try {
               RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
               // Only check bean definition if it is complete.
               if (!mbd.isAbstract() && (allowEagerInit ||
                     (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
                           !requiresEagerInitForType(mbd.getFactoryBeanName()))) {
                  // In case of FactoryBean, match object created by FactoryBean.在FactoryBean的狀況下，匹配由FactoryBean建立的對象。
                  boolean isFactoryBean = isFactoryBean(beanName, mbd);
                  BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
                  boolean matchFound =
                        (allowEagerInit || !isFactoryBean ||
                              (dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&
                        (includeNonSingletons ||
                              (dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&
                        isTypeMatch(beanName, type);
                  if (!matchFound && isFactoryBean) {
                     // In case of FactoryBean, try to match FactoryBean instance itself next. 在FactoryBean的狀況下，試着將FactoryBean實例自己與下一個進行匹配。
//                   beanName=&beanName
                     beanName = FACTORY_BEAN_PREFIX + beanName;
                     matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
                  }
                  if (matchFound) {
                     result.add(beanName);
                  }
               }
            }
            catch (CannotLoadBeanClassException ex) {
               if (allowEagerInit) {
                  throw ex;
               }
               // Probably contains a placeholder: let's ignore it for type matching purposes.
               if (this.logger.isDebugEnabled()) {
                  this.logger.debug("Ignoring bean class loading failure for bean '" + beanName + "'", ex);
               }
               onSuppressedException(ex);
            }
            catch (BeanDefinitionStoreException ex) {
               if (allowEagerInit) {
                  throw ex;
               }
               // Probably contains a placeholder: let's ignore it for type matching purposes.
               if (this.logger.isDebugEnabled()) {
                  this.logger.debug("Ignoring unresolvable metadata in bean definition '" + beanName + "'", ex);
               }
               onSuppressedException(ex);
            }
         }
      }

      // Check manually registered singletons too.
      for (String beanName : this.manualSingletonNames) {
         try {
            // In case of FactoryBean, match object created by FactoryBean.
            if (isFactoryBean(beanName)) {
               if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
                  result.add(beanName);
                  // Match found for this bean: do not match FactoryBean itself anymore.
                  continue;
               }
               // In case of FactoryBean, try to match FactoryBean itself next.
               beanName = FACTORY_BEAN_PREFIX + beanName;
            }
            // Match raw bean instance (might be raw FactoryBean).
            if (isTypeMatch(beanName, type)) {
               result.add(beanName);
            }
         }
         catch (NoSuchBeanDefinitionException ex) {
            // Shouldn't happen - probably a result of circular reference resolution...
            if (logger.isDebugEnabled()) {
               logger.debug("Failed to check manually registered singleton with name '" + beanName + "'", ex);
            }
         }
      }

      return StringUtils.toStringArray(result);
   }

返回到這個方法org.springframework.beans.factory.support.DefaultListableBeanFactory#findAutowireCandidates這一行代碼

//           jdk動態代理獲取對象
            autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);

public static Object resolveAutowiringValue(Object autowiringValue, Class<?> requiredType) {
   if (autowiringValue instanceof ObjectFactory && !requiredType.isInstance(autowiringValue)) {
      ObjectFactory<?> factory = (ObjectFactory<?>) autowiringValue;
      if (autowiringValue instanceof Serializable && requiredType.isInterface()) {
         autowiringValue = Proxy.newProxyInstance(requiredType.getClassLoader(),
               new Class<?>[] {requiredType}, new ObjectFactoryDelegatingInvocationHandler(factory));
      }
      else {
         return factory.getObject();
      }
   }
   return autowiringValue;
}

返回到這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#findAutowireCandidates這一行代碼

//     遍歷候選的beanName
      for (String candidate : candidateNames) {
//       候選的引用不是本身又是自動裝配的候選引用
         if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
            addCandidateEntry(result, candidate, descriptor, requiredType);
         }
      }

進入到這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#isAutowireCandidate(java.lang.String, org.springframework.beans.factory.config.DependencyDescriptor, org.springframework.beans.factory.support.AutowireCandidateResolver)

判斷這個bean是不是自動注入的候選項並進行依賴注入

protected boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor, AutowireCandidateResolver resolver)
         throws NoSuchBeanDefinitionException {

      String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
      if (containsBeanDefinition(beanDefinitionName)) {
//       判斷該bean是不是自動注入的候選項
         return isAutowireCandidate(beanName, getMergedLocalBeanDefinition(beanDefinitionName), descriptor, resolver);
      }
      else if (containsSingleton(beanName)) {
         return isAutowireCandidate(beanName, new RootBeanDefinition(getType(beanName)), descriptor, resolver);
      }

      BeanFactory parent = getParentBeanFactory();
      if (parent instanceof DefaultListableBeanFactory) {
         // No bean definition found in this factory -> delegate to parent.
         return ((DefaultListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor, resolver);
      }
      else if (parent instanceof ConfigurableListableBeanFactory) {
         // If no DefaultListableBeanFactory, can't pass the resolver along.
         return ((ConfigurableListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor);
      }
      else {
         return true;
      }
   }

進入這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#isAutowireCandidate(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, org.springframework.beans.factory.config.DependencyDescriptor, org.springframework.beans.factory.support.AutowireCandidateResolver)

protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
         DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {

      String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
//    將bean定義解析爲bean類
      resolveBeanClass(mbd, beanDefinitionName);
      if (mbd.isFactoryMethodUnique) {
         boolean resolve;
         synchronized (mbd.constructorArgumentLock) {
            resolve = (mbd.resolvedConstructorOrFactoryMethod == null);
         }
         if (resolve) {
            new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
         }
      }
      return resolver.isAutowireCandidate(
            new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
   }

進入這個方法

//           解析工廠方法
            new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);

public void resolveFactoryMethodIfPossible(RootBeanDefinition mbd) {
      Class<?> factoryClass;
      boolean isStatic;
      if (mbd.getFactoryBeanName() != null) {
         factoryClass = this.beanFactory.getType(mbd.getFactoryBeanName());
         isStatic = false;
      }
      else {
         factoryClass = mbd.getBeanClass();
         isStatic = true;
      }
      Assert.state(factoryClass != null, "Unresolvable factory class");
      factoryClass = ClassUtils.getUserClass(factoryClass);

//    查找給定bean定義的候選方法
      Method[] candidates = getCandidateMethods(factoryClass, mbd);
      Method uniqueCandidate = null;
      for (Method candidate : candidates) {
         if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
            if (uniqueCandidate == null) {
               uniqueCandidate = candidate;
            }
            else if (!Arrays.equals(uniqueCandidate.getParameterTypes(), candidate.getParameterTypes())) {
               uniqueCandidate = null;
               break;
            }
         }
      }
      synchronized (mbd.constructorArgumentLock) {
         mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
      }
   }

返回到這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#doResolveDependency這一行代碼

若是按照類型找到的bean是多個
         if (matchingBeans.size() > 1) {
//          獲取自動注入的beanName
            autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
            if (autowiredBeanName == null) {
//             找到不autowiredBeanName，報錯沒有惟一的bean
               if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
                  return descriptor.resolveNotUnique(type, matchingBeans);
               }

 

進入這個方法org.springframework.beans.factory.support.DefaultListableBeanFactory#determineAutowireCandidate

@Nullable
   protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
      Class<?> requiredType = descriptor.getDependencyType();
//    肯定的@Primary的候選項
      String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
      if (primaryCandidate != null) {
         return primaryCandidate;
      }
//    肯定@Priority的候選項，優先級底層是比較器實現
      String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
      if (priorityCandidate != null) {
         return priorityCandidate;
      }
      // Fallback
      for (Map.Entry<String, Object> entry : candidates.entrySet()) {
         String candidateName = entry.getKey();
         Object beanInstance = entry.getValue();
         if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
               matchesBeanName(candidateName, descriptor.getDependencyName())) {
            return candidateName;
         }
      }
      return null;
   }

返回到這個方法

org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency這一行代碼

//        返回延遲加載的代理對象
         Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
               descriptor, requestingBeanName);

返回到這個方法

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByType

註冊依賴bean
                  registerDependentBean(autowiredBeanName, beanName);

找到這個方法

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

//        初始化bean
         exposedObject = initializeBean(beanName, exposedObject, mbd);

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
      if (System.getSecurityManager() != null) {
         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
//          執行aware的方法
            invokeAwareMethods(beanName, bean);
            return null;
         }, getAccessControlContext());
      }
      else {
         invokeAwareMethods(beanName, bean);
      }

      Object wrappedBean = bean;
      if (mbd == null || !mbd.isSynthetic()) {
//       執行初始化以前的beanProccessors
         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
      }

      try {
//       執行初始化方法
         invokeInitMethods(beanName, wrappedBean, mbd);
      }
      catch (Throwable ex) {
         throw new BeanCreationException(
               (mbd != null ? mbd.getResourceDescription() : null),
               beanName, "Invocation of init method failed", ex);
      }
      if (mbd == null || !mbd.isSynthetic()) {
         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
      }

      return wrappedBean;
   }

這一行

//        執行初始化方法
         invokeInitMethods(beanName, wrappedBean, mbd);

進入org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeInitMethods

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
         throws Throwable {

//    是否實現了InitializingBean接口
      boolean isInitializingBean = (bean instanceof InitializingBean);
//    bean定義是否包含afterPropertiesSet這個方法
      if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
         if (logger.isDebugEnabled()) {
            logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
         }
         if (System.getSecurityManager() != null) {
            try {
               AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
//                執行afterPropertiesSet方法
                  ((InitializingBean) bean).afterPropertiesSet();
                  return null;
               }, getAccessControlContext());
            }
            catch (PrivilegedActionException pae) {
               throw pae.getException();
            }
         }
         else {
            ((InitializingBean) bean).afterPropertiesSet();
         }
      }

      if (mbd != null && bean.getClass() != NullBean.class) {
         String initMethodName = mbd.getInitMethodName();
         if (StringUtils.hasLength(initMethodName) &&
               !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
               !mbd.isExternallyManagedInitMethod(initMethodName)) {
//          執行客戶自定義的init方法
            invokeCustomInitMethod(beanName, bean, mbd);
         }
      }
   }

這一行

//           執行客戶自定義的init方法
            invokeCustomInitMethod(beanName, bean, mbd);

進入org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeCustomInitMethod

protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd)
         throws Throwable {

//    從bean定義中獲取初始化方法
      String initMethodName = mbd.getInitMethodName();
      Assert.state(initMethodName != null, "No init method set");
      final Method initMethod = (mbd.isNonPublicAccessAllowed() ?
            BeanUtils.findMethod(bean.getClass(), initMethodName) :
            ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));

      if (initMethod == null) {
         if (mbd.isEnforceInitMethod()) {
            throw new BeanDefinitionValidationException("Couldn't find an init method named '" +
                  initMethodName + "' on bean with name '" + beanName + "'");
         }
         else {
            if (logger.isDebugEnabled()) {
               logger.debug("No default init method named '" + initMethodName +
                     "' found on bean with name '" + beanName + "'");
            }
            // Ignore non-existent default lifecycle methods.
            return;
         }
      }

      if (logger.isDebugEnabled()) {
         logger.debug("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
      }

      if (System.getSecurityManager() != null) {
         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            ReflectionUtils.makeAccessible(initMethod);
            return null;
         });
         try {
            AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
//                執行初始化方法
               initMethod.invoke(bean), getAccessControlContext());
         }
         catch (PrivilegedActionException pae) {
            InvocationTargetException ex = (InvocationTargetException) pae.getException();
            throw ex.getTargetException();
         }
      }
      else {
         try {
            ReflectionUtils.makeAccessible(initMethod);
            initMethod.invoke(bean);
         }
         catch (InvocationTargetException ex) {
            throw ex.getTargetException();
         }
      }
   }

返回

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)這一行

//        執行bean初始化之後的beanProccessors
         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

下次繼續。

 

最後

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