@Implementation principle of Autowired annotation

Catalog

Preface

One 、@Autowired Use of annotations

Two 、@Autowired Annotate the process of automatic assembly

3、 ... and 、@Autowired Annotation source code analysis

---

Preface

          Before analyzing the implementation principle of this annotation , Let's review @Autowired Use of annotations .

One 、@Autowired Use of annotations

        [email protected] Annotations apply to construction methods , Examples are as follows ：

@Autowired
public OrderService(UserService userService){
    this.userService = userService;
}

       @Autowired When added to the construction method ,Spring At the stage of inferring the construction method , Select this construction method to instantiate , Before reflection calls the constructor , First, according to the parameter type of the construction method 、 The parameter name is from Spring Found in the container Bean object , As a constructor .

        [email protected] Annotations apply to attributes , Examples are as follows ：

@Autowired
private IUserService Service;

        @Autowired Add to an attribute ,Spring It's going on Bean During the life cycle of , In the step of property filling , Based on the instantiated object , Added... To the object @Autowired Automatically assign a value to the property of .Spring We will go first according to the type Spring Find all... Of this type in the container Bean object , If you find more than one , Then determine another one from multiple according to the name of the attribute , If required The attribute is true, And the object cannot be found according to the attribute information , Throw the exception directly .

        [email protected] Annotations apply to methods , Examples are as follows ：

@Autowired
public void setUserService(UserService userService){
    this.userService = userService;
}

       @Autowired When an annotation is written on a method ,Spring stay Bean The attribute filling phase of the lifecycle , According to the parameter type of the method 、 The parameter name is from Spring The container finds the object as a method input , Automatic reflection calls this method .

Two 、@Autowired Annotate the process of automatic assembly

 @Autowired adopt Bean The post processor of

 1. Creating a Spring The context is registered in the constructor AutowiredAnnotationBeanPostProcessor

 2. stay Bean During the creation of ：

          2.1 Pre parse （ analysis @Autowired The properties of the annotation 、 Method , such as ： Put the type of attribute 、 name 、 The class of the property ... Metadata is cached ;

          2.2 Inject real parsing into attributes ( Get the metadata cached in the previous step IOC Container to find , And return to inject );

                a. First, get the type according to the pre parsed metadata and search in the container ：

                        ·  If there is no matching class in the query result , Then an exception will be reported NoSuchBeanDefinitionException

                        ·  If the query result is exactly one , It's time to bean Assemble to @Autowired Specified data ;

                        ·  If there is more than one query result , that @Autowired Will look up... By name , If not, an error will be reported NoUniqueBeanDefinitionException

                      

3、 ... and 、@Autowired Annotation source code analysis

         stay Spring In the source code ,Autowired The annotation is located in the package org.springframework.beans.factory.annotation In , The contents of the package are as follows ：

      Through the analysis of , It's not hard to find out Spring Yes autowired The implementation logic of annotations is located in class AutowiredAnnotationBeanPostProcessor In , It has been marked red in the figure above . The core processing code is as follows ：

    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, beanType, (PropertyValues)null);
        metadata.checkConfigMembers(beanDefinition);
    }

       postProcessMergedBeanDefinition() The function of the method is to find the elements that need to be automatically assembled , Build metadata information , Then encapsulate the AutowiredFieledElement or AutowiredMethodElement in , Then call the inject Method , By reflection , Calling the container's getBean() Method to find what needs to be injected Bean object , Then inject into Bean in .

    protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
            if (!this.checkPropertySkipping(pvs)) {
                Method method = (Method)this.member;
                Object[] arguments;
                if (this.cached) {
                    try {
                        arguments = this.resolveCachedArguments(beanName);
                    } catch (NoSuchBeanDefinitionException var8) {
                        arguments = this.resolveMethodArguments(method, bean, beanName);
                    }
                } else {
                    arguments = this.resolveMethodArguments(method, bean, beanName);
                }

                if (arguments != null) {
                    try {
                        ReflectionUtils.makeAccessible(method);
                        method.invoke(bean, arguments);
                    } catch (InvocationTargetException var7) {
                        throw var7.getTargetException();
                    }
                }

           }
      }