Spring IoC 依赖注入(二)源码分析
目录
Spring IoC 依赖注入(二)源码分析
本章主要分析 Spring IoC 依赖注入的源码,首先分析最基本的手动注入,再分析两种自动注入方式 - 名称注入和类型注入,这两种注入最核心的是如何查找依赖,Spring 中专门提供了 resolveDependency API 用于根据类型查找依赖,最后我们再回过头再看一下构造器注入和工厂方法注入。
- 手动注入:Autowire.NO 禁止自动注入,官方推荐,也是默认的注入模式。db.propertyValues。
- 名称注入:Autowire.BY_NAME。根据 beanName 注入,Spring 中根据名称查找 Bean 标
- 类型注入:Autowire.BY_TYPE。根据 beanType 注入,核心是依赖查找,Spring 中提供 resolveDependency API 来查找所依赖的 Bean。
- 依赖查找:resolveDependency(核心方法) 根据类型查找所依赖的 Bean。当然也有根据名称查找,不过代码就很简单了。
- 构造器注入:本质还是类型注入,即通过 resolveDependency 查找依赖。
- 工厂方法注入:基本同构造器注入。
- AutowiredAnnotationBeanPostProcessor:@Autowired,@Value,@javax.inject.Inject 等。
- CommonAnnotationBeanPostProcessor:@Resource,PostConstruct,@PreDestroy 等。
1. 依赖注入口 - populateBean
1.1 doCreateBean
首先,我们要了解一下 Spring Bean 的整个创建过程,doCreateBean 方法主要完成了以下几件事:
- Bean 的实例化:Spring 常见的实例化方式有构造器实例化,工厂方法等,具体可以参考我的 Spring Bean 实例化方法总结。
- 调用 BeanDefinition:使用后置处理器调用 Bean 的定义 BeanDefinition,这也是最后的机会修改 Bean 的定义。如 AutowiredAnnotationBeanPostProcessor 就会通过 postProcessMergedBeanDefinition 方法读取 @Autowired 等注解的信息。
- 提前暴露单例 Bean:用于解决循环依赖问题。
- 属性注入:除构造器注入或工厂方法注入外的其它注入,包括 "Setter 注入" 或 "Field 注入" 或 "方法注入" 等。
- 初始化:执行顺序如下:"JSR 规范 @PostConstruct" > "Spring 标准接口 InitializingBean" > "自定义方法"。详见 Spring Bean 生命周期。
- 最后注册依赖关系:用于 Bean 销毁。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { // 1. 实例化Bean,构造器注入或工厂方法注入 BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args); // 2. 后置处理器修改Bean的定义BeanDefinition:bdp#postProcessMergedBeanDefinition applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); // 3. 提前将Bean暴露到IoC容器中,用于解决循环依赖 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // 4. populateBean属性注入的核心方法,initializeBean则执行bean初始化方法 Object exposedObject = bean; populateBean(beanName, mbd, instanceWrapper); exposedObject = initializeBean(beanName, exposedObject, mbd); // 5. 注册bean的依赖关系,用于bean销毁用 registerDisposableBeanIfNecessary(beanName, bean, mbd); return exposedObject; }
说明: 在 Bean 的创建过程中有两个方法都可以进行依赖注入。
createBeanInstance
:方法实例化时,构造器注入或工厂方法注入。populateBean
:"Setter 注入" 或 "Field 注入" 或 "方法注入" 等。
1.2 populateBean
下面,我们看一下 populateBean 方法是怎么进行属性注入的。populateBean 处理了 Spring 的各种依赖注入:包括自动注入(名称注入和类型注入)、注解注入(@Autowired 和 @Value 等)、手动注入等。
- 首先,判断是否需要进行属性注入。调用 ibp#postProcessAfterInstantiation,有时间再看一下 Spring 内部是怎么使用这个功能的,它的使用场景是什么?
- 自动注入:包括名称注入和类型注入。不推荐使用,只支持 XML 配置方式。
- 注解注入:处理 @Autowired 和 @Value 等注解,Spring 提供 ibp#postProcessProperties 可以调整 bean 实例。如 AutowiredAnnotationBeanPostProcessor 用于处理 @Autowired 和 @Value 注解。CommonAnnotationBeanPostProcessor 用于处理 @Resource 注解。
- 依赖检查:检查要注入的依赖是否已经完整。可以只检查简单类型(Java 原生类型、Enum、Class 等),也可以只检查对象类型。
- 手动注入:最基础的注入方式,实际上都委托给了 BeanWrapper 处理。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { // 1. 判断是否需要进行属性注入:ibp#postProcessAfterInstantiation if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { return; } } } } PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); // 2. 自动注入:包括名称注入和类型注入 int resolvedAutowireMode = mbd.getResolvedAutowireMode(); if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // 2.1 自动根据名称注入 if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // 2.2 自动根据类型注入 if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); // 3. 注解注入:后置处理器ibp#postProcessProperties,大名鼎鼎的@Autowired就是在这处理的。 PropertyDescriptor[] filteredPds = null; if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); } for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } } // 4. 依赖检查,循环依赖... if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } checkDependencies(beanName, mbd, filteredPds, pvs); } // 5. 手动依赖注入 if (pvs != null) { applyPropertyValues(beanName, mbd, bw, pvs); } }
说明: 代码很长,但逻辑非常清晰,populateBean 方法依次处理自动注入,注解注入,手动注入。每种注入方式的代码基本上都是独立的,我们先越过自动注入和注解注入,先深入分析手动注入 applyPropertyValues 方法。
2. 手动注入
本小节指的手动注入是指手动指定注入字段名称,解析后添加到 bd.propertyValues 中。如
<bean id="beanA" class="com.binarylei.spring.ioc.injection.BeanA"> <property name="beanB" ref="beanB"/> </bean>
2.1 相关的类说明
在分析 applyPropertyValues 源码之前,我们先认知一下这几个类:
- BeanDefinition:Bean 的元信息,无论是 XML 还是注解配置,最终都会解析成 BeanDefinition,这个我们已经很熟悉了。
- BeanWrapper:对 Bean 操作的封装,如 JavaBean 的内省,属性的设置。其 bw.setPropertyValues(mpvs) 将属性注入到 bean 实例中。
- BeanWrapperImpl:(默认)采用 PropertyDescriptor 进行注入,也就是 setter 方法反射注入,对应的处理器为 BeanPropertyHandler。
- DirectFieldAccessor:采用字段注入,对应的处理器为 FieldPropertyHandler。
- PropertyValues:AbstractBeanDefinition 重要属性,存放手动注入的属性值,默认实现类 MutablePropertyValues。类似的 constructorArgumentValues 则是构造参数。
- TypeConverter:Spring 内部的类型转换器,支持两个任意对象类型之间的转换。
- BeanDefinitionValueResolver:将 PropertyValue 中引用类型,转换成真实对象。
- TypedStringValue:封装 (String, targetType),表示需要将 String 转换成指定类型 targetType。
2.2 applyPropertyValues
applyPropertyValues 方法的主要逻辑是遍历 bd.propertyValues 中的 PropertyValue 属性,根据引用类型提取出对象实例,再将这个对象实例转换成可以直接注入的实例。
- 解析对象:valueResolver.resolveValueIfNecessary(pv, originalValue) 将 pv.value 解析成实例对象。
- 类型转换:convertForProperty(resolvedValue, propertyName, bw, converter) 将 resolvedValue 转换成可直接进行类型注入的类型。
- 依赖注入: bw.setPropertyValues(mpvs) 将解析后的属性注入到 bw 实例中。Spring 属性注入(一)JavaBean 内省机制在 BeanWrapper 中的应用。
- 结果缓存:Spring 会将 valueResolver 和 converter 解析后的最终对象缓存到 pv 中,提高效率。如果全部 pv 都不需要重新解析,则设置 mpvs.converted=true。
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { MutablePropertyValues mpvs = null; List<PropertyValue> original; // 1. 获取List<PropertyValue>,如果已经解析过,则直接注入后返回 if (pvs instanceof MutablePropertyValues) { mpvs = (MutablePropertyValues) pvs; // MutablePropertyValues已经解析,直接注入,在方法解析后会缓存已经解析的PropertyValue if (mpvs.isConverted()) { // bean注入 bw.setPropertyValues(mpvs); return; } original = mpvs.getPropertyValueList(); } else { original = Arrays.asList(pvs.getPropertyValues()); } // 2. TypeConverter:用于类型转换。 // BeanDefinitionValueResolver:用于解析PropertyValue,如间接引用替换成直接对象 TypeConverter converter = getCustomTypeConverter(); if (converter == null) { converter = bw; } BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter); // 3. 逐个解析PropertyValue List<PropertyValue> deepCopy = new ArrayList<>(original.size()); boolean resolveNecessary = false; for (PropertyValue pv : original) { if (pv.isConverted()) { // 3.1 PropertyValue已经解析 deepCopy.add(pv); } else { String propertyName = pv.getName(); Object originalValue = pv.getValue(); // 3.2 标记位,实际使用resolveDependency方法查找依赖注入的对象 if (originalValue == AutowiredPropertyMarker.INSTANCE) { Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod(); if (writeMethod == null) { throw new IllegalArgumentException("Autowire marker for property without write method: " + pv); } originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true); } // 3.3 提取真实的对象 Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); // 3.4 类型转换 Object convertedValue = resolvedValue; boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); if (convertible) { convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter); } // 3.5 缓存解析后的PropertyValue:resolvedValue -> convertedValue // 3.5.1 缓存:实例没有发生变化,比如只进行属性注入等 if (resolvedValue == originalValue) { if (convertible) { pv.setConvertedValue(convertedValue); } deepCopy.add(pv); // 3.5.2 缓存:TypedStringValue将String转换成指定类型targetType) // TypedStringValue不需要动态转换,且不是集合或数据 } else if (convertible && originalValue instanceof TypedStringValue && !((TypedStringValue) originalValue).isDynamic() && !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) { pv.setConvertedValue(convertedValue); deepCopy.add(pv); // 3.5.3 不缓存:每次都重新解析 } else { resolveNecessary = true; deepCopy.add(new PropertyValue(pv, convertedValue)); } } } // 4. 所有的字段都能成功解析,才会标记为转换完成,否则下次还需要动态解析 if (mpvs != null && !resolveNecessary) { mpvs.setConverted(); } // 5. bean依赖注入 bw.setPropertyValues(new MutablePropertyValues(deepCopy)); }
说明: 这段代码如上所述,完成了解析对象、类型转换、结果缓存、最后进行属性注入,但这些核心功能基本上都委托给对应的类完成。applyPropertyValues 本身却很简单:
解析对象:委托 BeanDefinitionValueResolver 完成。
类型转换:委托 TypeConverter 完成。
属性注入:委托 bw 完成。
结果缓存:applyPropertyValues 方法本身完成的最大功能。我们就看一下什么情况会使用缓存?
注入的字段 propertyName 必须有写方法(setter method)且注入的该字段不存在嵌套的情况(eg: person.user.name)
boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
解析后的对象实例没有被替换(地址匹配):如动态代理等,会直接替换对象。
resolvedValue == originalValue
对象类型是 TypedStringValue,不需要动态转换,且不是集合或数据
convertible && originalValue instanceof TypedStringValue && !((TypedStringValue) originalValue).isDynamic() && !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))
2.3 BeanDefinitionValueResolver
BeanDefinitionValueResolver#resolveValueIfNecessary(argName, value) 方法功能:解析 value 的真实类型,value 的类型不同,处理的结果也不同。本质就是进行依赖查找。
- RuntimeBeanReference 类型:引用类型,根据 ref.beanType 或 ref.beanName 从容器中获取。
- RuntimeBeanNameReference 类型:Spring EL 表达式解析 ref.beanName。
- BeanDefinitionHolder 或 BeanDefinition 类型:根据 BeanDefinition 实例化 bean。
- DependencyDescriptor:采用 beanFactory#resolveDependency 进行依赖查找。
- ManagedList 等集合类型:规则和上述完全类似,只是返回集合而已。
- 其它类型:如果是 String,则 Spring EL 表达式解析,其余的直接返回 originalValue。
如 applyPropertyValues 中的 AutowiredPropertyMarker.INSTANCE 类型:表示使用 beanFactory#resolveDependency 进行依赖查找。BeanDefinitionBuilder 添加属性时就会使用时这些类型。
public BeanDefinitionBuilder addPropertyValue(String name, @Nullable Object value) { this.beanDefinition.getPropertyValues().add(name, value); return this; } public BeanDefinitionBuilder addPropertyReference(String name, String beanName) { this.beanDefinition.getPropertyValues().add(name, new RuntimeBeanReference(beanName)); return this; } public BeanDefinitionBuilder addAutowiredProperty(String name) { this.beanDefinition.getPropertyValues().add(name, AutowiredPropertyMarker.INSTANCE); return this; }
2.4 依赖检查
依赖注入过程中,populateBean 调用 applyPropertyValues 方法进行属性注入之前,还有一步是依赖检查,默认是关闭的。在 AbstractBeanDefinition 中定义了如下 4 种检查方案,默认为 DEPENDENCY_CHECK_NONE。
public static final int DEPENDENCY_CHECK_NONE = 0; public static final int DEPENDENCY_CHECK_OBJECTS = 1; public static final int DEPENDENCY_CHECK_SIMPLE = 2; public static final int DEPENDENCY_CHECK_ALL = 3;
依赖检查 checkDependencies 方法,检查的 Bean 中 setter 方法对应的字段是否都是 value 值注入,如果字段没有 setter 则不用检查,又分为简单类型和对象类型检查。
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } checkDependencies(beanName, mbd, filteredPds, pvs); }
说明: populateBean 先调用 filterPropertyDescriptorsForDependencyCheck 过滤出需要进行依赖检查的字段,默认只要字段有 setter 方法,除开基本类型或特殊的类型,都要进行校验。checkDependencies 则判断 pvs 中是否包含 pd.getName(),如果不包含则根据检查级别抛出异常。
依赖检查因为默认是关闭的,而且代码也很简单,就不多说了。而且开发中好像也没有使用过这个功能。
2. 自动注入
Spring 提供了三种自动注入的手段:名称注入、类型注入、构造器注入。其中构造器注入本质是类型注入。
- 名称注入:调用 beanFactory#getBean(beanName) 方法查找依赖。无法注入时抛出异常。
- 类型注入:调用 beanFactory#resolveDependency 方法查找依赖。无法注入时不会抛出异常。
- 构造器注入:同类型注入。
无论是名称注入还是类型注入,都是通过依赖查找,通过 pvs.add(propertyName, propertyValue) 将属性添加到 bd.pvs 中,然后统一调用 bw.setPropertyValues(pvs) 将属性注入到 bean 中。
2.1 那些字段会自动注入
unsatisfiedNonSimpleProperties 方法定义了 bean 中那些字段需要自动注入。正常情况下,只要定义了 setter 方法的字段都会自动注入。
- JavaBean 中字段有写方法,即 setter 方法。
- 不需要进行依赖检查的字段。指定类型 ignoredDependencyTypes 或指定接口 ignoredDependencyInterfaces 中的方法不需要进行类型检查 。
- 没有进行指定属性值的字段。
- 简单类型及其对应的数组类型:如 Java 原生类型、包装类型、Class、Enum、Number 等基础类型。具体参考 BeanUtils#isSimpleValueType 方法。
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) { Set<String> result = new TreeSet<>(); PropertyValues pvs = mbd.getPropertyValues(); PropertyDescriptor[] pds = bw.getPropertyDescriptors(); for (PropertyDescriptor pd : pds) { if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) && !BeanUtils.isSimpleProperty(pd.getPropertyType())) { result.add(pd.getName()); } } return StringUtils.toStringArray(result); }
下面看一下那些方法不需要进行依赖检查。
protected boolean isExcludedFromDependencyCheck(PropertyDescriptor pd) { return (AutowireUtils.isExcludedFromDependencyCheck(pd) || this.ignoredDependencyTypes.contains(pd.getPropertyType()) || AutowireUtils.isSetterDefinedInInterface(pd, this.ignoredDependencyInterfaces)); }
说明: 有三种情况:一是写方法不存在;二是字段类型为指定不需要检查的类型 ignoredDependencyTypes;三是在指定接口中的方法也不需要进行类型检查 ignoredDependencyInterfaces。Spring 没有默认的 ignoredDependencyTypes 类型,但指定默认的接口 ignoredDependencyInterfaces 如下,这些 Aware 接口都是通过接口回调进行注入:
// AbstractAutowireCapableBeanFactory ignoreDependencyInterface(BeanNameAware.class); ignoreDependencyInterface(BeanFactoryAware.class); ignoreDependencyInterface(BeanClassLoaderAware.class); // AbstractApplicationContext#prepareBeanFactory beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
2.2 名称注入
当注入模式为 AUTOWIRE_BY_NAME,采用依赖注入,目前只支持 XML 配置。
<bean id="beanA" class="com.binarylei.spring.ioc.injection.BeanA" autowire="byName"/>
autowireByName 的代码也很简单。
protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); for (String propertyName : propertyNames) { if (containsBean(propertyName)) { Object bean = getBean(propertyName); pvs.add(propertyName, bean); registerDependentBean(propertyName, beanName); } } }
说明: 根据 getBean(propertyName) 查找依赖。
2.3 类型注入
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) { PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName); if (Object.class != pd.getPropertyType()) { MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); // eager 类型 @Lazy 属性,是否提前初始化 boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered); // DependencyDescriptor 封装了字段注入的详细信息 DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager); // (核心)依赖查找最核心的API Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter); if (autowiredArgument != null) { pvs.add(propertyName, autowiredArgument); } // 注册依赖关系,用于 bean 销毁 for (String autowiredBeanName : autowiredBeanNames) { registerDependentBean(autowiredBeanName, beanName); } autowiredBeanNames.clear(); } } }
说明: 调用 beanFactory#resolveDependency 方法查找依赖。重点还要说明一点的是
- AutowireByTypeDependencyDescriptor:封装了依赖注入点的详细信息,可以是字段 Field,也可以是方法参数 MethodParameter。
- eager:作用类型 @Lazy,是否提前初始化。
每天用心记录一点点。内容也许不重要,但习惯很重要!