前言

本文转自“天河聊技术”微信公众号

本次接着上次的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
    
      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
     
       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
      
        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
    
      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
     
       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
      
        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
       
         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
    
      matchingBeans = findAutowireCandidates(beanName, componentType,
    

进入这个方法

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

protected Map
    
      findAutowireCandidates(         @Nullable String beanName, Class
      requiredType, DependencyDescriptor descriptor) {      String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(            this, requiredType, true, descriptor.isEager());      Map
     
       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)

@Overridepublic String[] getBeanNamesForType(@Nullable Class
     type, boolean includeNonSingletons, boolean allowEagerInit) {   if (!isConfigurationFrozen() || type == null || !allowEagerInit) {      return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);   }   Map
    
     , 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
    
      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
    
      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
     
       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

这一行

//        执行初始化方法         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

这一行

//           执行客户自定义的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

返回

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);

下次继续。

 

最后

本次介绍到这里，以上内容仅供参考。