Sprng依赖注入（三）：构造方法注入是如何工作的？

电玩女神 2024-03-26 13:15 36阅读 0赞

## **前言** ##

这是Spring依赖注入系列的第三篇，前两篇主要分析了Spring bean依赖属性注入的两种方式，是字段注入和setter方法注入，单独比较这两种方式，会发现其过程和工作原理非常类似，那么构造方法注入会不会也和前两种比较类似呢？本篇文章将会揭晓答案。

## **构造方法注入方法** ##

以@Autowired注解为例，即把@Autowired注解标记在目标bean的构造方法上，而构造方法的入参数是引用bean类型；

## **构造方法注入示例** ##

示例主要内容：1、定义Teachert类; 2、定义Student类；3、在Student类中依赖Teacher；4、使用@Autowired注解标记在Student(Teacher teacher)上，即在Student对象中以构造方法注入的方式注入Teacher对象；

@Slf4j
    @Component
    public class Student {
        private String name="小明";
        private Teacher teacher;
        public Student() {
            log.info("----student的无参数构造方法被执行");
        }
        @Autowired
        public Student(Teacher teacher) {
            this.teacher = teacher;
            log.info("----student的有参数构造方法（teacher）被执行");
        }
        public Student(String name, Teacher teacher) {
            this.name = name;
            this.teacher = teacher;
            log.info("----student的有参数构造方法（name，teacher）被执行");
        }
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
            log.info("----student中的setTeacher方法被调用");
        }
    
    }

@Slf4j
    @Component
    public class Teacher  {
        private String name="李老师";
        private Student student;
        public Teacher() {
            log.info("----teacher的无参数构造方法被执行");
        }
        public Teacher(Student student) {
            this.student = student;
            log.info("----teacher的有参数构造方法被执行");
        }
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Student getStudent() {
            return student;
        }
    
        public void setStudent(Student student) {
            log.info("----teacher中的setStudent方法被调用");
            this.student = student;
        }
    }

@Component
    @Slf4j
    public class MyBeanPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if (beanName.equals("student")) {
                Student student = (Student) bean;
                log.info("----student属性注入完成,student.name:" + student.getName());
            }
            return bean;
        }
    }

@Component
    @Slf4j
    public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
        @Override
        public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
            if (beanName.equals("student")||beanName.equals("teacher")) {
                log.info("----bean实例化完成，beanName：" + beanName);
            }
            return true;
        }
    }

@Test
        public void test4() {
            log.info("----单元测试执行开始");
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.fanfu");
            Student bean = context.getBean(Student.class);
            log.info("----单元测试执行完毕");
        }

单元测试执行日志

![6fd412c87cfe4bdf920c4fa9a7943b40.png][]

从单元调试执行日志结果来看，teacher先被实例化，然后再调用student的有参数构造方法进行student对象的实例化，同时把teacher对象注入到了student对象里，这和字段注入、setter方法注入的过程明显不同，字段注入、setter方法注入都是student先实例化，然后实例化teacher对象，再把teacher对象注入到student对象里。这是一个非常明显的区别，要加深印象。

## **构造方法注入的工作原理** ##

这里从工作原理上，深入分析一下构造方法注入和字段注入、setter方法注入的过程的区别在哪里？

1、通过之前的分析，已经知道bean实例化时机是在AbstractAutowireCapableBeanFactory\#doCreateBean--->createBeanInstance()，那么先执行createBeanInstance()并观察其返回值，发现student对象实例化好的同时teacher对象也注入到student对象内，这和单元测试的执行日志结果是一致的；

![7e18567601df4308928d37444c4dce34.png][]

2、那就直接着进入到AbstractAutowireCapableBeanFactory\#createBeanInstance()，方法内第一行resolveBeanClass(mbd, beanName)，从名字看意思是解析出bean的Class实例对象，接着往下走调用determineConstructorsFromBeanPostProcessors(beanClass, beanName)，又引起了我的注意，看过我的这篇文章的小伙伴[Springboot扩展点之SmartInstantiationAwareBeanPostProcessor][Springboot_SmartInstantiationAwareBeanPostProcessor]，一定对determineCandidateConstructors()不陌生，这个方法可以决定使用哪个构造器构造 bean，执行结果就是student的有参数构造方法Student(Teacher teacher)；再来看下面的autowireConstructor(beanName, mbd, ctors, args)调用，从名字就能看出来是根据构造器自动装配bean；

![048c62ca5ca24e2e8dfda5f420b5a2e1.png][]

3、那还等什么，进入AbstractAutowireCapableBeanFactory\#autowireConstructor()，里面太简单了，new一个构造方法解析器对象（ConstructorResolver），调用ConstructorResolver\#autowireConstructor()；

4、ConstructorResolver\#autowireConstructor()内的解析过程比较复杂，各种的判断，让人眼花缭乱，但没关系，谁让我是一机灵鬼呢，我发现第一句就是BeanWrapperImpl bw = new BeanWrapperImpl()，这太熟悉了，Spring容器刚实例化好的bean都包装成一个BeanWrapper类型对象，我只需要牢牢看好这个对象，肯定能找到在什么时候注入student对象。后面果然让我抓到了，getUserDeclaredConstructor(candidate)拿到了有参数的构造方法对象，然后调用createArgumentArray()，入参数有bean的Class对象实例、bean构造方法形参名称，这个方法十有八九有我想要的结果；

![88b0363dea164e04b073823f5e920bc6.png][]

5、进入到ConstructorResolver\#createArgumentArray()，里面又是很多的判断，判断完之后又调用了ConstructorResolver\#resolveAutowiredArgument(); 这一块判断比较多，一定要耐心;

这个方法要加印象，一会记得看一下返回值（在第10步）；

![0fcfb6fedd0742b4a63654aeadb0b284.png][]

6、进入到ConstructorResolver\#resolveAutowiredArgument()，眼前一亮发现了 this.beanFactory.resolveDependency(...)，而这里的this.beanFactory是DefaultListableBeanFactory，有看过[Spring依赖注入（一）：字段注入的方式是如何工作的？][Spring][Sprng依赖注入（二）：setter注入是如何工作的？][Sprng_setter]的一对这个方法也不会陌生，从名字也能看出来是bean的依赖解析；

![c4fb7e0fcec742958281bd4bf7444e88.png][]

7、进入到DefaultListableBeanFactory\#resolveDependency()，又调用了doResolveDependency();

![c333487d742f41baabede976c54d6151.png][]

8、doResolveDependency()中，又调用了findAutowireCandidates(beanName, type, descriptor)查找Student类依赖属性Teacher类的Class对象；

![52a142189b214f8eb35e0d62dc6e0247.png][]

9、doResolveDependency()中，继续向下会调用descriptor.resolveCandidate(...)，而这个方法就是根据上一步得到Teacher类的Class对象实例化Teacher；进入到descriptor.resolveCandidate(...)，就一句beanFactory.getBean(beanName)，是不是熟悉的配方熟悉的味道？

![199fd24e60e44a588f03c09fedb39691.png][]

10、跳过teacher对象的创建过程，继续往下，直到ConstructorResolver\#createArgumentArray()执行完，返回值是teacher对象，还记得开始是准备实例化student，但是student还没实例化，其依赖的引用属性teacher已经完成了实例化了；

![c742919446a54fe188e0c9227eea89f3.png][]

11、继续往下走，一直到ConstructorResolver\#autowireConstructor()的最后一步，这时第4步new的BeanWrapperImpl()对象开始往里面注入student对象了，但是这里不是直接注入，而是先调用ConstructorResolver\#instantiate(String, RootBeanDefinition,Constructor, Object\[\])实例化Student，拿到student对象再包装进BeanWrapperImpl对象，这里着重看一下instantiate()的入参数是：构造方法对象、teacher对象；

![ef489fe0261a4117928b0ddbdeb4fdda.png][]

12、至此teacher、student对象都已经实例化了，并且student对象的依赖属性teacher也注入了；继续往下走，直到AbstractAutowireCapableBeanFactory\#doCreateBean--->createBeanInstance()执行完；还记得在[Spring依赖注入（一）：字段注入的方式是如何工作的？][Spring 1]是如何分析的吗？如下：

> Spring中bean创建核心逻辑都在AbstractAutowireCapableBeanFactory\#doCreateBean()中，这个方法主要干了这几件事：第一，bean的实例化；第二，bean的后置处理方法执行；第三，把实例化完成、未完成属性注入的bean提前暴露到Spring的第三级缓存中去；第四，bean依赖属性注入；第五，bean的初始化；student对象在完成这几步后，就可以作为Spring容器中正式的bean开始被使用了。

但是事实上，createBeanInstance()执行完的时候，依赖属性注入已经完成了，第三步注入到Spring第三级缓存里的bean已经是一个完成属性注入的bean了，第四步也不会再执行注入操作了；

## **构造方法注入总结** ##

Spring bean使用构造方法注入依赖属性的注入时机，要早于字段注入和、setter方法注入，而且注入到Spring第三级缓存里的bean已经是一个完成依赖属性注入的bean。得到这个结论，后面再来分析Spring的bean的循环依赖为什么有的是可以解决的？有的是解决不了的？其实答案已经明显了，下面一篇文章将重点分析。

[6fd412c87cfe4bdf920c4fa9a7943b40.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/97cf8ffb9c5445358d0f7380b3a8ee14.png
[7e18567601df4308928d37444c4dce34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9357a968783d45c8b52aecda97f73ebb.png
[Springboot_SmartInstantiationAwareBeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128976944
[048c62ca5ca24e2e8dfda5f420b5a2e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/291a9f006c41469c9431a779a4c79e53.png
[88b0363dea164e04b073823f5e920bc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9f7c9153fb084192a6fba0745805b085.png
[0fcfb6fedd0742b4a63654aeadb0b284.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f2159d9084c14055af59030323369c5d.png
[Spring]: https://blog.csdn.net/fox9916/article/details/129150036
[Sprng_setter]: https://blog.csdn.net/fox9916/article/details/129170147?spm=1001.2014.3001.5501
[c4fb7e0fcec742958281bd4bf7444e88.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f1690094efe8492697690b5cc045445a.png
[c333487d742f41baabede976c54d6151.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/fe62f526760a45db8fb85767e097f91f.png
[52a142189b214f8eb35e0d62dc6e0247.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/2121be8efb5d42ae91ba1c4a862e8060.png
[199fd24e60e44a588f03c09fedb39691.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/011403c4f5d44716ae77ef4e907cea82.png
[c742919446a54fe188e0c9227eea89f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/43ddb397f9db4724a9f0f0d6d73d7c6c.png
[ef489fe0261a4117928b0ddbdeb4fdda.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/dfcfe5b4528548c4bb40a4d821dcba17.png
[Spring 1]: https://blog.csdn.net/fox9916/article/details/129150036?spm=1001.2014.3001.5501