当前位置：
首页
文章
前端
详情

spring源码解析bean初始化与依赖注入二

  • 前端
  • Easter79
  • 0

前言

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

本次接着上次的介绍来解析bean初始化和依赖注入

正文

上一次跟踪到这个方法

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

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

// Instantiate the bean.   BeanWrapper instanceWrapper = null;   if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);   } if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args);   } final Object bean = instanceWrapper.getWrappedInstance();   Class<?> beanType = instanceWrapper.getWrappedClass();   if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType;   }

// Allow post-processors to modify the merged bean definition.允许后处理器修改合并后的bean定义。   synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);         } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName,                  "Post-processing of merged bean definition failed", ex);         } mbd.postProcessed = true;      } }

// Eagerly cache singletons to be able to resolve circular references   // even when triggered by lifecycle interfaces like BeanFactoryAware.   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));   if (earlySingletonExposure) { if (logger.isDebugEnabled()) { logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");      } addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));   }

// Initialize the bean instance.   Object exposedObject = bean;   try { populateBean(beanName, mbd, instanceWrapper);      exposedObject = initializeBean(beanName, exposedObject, mbd);   } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex;      } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);      } }

if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false);      if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference;         } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName);            Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);            for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean);               } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName,                     "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");            } } } }

// Register bean as disposable.bean注册为一次性。   try { registerDisposableBeanIfNecessary(beanName, bean, mbd);   } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);   }

return exposedObject; }

找到这行代码

//        创建bean对象         instanceWrapper = createBeanInstance(beanName, mbd, args);

进入到这个方法

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

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { // Make sure bean class is actually resolved at this point.      Class<?> beanClass = resolveBeanClass(mbd, beanName);

//    类必须是public，构造方法必须是public      if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName,               "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());      }

  Supplier<?> instanceSupplier = mbd.getInstanceSupplier();

     if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName);      }

//    如果工厂方法不为空，就用工厂方法创建bean      if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args);      }

  // Shortcut when re-creating the same bean...

     boolean resolved = false;      boolean autowireNecessary = false;      if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true;               autowireNecessary = mbd.constructorArgumentsResolved;            } } } if (resolved) { if (autowireNecessary) { return autowireConstructor(beanName, mbd, null, null);         } else { return instantiateBean(beanName, mbd);         } }

  // Need to determine the constructor...

     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);      if (ctors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { //       构造参数注入         return autowireConstructor(beanName, mbd, ctors, args);      }

  // No special handling: simply use no-arg constructor.无需特殊处理:只需使用无arg构造函数。

     return instantiateBean(beanName, mbd);   }

找到这一行代码

//     如果工厂方法不为空，就用工厂方法创建bean      if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args);      }

优先使用工厂方法创建bean对象

进入这个方法

org.springframework.beans.factory.support.ConstructorResolver#instantiateUsingFactoryMethod

这一行代码

//        默认类型自动装配，判断是否是构造参数装配         boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);

找到这一行代码

beanInstance = this.beanFactory.getInstantiationStrategy().instantiate( mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);

执行工厂方法创建对象

返回到这个方法

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance这一行代码

   构造方法注入            return autowireConstructor(beanName, mbd, null, null);

进入这个方法

org.springframework.beans.factory.support.ConstructorResolver#autowireConstructor

public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,         @Nullable Constructor<?>[] chosenCtors, @Nullable final Object[] explicitArgs) {

  BeanWrapperImpl bw = new BeanWrapperImpl();

     this.beanFactory.initBeanWrapper(bw);

     Constructor<?> constructorToUse = null;      ArgumentsHolder argsHolderToUse = null;      Object[] argsToUse = null;

     if (explicitArgs != null) { argsToUse = explicitArgs;      } else { Object[] argsToResolve = null;         synchronized (mbd.constructorArgumentLock) { constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;            if (constructorToUse != null && mbd.constructorArgumentsResolved) { // Found a cached constructor...               argsToUse = mbd.resolvedConstructorArguments;               if (argsToUse == null) { argsToResolve = mbd.preparedConstructorArguments;               } } } if (argsToResolve != null) { //          解析bean定义中的方法            argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);         } }

  if (constructorToUse == null) {
     // Need to resolve the constructor.判断是否是构造参数注入

        boolean autowiring = (chosenCtors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);         ConstructorArgumentValues resolvedValues = null;

        int minNrOfArgs;         if (explicitArgs != null) { minNrOfArgs = explicitArgs.length;         } else { ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();            resolvedValues = new ConstructorArgumentValues(); //          解析构造参数            minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);         }

     // Take specified constructors, if any.使用指定的构造函数(如果有的话)。

        Constructor\[\] candidates = chosenCtors;         if (candidates == null) { Class beanClass = mbd.getBeanClass();            try { candidates = (mbd.isNonPublicAccessAllowed() ? beanClass.getDeclaredConstructors() : beanClass.getConstructors());            } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName,                     "Resolution of declared constructors on bean Class [" + beanClass.getName() + "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);            } } AutowireUtils.sortConstructors(candidates);         int minTypeDiffWeight = Integer.MAX_VALUE;         Set<Constructor<?>> ambiguousConstructors = null;         LinkedList causes = null;

        for (Constructor candidate : candidates) { Class[] paramTypes = candidate.getParameterTypes();

           if (constructorToUse != null && argsToUse.length > paramTypes.length) { // Already found greedy constructor that can be satisfied ->               // do not look any further, there are only less greedy constructors left.               break;            } if (paramTypes.length < minNrOfArgs) { continue;            }

        ArgumentsHolder argsHolder;

           if (resolvedValues != null) { try { //                @ConstructorProperties注释解析                  String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);                  if (paramNames == null) { ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();                     if (pnd != null) { paramNames = pnd.getParameterNames(candidate);                     } } //                解析构造参数并转换成数组                  argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,                        getUserDeclaredConstructor(candidate), autowiring);               } catch (UnsatisfiedDependencyException ex) { if (this.beanFactory.logger.isTraceEnabled()) { this.beanFactory.logger.trace( "Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);                  } // Swallow and try next constructor.                  if (causes == null) { causes = new LinkedList<>();                  } causes.add(ex);                  continue;               } } else { // Explicit arguments given -> arguments length must match exactly.               if (paramTypes.length != explicitArgs.length) { continue;               } argsHolder = new ArgumentsHolder(explicitArgs);            }

        int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
              argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));

           // Choose this constructor if it represents the closest match.            if (typeDiffWeight < minTypeDiffWeight) { constructorToUse = candidate;               argsHolderToUse = argsHolder;               argsToUse = argsHolder.arguments;               minTypeDiffWeight = typeDiffWeight;               ambiguousConstructors = null;            } else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) { if (ambiguousConstructors == null) { ambiguousConstructors = new LinkedHashSet<>();                  ambiguousConstructors.add(constructorToUse);               } ambiguousConstructors.add(candidate);            } }

     if (constructorToUse == null) {
        if (causes != null) {
           UnsatisfiedDependencyException ex = causes.removeLast();

              for (Exception cause : causes) { this.beanFactory.onSuppressedException(cause);               } throw ex;            } throw new BeanCreationException(mbd.getResourceDescription(), beanName,                  "Could not resolve matching constructor " + "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");         } else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName,                  "Ambiguous constructor matches found in bean '" + beanName + "' " + "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " + ambiguousConstructors);         }

     if (explicitArgs == null) {
        argsHolderToUse.storeCache(mbd, constructorToUse);

        } }

  try {

//       bean初始化策略，如果容器中bean方法需要被覆盖，采用cglib创建子类         final InstantiationStrategy strategy = beanFactory.getInstantiationStrategy();         Object beanInstance;

        if (System.getSecurityManager() != null) { final Constructor<?> ctorToUse = constructorToUse;            final Object[] argumentsToUse = argsToUse;            beanInstance = AccessController.doPrivileged((PrivilegedAction) () -> //                初始化bean                  strategy.instantiate(mbd, beanName, beanFactory, ctorToUse, argumentsToUse),                  beanFactory.getAccessControlContext());         } else { beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);         }

     bw.setBeanInstance(beanInstance);

        return bw;      } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName,               "Bean instantiation via constructor failed", ex);      } }

返回到这个方法

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

使用默认构造参数初始化bean            return instantiateBean(beanName, mbd);

进入这个方法

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

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) { try { Object beanInstance;         final BeanFactory parent = this;         if (System.getSecurityManager() != null) { beanInstance = AccessController.doPrivileged((PrivilegedAction) () -> //                获取bean初始化策略并进行初始化                  getInstantiationStrategy().instantiate(mbd, beanName, parent),                  getAccessControlContext());         } else { beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);         } BeanWrapper bw = new BeanWrapperImpl(beanInstance);         initBeanWrapper(bw);         return bw;      } catch (Throwable ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);      } }

   获取bean初始化策略并进行初始化                  getInstantiationStrategy().instantiate(mbd, beanName, parent),

进入这个方法

org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory)

@Override   public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) { // Don't override the class with CGLIB if no overrides.如果没有重写，不要使用CGLIB覆盖该类。      if (!bd.hasMethodOverrides()) { Constructor constructorToUse;         synchronized (bd.constructorArgumentLock) { constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;            if (constructorToUse == null) { final Class clazz = bd.getBeanClass();               if (clazz.isInterface()) { throw new BeanInstantiationException(clazz, "Specified class is an interface");               } try { if (System.getSecurityManager() != null) { constructorToUse = AccessController.doPrivileged( (PrivilegedExceptionAction>) clazz::getDeclaredConstructor);                  } else { constructorToUse = clazz.getDeclaredConstructor();                  } bd.resolvedConstructorOrFactoryMethod = constructorToUse;               } catch (Throwable ex) { throw new BeanInstantiationException(clazz, "No default constructor found", ex);               } } } //       使用构造方法创建类         return BeanUtils.instantiateClass(constructorToUse);      } else { // Must generate CGLIB subclass.必须生成CGLIB子类         return instantiateWithMethodInjection(bd, beanName, owner);      } }

返回到这个方法

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean这一行代码

//        填充依赖注入的bean对象         populateBean(beanName, mbd, instanceWrapper);

进入org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean这个方法

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { if (mbd.hasPropertyValues()) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");         } else { // Skip property population phase for null instance.            return;         } }

  // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the

     // state of the bean before properties are set. This can be used, for example,      // to support styles of field injection.      boolean continueWithPropertyPopulation = true;

     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;               if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false;                  break;               } } } }

  if (!continueWithPropertyPopulation) {
     return;

     }

  PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

//    如果是按名称注入或者按类型注入      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

        // Add property values based on autowire by name if applicable.如果可以的话，在autowire的基础上添加属性值。         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { //          按名称注入            autowireByName(beanName, mbd, bw, newPvs);         }

     // Add property values based on autowire by type if applicable.如果可以的话，按类型添加基于autowire的属性值。

        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { //          按类型注入            autowireByType(beanName, mbd, bw, newPvs);         }

     pvs = newPvs;

     }

  boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();

     boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

     if (hasInstAwareBpps || needsDepCheck) { if (pvs == null) { pvs = mbd.getPropertyValues();         } PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);         if (hasInstAwareBpps) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;                  pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);                  if (pvs == null) { return;                  } } } } if (needsDepCheck) { checkDependencies(beanName, mbd, filteredPds, pvs);         } }

  if (pvs != null) {
     applyPropertyValues(beanName, mbd, bw, pvs);

     } }

找到这行代码

//           按类型注入            autowireByType(beanName, mbd, bw, newPvs);

进入这个方法org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByType

protected void autowireByType( String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

  TypeConverter converter = getCustomTypeConverter();

     if (converter == null) { converter = bw;      }

  Set<String> autowiredBeanNames = new LinkedHashSet<>(4);

     String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);      for (String propertyName : propertyNames) { try { PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);            // Don't try autowiring by type for type Object: never makes sense,            // even if it technically is a unsatisfied, non-simple property.            if (Object.class != pd.getPropertyType()) { MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);               // Do not allow eager init for type matching in case of a prioritized post-processor.               boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());               DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager); //             解析依赖值               Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);               if (autowiredArgument != null) { pvs.add(propertyName, autowiredArgument);               } for (String autowiredBeanName : autowiredBeanNames) { registerDependentBean(autowiredBeanName, beanName);                  if (logger.isDebugEnabled()) { logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + autowiredBeanName + "'");                  } } autowiredBeanNames.clear();            } } catch (BeansException ex) { throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);         } } }

找到这行代码

   解析依赖值               Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);

进入这个方法

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

本次介绍到这里，下次继续。

最后

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

免责申明：本站发布的内容（图片、视频和文字）以转载和分享为主，文章观点不代表本站立场，如涉及侵权请联系站长邮箱：xbc-online@qq.com进行反馈，一经查实，将立刻删除涉嫌侵权内容。

同类热门文章

十分钟搞定Pinia的使用与原理

本质是一个插件，基于reactive实现响应式仓库（全局共享） 十分钟搞定Pinia的使用与原理。

  • 前端
  • 种豆得瓜zzz
  • 28
十分钟搞定Pinia的使用与原理

JavaScript常规加密技术

当今Web开发中，数据安全是一个至关重要的问题，为了确保数据的安全性，我们需要使用加密技术。JavaScript作为一种客户端编程语言，可以很好地为数据进行加密。在本篇文章中，我们将为你提供一个常规J

  • 前端
  • 网友
  • 17
JavaScript常规加密技术

Vue3父组件调用子组件方法

Parent.vue <scriptsetup> import{ref}from'vue' importChildrenfrom'./children.vue' constchildre

  • 前端
  • 三生万物
  • 17
Vue3父组件调用子组件方法

Pinia封装使用

先创建stores文件夹，内部创建index.js文件和各分类文件 main.js文件内部 stores文件夹内index.js文件内部 stores文件夹内分类仓库文件内部(counter.js文件

  • 前端
  • 柠檬仔_
  • 16
Pinia封装使用

vue3组件通信方式

1.props 父组件代码如下： 子组件只需要渲染父组件传递的值。 代码如下： 2.Emit Emit也是Vue中最常见的组件通信方式，用于子组件向父组件传递消息。 我们在父组件中定义列表，子组件只需

  • 前端
  • 不会杀鸡的前端
  • 14
vue3组件通信方式
文章标签
相关推荐

本站数据来源于网络，若侵害到您的利益，请联系我们删除处理！| 联系QQ：718489412 请注明来意！

Copyright © 2022 我爱编程    渝ICP备16013811号-10