前言

这是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("----单元测试执行完毕");
    }

单元测试执行日志

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

构造方法注入的工作原理

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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的循环依赖为什么有的是可以解决的？有的是解决不了的？其实答案已经明显了，下面一篇文章将重点分析。