您现在的位置是:首页 > 文章详情

Spring bean 创建过程源码解析

日期:2018-12-09点击:393

相关文章

Spring 中 bean 注册的源码解析

前言

在上一篇文件 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.4 填充对象的各种属性
        4.4.1 名称注入
        4.4.2 类型注入
    4.5 处理 init-method 方法
        4.5.1 处理 bean 的前置处理器
        4.5.2 执行 init-method 方法
        4.5.3 处理 bean 的后置处理器

创建过程

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

@Override protected 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 

当经过 resolveBeforeInstantiation 方法后,如果程序创建了代理,或者执行了 applyBeanPostProcessorsBeforeInstantiation 和 applyBeanPostProcessorsAfterInitialization 方法后,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://my.oschina.net/mengyuankan/blog/2985827
关注公众号

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。

持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

转载内容版权归作者及来源网站所有,本站原创内容转载请注明来源。

文章评论

共有0条评论来说两句吧...

文章二维码

扫描即可查看该文章

点击排行

推荐阅读

最新文章