【04】spring源码解析之Autowired属性注入
在文章【03】spring源码解析之配置文件context:component-scan 解析流程中分析了spring是如何解析配置文件的，spring根据配置文件中配置的bean扫描路径（或者是xml文件中配置的bean）找到这些须要被spring管理的bean，找到这些bean之后，并无组织这些bean之间的关系，只是返回了BeanDefinitions，也就是描述这些Bean性质的BeanDefinition列表，对于一个Bean做为另一个Bean的属性是如何注入的则在其余的流程中进行组装。下图的时序图粗略的描述了一下整个注入的过程 java
从上图能够看出，Bean组装的入口是AbstractApplicationContext 的registerBeanPostProcessors方法，这个方法接受一个ConfigurableListableBeanFactory做为参数，对于ConfigurableListableBeanFactory类的层级关系以下类图： spring
从关系图中能够看出，ConfigurableListableBeanFactory继承ListableBeanFactory,而ListableBeanFactory持有BeanDefinition对象，也就是说ConfigurableListableBeanFactory在解析的时候持有了BeanDefinitions这些对象。 app
从图时序图1中能够看出，Bean的建立关键代码是AbstractAutowireCapableBeanFactory的doCreateBean方法，而进行属性注入的是populateBean方法，这个方法声明以下： ide
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args); 函数
它接收三个参数，第一个参数是bean的名称，第二个是对这个类的描述对象，第三个参数是建立这个bean时候的构造函数所须要的参数。返回值是一个建立完成的对象。 post
而建立对象的过程主要是分为两个步骤 ui
一、建立对象 this
二、注入属性 lua
建立对象是由createBeanInstance方法完成的，注入属性是populateBean方法完成的 spa
1、对象建立
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// 确保这个类是存在的，而且经过mbd反向查找到类
Class<?> beanClass = resolveBeanClass(mbd, beanName);
//校验类是否为空，是否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());
}
.....
//实例化Bean，对具备没有参数的构造函数进行实例化，registerCustomEditors
//调用过程为instantiateBean->registerCustomEditors->BeanUtils.instantiateClass(editorClass);
return instantiateBean(beanName, mbd);
}
//把instanceWrapper 对象转化为真正实例化后的对象
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
2、属性注入
一、查找Bean中的注解
入口为applyMergedBeanDefinitionPostProcessors，真正的查找方法为AutowiredAnnotationBeanProcessor中的findAutowiredMetadata方法，而后调用bulidResourceMetadate方法，解析class文件中的注解文件，
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<InjectionMetadata.InjectedElement>();
Class<?> targetClass = clazz;
do {
final LinkedList<InjectionMetadata.InjectedElement> currElements =
new LinkedList<InjectionMetadata.InjectedElement>();
//经过反射的方法，找到class的全部属性，而后回调FieldCallback方法，在这个方法中过滤被Autowired注解所修饰
的属性，而且校验属性是否是static的，若是是的话，则记录warin级别的日志，Autowired不支持修饰static变量
而后把符合条件的属性集合放入到currElements集合中以待后续处理
ReflectionUtils.doWithLocalFields(targetClass, new ReflectionUtils.FieldCallback() {
@Override
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
AnnotationAttributes ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static fields: " + field);
}
return;
}
boolean required = determineRequiredStatus(ann);
currElements.add(new AutowiredFieldElement(field, required));
}
}
});
//和doWithLocalFields采起相同的方式，处理相关方法
ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
@Override
public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterTypes().length == 0) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation should be used on methods with parameters: " + method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
}
});
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
return new InjectionMetadata(clazz, elements);
}
二、属性注解检验
对static修饰的属性，不容许使用Autowired注解
三、属性注入
数据准备完成之后，经过调用populateBean方法，真正的对须要注入的属性进行注入
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
PropertyValues pvs = mbd.getPropertyValues();
if (bw == null) {
if (!pvs.isEmpty()) {
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;
}
//mbd.getResolvedAutowireMode() 根据自动注入策略，获取注入策略的值，默认值是0
RootBeanDefinition.AUTOWIRE_BY_NAME的值是1
RootBeanDefinition.AUTOWIRE_BY_TYPE的值是2
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.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
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);
}
}
applyPropertyValues(beanName, mbd, bw, pvs);
}
实例化属性，注入的代码
DefaultListableBeanFactory.java
public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
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()));
}
if (type.isArray()) {
Class<?> componentType = type.getComponentType();
DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
targetDesc.increaseNestingLevel();
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, targetDesc);
//注入其依赖的属性，实例化属性，这样就能达到一个循环，把全部的依赖从最里层逐步剥离出来进行实例化，而后注入
if (matchingBeans.isEmpty()) {
if (descriptor.isRequired()) {
raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);
}
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.getCollectionType();
if (elementType == null) {
if (descriptor.isRequired()) {
throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");
}
return null;
}
DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
targetDesc.increaseNestingLevel();
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, targetDesc);
if (matchingBeans.isEmpty()) {
if (descriptor.isRequired()) {
raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);
}
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) {
Collections.sort((List<?>) result, adaptDependencyComparator(matchingBeans));
}
return result;
}
else if (Map.class.isAssignableFrom(type) && type.isInterface()) {
Class<?> keyType = descriptor.getMapKeyType();
if (String.class != keyType) {
if (descriptor.isRequired()) {
throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +
"] must be [java.lang.String]");
}
return null;
}
Class<?> valueType = descriptor.getMapValueType();
if (valueType == null) {
if (descriptor.isRequired()) {
throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");
}
return null;
}
DependencyDescriptor targetDesc = new DependencyDescriptor(descriptor);
targetDesc.increaseNestingLevel();
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, targetDesc);
if (matchingBeans.isEmpty()) {
if (descriptor.isRequired()) {
raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);
}
return null;
}
if (autowiredBeanNames != null) {
autowiredBeanNames.addAll(matchingBeans.keySet());
}
return matchingBeans;
}
else {
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
if (descriptor.isRequired()) {
raiseNoSuchBeanDefinitionException(type, "", descriptor);
//若是没有找到属性所要注入的实例，则会抛出咱们很是常见的一个异常 ^_^
//expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations:xxxx
}
return null;
}
if (matchingBeans.size() > 1) {
String primaryBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (primaryBeanName == null) {
throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());
//针对一个属性，找到了多个实例，抛出实例重复异常
//expected at least 1 bean which qualifies as autowire candidate for this dependency.
}
if (autowiredBeanNames != null) {
autowiredBeanNames.add(primaryBeanName);
}
return matchingBeans.get(primaryBeanName);
}
//确保有且只能找到一个
// We have exactly one match.
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
if (autowiredBeanNames != null) {
autowiredBeanNames.add(entry.getKey());
}
return entry.getValue();
}
}
AutowiredAnnotationBeanPostProcessor的内部类AutowiredFieldElement中的inject方法
@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
...........
...............
if (value != null) {
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
//对属性注入值的最根本的代码
//注入属性^_^ ^_^ ^_^^_^^_^^_^^_^^_^^_^
//我得意的笑啊，终于找到这家伙了
}
}
catch (Throwable ex) {
throw new BeanCreationException("Could not autowire field: " + field, ex);
}
}
}
相关文章
- 1. Spring源码分析之属性注入
- 2. spring源码解析 -- 注入属性
- 3. Spring注解@Autowired源码分析
- 4. @Autowired注解源码解析
- 5. Spring AOP注解经过@Autowired，@Resource，@Qualifier，@PostConstruct，@PreDestroy注入属性的
- 6. Spring之@AutoWired注解
- 7. Spring @Autowired注解解析
- 8. Spring 源码分析之 bean 依赖注入原理(注入属性)
- 9. Spring源码讲解（四）Spring中bean的属性注入
- 10. Spring源码分析：@Autowired注解原理分析
- 更多相关文章...
- • Spring DI（依赖注入）的实现方式：属性注入和构造注入 - Spring教程
- • SQLite 注入 - SQLite教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • Java Agent入门实战（二）-Instrumentation源码概述
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Spring源码分析之属性注入
- 2. spring源码解析 -- 注入属性
- 3. Spring注解@Autowired源码分析
- 4. @Autowired注解源码解析
- 5. Spring AOP注解经过@Autowired，@Resource，@Qualifier，@PostConstruct，@PreDestroy注入属性的
- 6. Spring之@AutoWired注解
- 7. Spring @Autowired注解解析
- 8. Spring 源码分析之 bean 依赖注入原理(注入属性)
- 9. Spring源码讲解（四）Spring中bean的属性注入
- 10. Spring源码分析：@Autowired注解原理分析