@Autowired注解 -【Spring底层原理】

骑猪看日落 2021-09-21 20:52 418阅读 0赞

**目录**

一、概述

二、实例分析

三、源码追踪

四、总结

--------------------

### 一、概述 ###

【1】注解用法

根据@Autowired注解的源码，可以看到该注解可以作用在构造器、参数、方法、属性，都是从容器中获取参数组件的值

*  标注在方法上：@Bean+方法参数，参数从容器中获取，默认不写@Autowired效果是一样的，都能自动装配
 *  标注在构造器上：如果组件上只有一个有参构造，这个有参构造的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
 *  标注在参数位置
 *  标注在属性位置

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Autowired {
        boolean required() default true;
    }

相关注解：

>  *  @Autowired：默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解一起使用（Spring提供）
>  *  @Qualifier()：指定装配的bean，多个实例时可以结合@Autowired一起使用
>  *  @Primary：自动装配时当出现多个bean候选者时，被注解为`@Primary`的bean将作为首选者
>  *  @Resource：默认按名称装配，当找不到与名称匹配的bean才会按类型装配（不支持`@Primary`和`@Autowired(required = false)`功能，JDK提供）
>  *  @Inject：需要导入javax.inject的包，和Autowired功能一样，但是没有`required=false`功能（JDK提供）

【2】自动装配

Spring利用依赖注入（DI）完成对IOC容器中各个组件的依赖关系赋值

**`@Autowired`自动注入（Spring提供的）：**

*  默认优先按照去容器中找对应的组件：applicationContext.getBean()
 *  如果找到多个相同类型的组件，再将属性的名称作为组件的ID去容器中查找
 *  @Qualifier()注解：该注解指定需要装配的组件ID，而不是使用属性名
 *  自动装配默认必须要对属性赋值，没有就会报错，可以使用`@Autowired(required = false)`指定非必须就不会报错
 *  @Primary注解：自动装配时当出现多个bean候选者时，被注解为`@Primary`的bean将作为首选者，否则将抛出异常，如果使用了`@Qualifier()`指定装配的bean，则还是使用明确指定装配的bean

**@Resource(JSR250)和@Inject(JSR330)（JDK提供的）**

@Resource：

*  默认按照组件名称进行装配，也可以指定名称进行装配
 *  当找不到与名称匹配的bean会按类型装配
 *  不支持`@Primary`和`@Autowired(required = false)`功能
 *  如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。
 *  如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。
 *  如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。
 *  如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

@Inject：

*  需要导入javax.inject的包，和Autowired功能一样，但是没有`required=false`功能

【3】@Autowired和@Resource注解的区别

*  @Autowired由Spring提供，只按照byType注入；@Resource由J2EE提供，默认按照byName自动注入，当找不到与名称匹配的bean会按类型装配
 *  @Autowired默认按类型装配，默认情况下必须要求依赖对象存在，如果要允许null值，可以设置它的required属性为false。如果想使用名称装配可以结合@Qualifier注解进行使用。
 *  @Resource，默认按照名称进行装配，名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名进行名称查找。如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

### 二、实例分析 ###

这里只对@Autowired注解标注在属性位置进行实例分析

【1】@Autowired注解

// 启动类
    @Test
    public void TestMain() {
        // 创建IOC容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = applicationContext.getBean(UserService.class);
        System.out.println("userService:" + userService);
    }
    
    // Service
    @Service
    public class UserService {
        @Autowired(required = false)	// 指定非必须
        @Qualifier("userDao2")		// 指定装配bean
        private UserDao userDao;
        @Override
        public String toString() {
            return "UserService{" +
                    "userDao=" + userDao +
                    '}';
        }
    }
    
    // Dao
    @Repository
    public class UserDao {
        private String label = "1";
        public void setLabel(String label) {
            this.label = label;
        }
        @Override
        public String toString() {
            return "UserDao{" +
                    "label='" + label + '\'' +
                    '}';
        }
    }
    
    // 配置类
    @Configuration
    @ComponentScan({"dao","service","controller"})
    public class AppConfig {
        @Primary		// 首选装配bean
        @Bean("userDao2")
        public UserDao userDao(){
            UserDao userDao = new UserDao();
            userDao.setLabel("2");
            return userDao;
        }
    }

输出结果如下，由于上面使用`@Qualifier("userDao2")`指定了要装配的bean，所以这里输出的是label=’2‘：

![image-20210313102341875][]

>  *  如果将`@Qualifier("userDao2")`改为`@Qualifier("userDao")`，则装配的是`label=’1‘`

【2】@Resource注解

@Service
    public class UserService {
        @Resource(name = "userDao2",type = UserDao.class)
        private UserDao userDao;
        @Override
        public String toString() {
            return "UserService{" +
                    "userDao=" + userDao +
                    '}';
        }
    }

>  *  默认按照组件名称进行装配，也可以指定名称进行装配
>  *  当找不到与名称匹配的bean会按类型装配
>  *  不支持`@Primary`和`@Autowired(required = false)`功能
>  *  如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。
>  *  如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。
>  *  如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。
>  *  如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

### 三、源码追踪 ###

这里对@Autowired注解底层进行源码分析

参考：[https://blog.csdn.net/topdeveloperr/article/details/87971446][https_blog.csdn.net_topdeveloperr_article_details_87971446]

@Autowired是用来装配bean的，肯定和bean的实例化有关，先经过了refresh方法，在finishBeanFactoryInitialization方法中getBean，然后走getObject的时候触发bean的初始化。bean的初始化是一个很复杂地方，在AbstractAutowireCapableBeanFactory\#doCreateBean方法中，先创建一个BeanWrapper，它的内部成员变量wrappedObject中存放的就是实例化的MyService对象，[Spring Bean的生命周期源码详解 - 【Spring底层原理】][Spring Bean_ - _Spring]，再往后进入populateBean方法进行属性注入

Spring对autowire注解的实现逻辑位于类:`AutowiredAnnotationBeanPostProcessor#postProcessProperties`之中，——>findAutowiringMetadata——>buildAutowiringMetadata，核心代码就在buildAutowiringMetadata方法里面

private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
        if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
            return InjectionMetadata.EMPTY;
        } else {
            List<InjectedElement> elements = new ArrayList();
            // 需要处理的目标类
            Class targetClass = clazz;
    
            do {
                List<InjectedElement> currElements = new ArrayList();
                // 通过反射获取该类所有的字段，并遍历每一个字段，并通过方法findAutowiredAnnotation遍历每一个字段的所用注解，并如果用autowired修饰了，则返回auotowired相关属性
                ReflectionUtils.doWithLocalFields(targetClass, (field) -> {
                    MergedAnnotation<?> ann = this.findAutowiredAnnotation(field);
                    if (ann != null) {
                        // 校验autowired注解是否用在了static方法上
                        if (Modifier.isStatic(field.getModifiers())) {
                            if (this.logger.isInfoEnabled()) {
                                this.logger.info("Autowired annotation is not supported on static fields: " + field);
                            }
    
                            return;
                        }
    
                        // 判断是否指定了required
                        boolean required = this.determineRequiredStatus(ann);
                        currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement(field, required));
                    }
    
                });
                // 和上面一样的逻辑，但是是通过反射处理类的method
                ReflectionUtils.doWithLocalMethods(targetClass, (method) -> {
                    Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                    if (BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                        MergedAnnotation<?> ann = this.findAutowiredAnnotation(bridgedMethod);
                        if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                            if (Modifier.isStatic(method.getModifiers())) {
                                if (this.logger.isInfoEnabled()) {
                                    this.logger.info("Autowired annotation is not supported on static methods: " + method);
                                }
    
                                return;
                            }
    
                            if (method.getParameterCount() == 0 && this.logger.isInfoEnabled()) {
                                this.logger.info("Autowired annotation should only be used on methods with parameters: " + method);
                            }
    
                            boolean required = this.determineRequiredStatus(ann);
                            PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                            currElements.add(new AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement(method, required, pd));
                        }
    
                    }
                });
                // 用@Autowired修饰的注解可能不止一个，因此都加在currElements这个容器里面，一起处理
                elements.addAll(0, currElements);
                targetClass = targetClass.getSuperclass();
            } while(targetClass != null && targetClass != Object.class);
    
            return InjectionMetadata.forElements(elements, clazz);
        }
    }

>  *  获取需要处理的目标类
>  *  通过doWithLocalFields方法传入目标类参数，通过反射获取该类所有的字段，并遍历每一个字段，并通过方法findAutowiredAnnotation遍历每一个字段的所用注解，并如果用autowired修饰了，则返回auotowired相关属性
>  *  判断autowired注解是否用在了static方法上
>  *  如有多个@Autowired修饰的注解，都加在currElements这个容器里面，一起处理

最后返回包含所有带有autowire注解修饰的一个InjectionMetadata集合，如下

*  targetClass：要处理的目标类
 *  elements：上述方法获取到的所以elements集合

public InjectionMetadata(Class<?> targetClass, Collection<InjectionMetadata.InjectedElement> elements) {
        this.targetClass = targetClass;
        this.injectedElements = elements;
    }

有了目标类，与所有需要注入的元素集合之后，我们就可以实现autowired的依赖注入逻辑了，实现的方法如下:

public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
        if (!this.validatedBeanNames.contains(beanName)) {
            if (!this.shouldSkip(this.beanFactory, beanName)) {
                List<String> invalidProperties = new ArrayList();
                PropertyDescriptor[] var6 = pds;
                int var7 = pds.length;
    
                for(int var8 = 0; var8 < var7; ++var8) {
                    PropertyDescriptor pd = var6[var8];
                    if (this.isRequiredProperty(pd) && !pvs.contains(pd.getName())) {
                        invalidProperties.add(pd.getName());
                    }
                }
    
                if (!invalidProperties.isEmpty()) {
                    throw new BeanInitializationException(this.buildExceptionMessage(invalidProperties, beanName));
                }
            }
    
            this.validatedBeanNames.add(beanName);
        }
    
        return pvs;
    }

调用InjectionMetadata中定义的inject方法：

public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
        Collection<InjectionMetadata.InjectedElement> checkedElements = this.checkedElements;
        Collection<InjectionMetadata.InjectedElement> elementsToIterate = checkedElements != null ? checkedElements : this.injectedElements;
        if (!((Collection)elementsToIterate).isEmpty()) {
            Iterator var6 = ((Collection)elementsToIterate).iterator();
    
            while(var6.hasNext()) {
                InjectionMetadata.InjectedElement element = (InjectionMetadata.InjectedElement)var6.next();
                element.inject(target, beanName, pvs);
            }
        }
    }

进行遍历，然后调用inject方法，inject方法其实现逻辑如下:

protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs) throws Throwable {
        if (this.isField) {
            Field field = (Field)this.member;
            // 暴力破解的方法，通过反射技术对对象进行实例化和赋值
            ReflectionUtils.makeAccessible(field);
            field.set(target, this.getResourceToInject(target, requestingBeanName));
        } else {
            if (this.checkPropertySkipping(pvs)) {
                return;
            }
    
            try {
                Method method = (Method)this.member;
                ReflectionUtils.makeAccessible(method);
                // 注入的bean的名字，这个方法的功能就是根据这个bean的名字去拿到它
                method.invoke(target, this.getResourceToInject(target, requestingBeanName));
            } catch (InvocationTargetException var5) {
                throw var5.getTargetException();
            }
        }
    }

>  *  使用了反射技术，分成字段和方法去处理的。
>  *  makeAccessible这样的可以称之为暴力破解的方法，通过反射技术对对象进行实例化和赋值
>  *  getResourceToInject方法的参数就是要注入的bean的名字，这个方法的功能就是根据这个bean的名字去拿到它

### 四、总结 ###

@AutoWired自动注入过程图：

![image-20210313173345709][]

[image-20210313102341875]: /images/20210920/a9d870d9261a451bacd47f02319dbe69.png
[https_blog.csdn.net_topdeveloperr_article_details_87971446]: https://blog.csdn.net/topdeveloperr/article/details/87971446
[Spring Bean_ - _Spring]: https://mp.weixin.qq.com/s?__biz=MzU2MDQ2MTE5MA==&mid=2247484381&idx=1&sn=86696631aa894f896863f990c000659b&chksm=fc06e734cb716e2213545625de57e127f5e52fcce136a078166076c62253f62bbe10a0d196b7&token=1220372360&lang=zh_CN#rd
[image-20210313173345709]: /images/20210920/cb5d165bf114475981f5cd510e7bfe64.png