Spring bean 创建过程源码解析

Spring bean 创建过程源码解析

TSMYK Java技术编程

前言

在上一篇文章 Spring 中 bean 注册的源码解析 中分析了 Spring 中 bean 的注册过程,就是把配置文件中配置的 bean 的信息加载到内存中,以 BeanDefinition对象的形式存放,该对象中存放了 bean 的相关属性,下面就以 debug 的形式一步步来看下 bean 是如何创建的。

Spring 中 bean 的创建可以说是非常的复杂,方法嵌套很多,为了更好的理清创建过程,画了下面的 UML 图:

从上述 UML 图中,可以看出 bean 的创建主要分为以下几步:

  1. 根据 bean 的 name 解析对应的 class

  2. 处理 lookup-metod 和 replace-method 子标签

  3. 处理初始化前的后置处理器

  4. 真正的创建 bean
    4.1 创建 bean 实例
    4.1.1 工厂方法创建
    4.1.2 带参数的构造方法创建
    4.1.3 默认的构造方法创建

4.2 添加单例对象的工厂缓存

4.3 填充对象的各种属性
4.3.1 名称注入
4.3.2 类型注入

4.4 处理 init-method 方法
4.4.1 处理 bean 的前置处理器
4.4.2 执行 init-method 方法
4.4.3 处理 bean 的后置处理器

创建过程

创建 bean 的代码是在 AbstractAutowireCapableBeanFactory 类中开始创建的,在分析的过程中,会把一些代码省略掉,如异常处理等:

@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {    // 表示 <bean> 标签,里面有各种属性    RootBeanDefinition mbdToUse = mbd;    // 根据设置的 class 属性或 className 来解析 class,    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {        mbdToUse = new RootBeanDefinition(mbd);        mbdToUse.setBeanClass(resolvedClass);    }    // 处理 lookup-method 和 replace-method 子标签    mbdToUse.prepareMethodOverrides();    // 给 BeanPostProcessors 机会返回一个代理来代替bean的实例    // 即在初始化前,应用后置处理器,解析指定的bean是否存在初始化前的短路操作    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);    if (bean != null) {        return bean;    }       // 创建 bean     Object beanInstance = doCreateBean(beanName, mbdToUse, args);       return beanInstance;    }   

处理 lookup-method 和 replace-method 子标签

这两个标签虽然不常用,但是是很有用的,这里不再细说;在 Spring 中 bean 注册的源码解析 中 这两个标签会被解析放到 BeanDefinition 对象的 methodOverrides 属性中,表示需要覆盖的方法;所以在创建bean之前需要解析这两个标签,但是只是预处理:

public void prepareMethodOverrides() throws BeanDefinitionValidationException {    // Check that lookup methods exists.    MethodOverrides methodOverrides = getMethodOverrides();    if (!methodOverrides.isEmpty()) {        Set<MethodOverride> overrides = methodOverrides.getOverrides();        synchronized (overrides) {            for (MethodOverride mo : overrides) {                prepareMethodOverride(mo);            }        }    }}protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {    // 获取对应类的方法的个数    int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());    if (count == 0) {        throw new BeanDefinitionValidationException("...");    }    // 标记 MethodOverride 未被覆盖,避免了后面参数类型检查的开销    else if (count == 1) {        mo.setOverloaded(false);    }}

在处理 prepareMethodOverride(MethodOverride mo) 方法为什么只处理方法个数为 1 的情况呢?如果一个类中有多个重载的方法,则调用或增强的时候,还需要进行参数类型的解析才能确定调用的是哪个方法,Spring 把部分功能放在这里提前进行预处理,如果方法只有一个,即没有重载的方法,在后面调用的时候,直接找到该方法调用,不用再去解析参数来确定方法了,这样就可以避免的一些参数类型检查的开销。

实例化的前置处理

如果经过前置处理后的结果不为空,则直接返回,不再进行bean的创建过程,AOP功能就是在这里判断的:

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);if (bean != null) {    return bean;}protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {    Object bean = null;    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {        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

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)throws BeanCreationException {    // 最终返回的 bean 的包装类    BeanWrapper instanceWrapper = null;    if (mbd.isSingleton()) {        // 如果是单例,则检查工厂缓存中以前是否创建过        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);    }    if (instanceWrapper == null) {        // 创建bean,工厂方法创建,构造方法创建,默认构造方法创建等        instanceWrapper = createBeanInstance(beanName, mbd, args);    }    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);    mbd.resolvedTargetType = beanType;    // Allow post-processors to modify the merged bean definition.    synchronized (mbd.postProcessingLock) {        if (!mbd.postProcessed) {            // 应用 MergedBeanDefinitionPostProcessors            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);            mbd.postProcessed = true;        }    }    // 检查循环依赖:是否是单例 && 是否允许循环依赖 && 当前bean是否正在创建中    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&            isSingletonCurrentlyInCreation(beanName));    if (earlySingletonExposure) {        // 为了避免后期的循环依赖,在bean初始化完成前,将创建bean的工厂添加到缓存中,如果其他的bean依赖该bean,直接从缓存中获取对应的工厂创建集合,解决循环依赖,注意是只有单例情况才能这么做        addSingletonFactory(beanName, new ObjectFactory<Object>() {            public Object getObject() throws BeansException {                return getEarlyBeanReference(beanName, mbd, bean);            }        });    }    // 初始化 bean    Object exposedObject = bean;    // 填充属性    populateBean(beanName, mbd, instanceWrapper);    if (exposedObject != null) {        // 执行初始化方法,如 init-method         exposedObject = initializeBean(beanName, exposedObject, mbd);    }    if (earlySingletonExposure) {        // 只有在检测到循环依赖时才不会为空        Object earlySingletonReference = getSingleton(beanName, false);        // 存在循环依赖        if (earlySingletonReference != null) {           // 如果 exposedObject 在初始化方法中没有被改变,即没有被增强            if (exposedObject == bean) {                exposedObject = earlySingletonReference;            }            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {                String[] dependentBeans = getDependentBeans(beanName);                Set<String> actualDependentBeans = new LinkedHashSet<String(dependentBeans.length);                for (String dependentBean : dependentBeans) {                    // 检测依赖                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {                        actualDependentBeans.add(dependentBean);                    }                }                // 因为bean创建后,所依赖的bean一定是已经创建完毕的,actualDependentBeans 不为空则表示所依赖的bean还没有创建完,即存在循环依赖                if (!actualDependentBeans.isEmpty()) {                    throw new BeanCurrentlyInCreationException("");                }            }        }    }    // 根据 score 注册 bean     registerDisposableBeanIfNecessary(beanName, bean, mbd);    return exposedObject;}

上面创建 bean 的过程很复杂,分为很多步骤,下面再来看看这些步骤:

创建bean实例

创建 bean 的实例,会根据策略使用不同的创建方法,比如说 构造方法创建, 工厂方法创建,默认的构造方法创建等:

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {    // 获取 bean 对应的 class     Class<?> beanClass = resolveBeanClass(mbd, beanName);    // 如果工厂方法不为空,则使用工厂方法创建    if (mbd.getFactoryMethodName() != null)  {        return instantiateUsingFactoryMethod(beanName, mbd, args);    }    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);        }    }    // 解析构造方法    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);    if (ctors != null ||            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {        // 构造方法自动注入        return autowireConstructor(beanName, mbd, ctors, args);    }    // 默认构造方法自动注入    return instantiateBean(beanName, mbd);}

参数的构造方法注入

先来看下带参数的构造方法自动注入,

public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,        Constructor<?>[] chosenCtors, final Object[] explicitArgs) {    BeanWrapperImpl bw = new BeanWrapperImpl();    this.beanFactory.initBeanWrapper(bw);    Constructor<?> constructorToUse = null;    ArgumentsHolder argsHolderToUse = null;    Object[] argsToUse = null;    // explicitArgs 参数通过 getBean() 方法传入,Object getBean(String name, Object... args)    if (explicitArgs != null) {        // 如果 getBean 方法传入了参数,则直接使用        argsToUse = explicitArgs;    }    else {        // 如果 getBean 方法没有传入参数,则从配置文件进行解析        Object[] argsToResolve = null;        // 从缓存中获取        synchronized (mbd.constructorArgumentLock) {            constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;            if (constructorToUse != null && mbd.constructorArgumentsResolved) {                argsToUse = mbd.resolvedConstructorArguments;                if (argsToUse == null) {                    argsToResolve = mbd.preparedConstructorArguments;                }            }        }        if (argsToResolve != null) {            // 配置的构造方法参数            argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);        }    }    // 该构造没有被缓存,则需要进行解析    if (constructorToUse == null) {        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);        }        Constructor<?>[] candidates = chosenCtors;        if (candidates == null) {            Class<?> beanClass = mbd.getBeanClass();            candidates = (mbd.isNonPublicAccessAllowed() ? beanClass.getDeclaredConstructors() : beanClass.getConstructors());        }        // 排序构造方法,按照参数个数进行排序        AutowireUtils.sortConstructors(candidates);        int minTypeDiffWeight = Integer.MAX_VALUE;        Set<Constructor<?>> ambiguousConstructors = null;        for (Constructor<?> candidate : candidates) {            Class<?>[] paramTypes = candidate.getParameterTypes();            if (constructorToUse != null && argsToUse.length > paramTypes.length) {                // 如果已经找到满足条件的构造方法,则终止                break;            }            if (paramTypes.length < minNrOfArgs) {                continue;            }            ArgumentsHolder argsHolder;            if (resolvedValues != null) {                // 构造方法参数的名字                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);            }            else {                // 构造方法没有参数                argsHolder = new ArgumentsHolder(explicitArgs);            }            // 检查是否有不确定性构造方法的存在,如参数为父子关系            int typeDiffWeight = (mbd.isLenientConstructorResolution() ?argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));            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<Constructor<?>>();                    ambiguousConstructors.add(constructorToUse);                }                ambiguousConstructors.add(candidate);            }        }        if (constructorToUse == null) {            throw new BeanCreationException("...")        }        // 将解析的构造方法加入缓存        if (explicitArgs == null) {            argsHolderToUse.storeCache(mbd, constructorToUse);        }    }    // 实例化    Object beanInstance;    if (System.getSecurityManager() != null) {        final Constructor<?> ctorToUse = constructorToUse;        final Object[] argumentsToUse = argsToUse;        beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {            public Object run() {                return beanFactory.getInstantiationStrategy().instantiate(                        mbd, beanName, beanFactory, ctorToUse, argumentsToUse);            }        }, beanFactory.getAccessControlContext());    }    else {        beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(                mbd, beanName, this.beanFactory, constructorToUse, argsToUse);    }    bw.setBeanInstance(beanInstance);    return bw;}

上面的方法就是使用构造方法进行实例化bean的过程,很复杂,也有很多的辅助方法,下面来看下实例化的过程:

实例化有两种方式,CGLIB 和 反射:

beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, ctorToUse);

先来看下 getInstantiationStrategy 方法返回什么?

protected InstantiationStrategy getInstantiationStrategy() {    return this.instantiationStrategy;}private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

它返回的是 InstantiationStrategy 接口,而接口由两个实现类:

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,        final Constructor<?> ctor, Object... args) {    // 如果没有需要动态改变的方法,则直接使用反射进行实例化    if (bd.getMethodOverrides().isEmpty()) {        if (System.getSecurityManager() != null) {            AccessController.doPrivileged(new PrivilegedAction<Object>() {                @Override                public Object run() {                    ReflectionUtils.makeAccessible(ctor);                    return null;                }            });        }        // 使用 反射 实例化        return BeanUtils.instantiateClass(ctor, args);    }    else {        // 如果需要覆盖或者动态替换的方法,则需要使用 CGLIB 来动态代理,在创建代理的时候,可以增强植入我们的代码        return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);    }}

使用工厂方法创建实例和构造方法参不多,使用默认的构造方法实例化比较简单,这里就不列出来了。

属性填充

在上面分析 doCreateBean 方法的时候,当通过 工厂方法,带参数的构造方法或默认的构造方法创建了 bean 实例后,需要对 bean 的属性进行设置

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {    PropertyValues pvs = mbd.getPropertyValues();    // 给 InstantiationAwareBeanPostProcessor 最后一次机会在属性设置前来改变 bean     boolean continueWithPropertyPopulation = true;    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {        for (BeanPostProcessor bp : getBeanPostProcessors()) {            if (bp instanceof InstantiationAwareBeanPostProcessor) {                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;                // postProcessAfterInstantiation 返回值为是否继续填充 bean                 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {                    continueWithPropertyPopulation = false;                    break;                }            }        }    }    if (!continueWithPropertyPopulation) {        return;    }    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||            mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);        // 名称注入        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {            autowireByName(beanName, mbd, bw, newPvs);        }        // 类型注入        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) {        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);        }    }    // 将属性应用到 bean 中    applyPropertyValues(beanName, mbd, bw, pvs);}

关于 名称 注入和类型注入,后面单独分析

将属性应用到 bean 中:
到这里,已经完成了对注入属性的获取,但是获取的是 PropereyValues 的形式存在,现在将他们应用到 bean 中去:

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {    if (pvs == null || pvs.isEmpty()) {        return;    }    if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {        ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());    }    MutablePropertyValues mpvs = null;    List<PropertyValue> original;    if (pvs instanceof MutablePropertyValues) {        // 如果 mpvs 中的值已经被转换为对应的类型,则可以直接设置到 beanWapper 中         mpvs = (MutablePropertyValues) pvs;        if (mpvs.isConverted()) {            bw.setPropertyValues(mpvs);            return;        }        original = mpvs.getPropertyValueList();    }    else {        // 如果 pvs 不是 MutablePropertyValues 封装的类,则直接使用原始的属性获取方法        original = Arrays.asList(pvs.getPropertyValues());    }    // 获取用户自定义的类型转换器    TypeConverter converter = getCustomTypeConverter();    if (converter == null) {        converter = bw;    }    / 获取对应的解析器    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);    List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());    boolean resolveNecessary = false;    // 遍历属性,将属性转换为对应类的对应属性的类型    for (PropertyValue pv : original) {        if (pv.isConverted()) {            deepCopy.add(pv);        }        else {            String propertyName = pv.getName();            Object originalValue = pv.getValue();            Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);            Object convertedValue = resolvedValue;            boolean convertible = bw.isWritableProperty(propertyName) &&                    !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);            if (convertible) {                convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);            }            if (resolvedValue == originalValue) {                if (convertible) {                    pv.setConvertedValue(convertedValue);                }                deepCopy.add(pv);            }            else if (convertible && originalValue instanceof TypedStringValue &&                !((TypedStringValue) originalValue).isDynamic() &&                !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {                pv.setConvertedValue(convertedValue);                deepCopy.add(pv);            }            else {                resolveNecessary = true;                deepCopy.add(new PropertyValue(pv, convertedValue));            }        }    }    if (mpvs != null && !resolveNecessary) {        mpvs.setConverted();    }    bw.setPropertyValues(new MutablePropertyValues(deepCopy));}

执行初始化方法

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {    // 执行用户自定义的各种 aware 方法    invokeAwareMethods(beanName, bean);    Object wrappedBean = bean;    if (mbd == null || !mbd.isSynthetic()) {        // 在执行 init 方法之前,先执行 前置处理器 applyBeanPostProcessorsBeforeInitialization        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);    }    // 执行初始化方法    invokeInitMethods(beanName, wrappedBean, mbd);    // 执行后置处理器 applyBeanPostProcessorsAfterInitialization    if (mbd == null || !mbd.isSynthetic()) {        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);    }    return wrappedBean;}// 执行用户自定义的各种 aware 方法 private void invokeAwareMethods(final String beanName, final Object bean) {    if (bean instanceof Aware) {        if (bean instanceof BeanNameAware) {            ((BeanNameAware) bean).setBeanName(beanName);        }        if (bean instanceof BeanClassLoaderAware) {            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());        }        if (bean instanceof BeanFactoryAware) {            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);        }    }}

到这里,bean 创建的大致过程就结束了

来源:https://www.icode9.com/content-1-836851.html

(0)

相关推荐