@autowire、@resource原理

@autowire、@resource、@value是我们项目开发中最常用的注解。

对于初学者来说

@value注入配置属性

@autowire根据类型注入

@resource根据名字注入

其实这种理解不是很透彻

今天我们来探索下@autowire的原理。

一、准备测试代码

一个接口类有多个实现类

public interface UserService {

}

--

@Service("userService1")
public class UserService1Impl implements UserService {

}

--
@Service("userService2")
public class UserService2Impl implements UserService {

}

需要注入的类

public interface UniqueService {

    void a();

}

--
@Service
public class UniqueServiceImpl implements UniqueService {

    @Autowired
    private UserService userService1;

    @Value("${test.a}")
    private String a;

    @Override
    public void a() {
        System.out.println(a);
    }
}

xml配置

<context:property-placeholder location="classpath:application.properties"/>
<context:component-scan base-package="com.csy.discuss.core.autowire"/>

二、源码分析

1.AutowiredAnnotationBeanPostProcessor初始化

注：这一点其实大部分知识点都与Spring容器的初始化和Spring命名空间有关。

当spring解析<context:component-scan>标签的时候找到对应的ComponentScanBeanDefinitionParser命名空间解析器

//ComponentScanBeanDefinitionParser#registerComponents

protected void registerComponents(
            XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {

    ...

    // Register annotation config processors, if necessary.
    boolean annotationConfig = true;
    if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
        annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
    }
    if (annotationConfig) {
        Set<BeanDefinitionHolder> processorDefinitions =
                AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
        for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
            compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
        }
    }

    readerContext.fireComponentRegistered(compositeDef);
}

因为<context:component-scan>标签annotation-config属性默认为true。所以
调用AnnotationConfigUtils.registerAnnotationConfigProcessors。
里面手动注册了AutowiredAnnotationBeanPostProcessor这个bean。

Spring创建AutowiredAnnotationBeanPostProcessor这个bean的时候调用其构造方法

public AutowiredAnnotationBeanPostProcessor() {
    this.autowiredAnnotationTypes.add(Autowired.class);
    this.autowiredAnnotationTypes.add(Value.class);
    try {
        this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
                ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
        logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
    }
    catch (ClassNotFoundException ex) {
        // JSR-330 API not available - simply skip.
    }
}

我们可以看到。它初始化了Autowired、Value、Inject三个注解。也就是说这三个注解都是由AutowiredAnnotationBeanPostProcessor来实现的。

2.组装InjectionMetadata

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

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

        ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
            @Override
            public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
                ...
            }
        });

        elements.addAll(0, currElements);
        targetClass = targetClass.getSuperclass();
    }
    while (targetClass != null && targetClass != Object.class);

    return new InjectionMetadata(clazz, elements);
}

我们可以看两个主方法:doWithLocalFields和doWithLocalMethods。顾名思义,处理属性和方法上的@autowire类注解。也就是说@autowire不仅可以打在类的属性上,还能打在类的方法上。打在方法上我们不做分析,因为基本不用。
然后遍历这个类上所有的属性。筛选出带有@Autowire或@Value或@Inject的属性。最终组装成InjectionMetadata。

3.注入

doCreateBean -> populateBean -> InstantiationAwareBeanPostProcessor#postProcessPropertyValues

AutowiredAnnotationBeanPostProcessor就是继承InstantiationAwareBeanPostProcessor。

public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {

    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    try {
       // AutowiredFieldElement.inject
        metadata.inject(bean, beanName, pvs);
    }
    catch (BeanCreationException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    }
    return pvs;
}

首先，就是拿到我们第二步组装好的InjectionMetadata,然后遍历里面的InjectedElement。即遍历这个bean所有带有@Autowire或@Value或@Inject的属性。

AutowiredAnnotationBeanPostProcessor有两个私有内部类AutowiredFieldElement和AutowiredMethodElement,都继承InjectionMetadata的内部类InjectedElement。显而易见,我们要跟踪的是AutowiredFieldElement。

//DefaultListableBeanFactory

public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

    InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
    try {
        Object shortcut = descriptor.resolveShortcut(this);
        if (shortcut != null) {
            return shortcut;
        }

        Class<?> type = descriptor.getDependencyType();
        Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
        
        //@Value注解走这里
        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()));
        }
      
        //@Autowire注解走这里
        Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
        if (multipleBeans != null) {
            return multipleBeans;
        }

        Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
        if (matchingBeans.isEmpty()) {
            if (isRequired(descriptor)) {
                raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
            }
            return null;
        }

        String autowiredBeanName;
        Object instanceCandidate;

        if (matchingBeans.size() > 1) {
            autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
            if (autowiredBeanName == null) {
                if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
                    return descriptor.resolveNotUnique(type, matchingBeans);
                }
                else {
                    // In case of an optional Collection/Map, silently ignore a non-unique case:
                    // possibly it was meant to be an empty collection of multiple regular beans
                    // (before 4.3 in particular when we didn't even look for collection beans).
                    return null;
                }
            }
            instanceCandidate = matchingBeans.get(autowiredBeanName);
        }
        else {
            // We have exactly one match.
            Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
            autowiredBeanName = entry.getKey();
            instanceCandidate = entry.getValue();
        }

        if (autowiredBeanNames != null) {
            autowiredBeanNames.add(autowiredBeanName);
        }
        return (instanceCandidate instanceof Class ?
                descriptor.resolveCandidate(autowiredBeanName, type, this) : instanceCandidate);
    }
    finally {
        ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
    }
}

3.1@Value注解链路

这个不多分析了。主要通过PropertySourcesPlaceholderConfigurer去解析

3.2@Autowire注解链路

以测试代码注入的UserService userService1为例。

Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);

candidates老朋友了,候选者的意思。

从bean工厂中捞出UserService类型的bean。以这个bean的名字为key。若bean已经创建完成,那么以这个bean的实例为value。否则以这个bean的类型为value;

对于测试代码的例子来说。有两个候选者。分别是userService1和userService2

如果matchingBeans有多个,那就根据对应属性的名字进行匹配。

return (instanceCandidate instanceof Class ?
                    descriptor.resolveCandidate(autowiredBeanName, type, this) : instanceCandidate);
                    

如果是class类型那么调用beanFactory.getBean进行bean的创建,拿到这个bean的实例。

AutowiredFieldElement#inject的最后几句代码

if (value != null) {
    ReflectionUtils.makeAccessible(field);
    field.set(bean, value);
}

通过反射将属性设置进去。

四、顺便提一下@Resource注解

由CommonAnnotationBeanPostProcessor实现

看beanDefinitionMap里是否有这个属性名称的bean。没有的话根据类型走和@autowire一样的doResolveDependency方法。有这个属性名称的bean,直接创建这个bean。

总结

1.@autowire、@resource、@value是通过调用AutowiredAnnotationBeanPostProcessor这个BeanPostProsess的postProcessPropertyValues方法进行注入的

2.@Autowire不仅可以作用在bean的属性上,还能作用在bean的方法上。

3.@Autowire通过属性的类型进行注入。若这个类型有多种（一个接口类有多个实现类）,降级为根据名字来注入

4.@Resource通过属性的名字去容器里找bean的定义。有的话直接创建bean进行注入。没有的话降级为根据类型进行注入

转载于:https://www.cnblogs.com/chenshengyue/p/11453953.html