spring自动装配的原理解析

前言

学习SpringBoot，绝对避不开自动装配这个概念，这也是SpringBoot的关键之一

本人也是SpringBoot的初学者，下面的一些总结都是结合个人理解和实践得出的，如果有错误或者疏漏，请一定一定一定（不是欢迎，是一定）帮我指出，在评论区回复即可，一起学习！

篇幅较长，希望你可以有耐心.

如果只关心SpringBoot装配过程，可以直接跳到第7部分

想要理解spring自动装配，需要明确两个含义：

• 装配，装配什么？
• 自动，怎么自动？

1. Warm up

在开始之前，让我们先来看点简单的开胃菜：spring中bean注入的三种形式

首先我们先来一个Person类，这里为了篇幅长度考虑使用了lombok

如果你不知道lombok是什么，那就最好不要知道，加了几个注解之后我的pojo类Person就完成了

/**
 * @author dzzhyk
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    private String name;
    private Integer age;
    private Boolean sex;
}

在Spring中（不是Spring Boot），要实现bean的注入，我们有3种注入方式：

1.1 setter注入

这是最基本的注入方式

首先我们创建applicationContext.xml文件，在里面加入：

<!-- 手动配置bean对象 -->
<bean id="person" class="pojo.Person">
    <property name="name" value="dzzhyk"/>
    <property name="age" value="20"/>
    <property name="sex" value="true"/>
</bean>

这里使用property为bean对象赋值

紧接着我们会在test包下写一个version1.TestVersion1类

/**
 * 第一种bean注入实现方式 - 在xml文件中直接配置属性
 */
public class TestVersion1 {
    @Test
    public void test(){
        ApplicationContext ca = new   ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = ca.getBean("person", Person.class);
        System.out.println(person);
    }
}

这里我使用了ClassPathXmlApplicationContext来加载spring配置文件并且读取其中定义的bean，然后使用getBean方法使用id和类来获取这个Person的Bean对象，结果成功输出：

Person(name=dzzhyk, age=20, sex=true)

1.2 构造器注入

接下来是使用构造器注入，我们需要更改applicationContext.xml文件中的property为construct-arg

<!-- 使用构造器 -->
<bean id="person" class="pojo.Person">
    <constructor-arg index="0" type="java.lang.String" value="dzzhyk" />
    <constructor-arg index="1" type="java.lang.Integer" value="20"/>
    <constructor-arg index="2" type="java.lang.Boolean" value="true"/>
</bean>

version2.TestVersion2内容不变：

public class TestVersion2 {
    @Test
    public void test(){
        ApplicationContext ca = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = ca.getBean("person", Person.class);
        System.out.println(person);
    }
}

依然正常输出结果：

Person(name=dzzhyk, age=20, sex=true)

1.3 属性注入

使用注解方式的属性注入Bean是比较优雅的做法

首先我们需要在applicationContext.xml中开启注解支持和自动包扫描：

<context:annotation-config />
<context:component-scan base-package="pojo"/>

在pojo类中对Person类加上@Component注解，将其标记为组件，并且使用@Value注解为各属性赋初值

@Component
public class Person {
    
    @Value("dzzhyk")
    private String name;
    @Value("20")
    private Integer age;
    @Value("true")
    private Boolean sex;
}

然后添加新的测试类version3.TestVersion3

public class TestVersion3 {
    @Test
    public void test(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = ac.getBean("person", Person.class);
        System.out.println(person);
    }
}

运行也可以得到如下结果：

Person(name=dzzhyk, age=20, sex=true)

2. Warm up again

什么？还有什么？接下来我们来聊聊Spring的两种配置方式：基于XML的配置和基于JavaConfig类的配置方式，这对于理解SpringBoot的自动装配原理是非常重要的。

首先我们在Person的基础上再创建几个pojo类：这个Person有Car、有Dog

public class Car {
    private String brand;
    private Integer price;
}

public class Dog {
    private String name;
    private Integer age;
}

public class Person {
    private String name;
    private Integer age;
    private Boolean sex;
    private Dog dog;
    private Car car;
}

2.1 基于XML的配置

接下来让我们尝试使用XML的配置方式来为一个Person注入

<bean id="person" class="pojo.Person">
    <property name="name" value="dzzhyk"/>
    <property name="age" value="20"/>
    <property name="sex" value="true"/>
    <property name="dog" ref="dog"/>
    <property name="car" ref="car"/>
</bean>

<bean id="dog" class="pojo.Dog">
    <property name="name" value="旺财"/>
    <property name="age" value="5" />
</bean>

<bean id="car" class="pojo.Car">
    <property name="brand" value="奥迪双钻"/>
    <property name="price" value="100000"/>
</bean>

然后跟普通的Bean注入一样，使用ClassPathXmlApplicationContext来加载配置文件，然后获取Bean

/**
 * 使用XML配置
 */
public class TestVersion1 {
    @Test
    public void test(){
        ClassPathXmlApplicationContext ca = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = ca.getBean("person", Person.class);
        System.out.println(person);
    }
}

输出结果如下：

Person(name=dzzhyk, age=20, sex=true, dog=Dog(name=旺财, age=5), car=Car(brand=奥迪双钻, price=100000))

2.2 基于JavaConfig类的配置

想要成为JavaConfig类，需要使用@Configuration注解

我们新建一个包命名为config，在config中新增一个PersonConfig类

@Configuration
@ComponentScan
public class PersonConfig {

    @Bean
    public Person person(Dog dog, Car car){
        return new Person("dzzhyk", 20, true, dog, car);
    }

    @Bean
    public Dog dog(){
        return new Dog("旺财", 5);
    }

    @Bean
    public Car car(){
        return new Car("奥迪双钻", 100000);
    }
}

此时我们的XML配置文件可以完全为空了，此时应该使用AnnotationConfigApplicationContext来获取注解配置

/**
 * 使用JavaConfig配置
 */
public class TestVersion2 {
    @Test
    public void test(){
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(PersonConfig.class);
        Person person = ac.getBean("person", Person.class);
        System.out.println(person);
    }
}

仍然正常输出了结果：

Person(name=dzzhyk, age=20, sex=true, dog=Dog(name=旺财, age=5), car=Car(brand=奥迪双钻, price=100000))

3. BeanDefinition

AbstractBeanDefinition

是spring中所有bean的抽象定义对象，我把他叫做bean定义

当bean.class被JVM类加载到内存中时，会被spring扫描到一个map容器中：

BeanDefinitionMap<beanName, BeanDefinition>

这个容器存储了bean定义，但是bean此时还没有进行实例化，在进行实例化之前，还有一个

BeanFactoryPostProcessor

可以对bean对象进行一些自定义处理

我们打开BeanFactoryProcessor这个接口的源码可以发现如下内容：

/*
* Modify the application context's internal bean factory after its standard
* initialization. All bean definitions will have been loaded, but no beans
* will have been instantiated yet. This allows for overriding or adding
* properties even to eager-initializing beans.
*/

在spring完成标准的初始化过程后，实现BeanFactoryPostProcessor接口的对象可以用于定制bean factory，所有的bean definition都会被加载，但是此时还没有被实例化。这个接口允许对一些bean定义做出属性上的改动。

简言之就是实现了BeanFactoryPostProcessor这个接口的类，可以在bean实例化之前完成一些对bean的改动。

大致流程我画了个图：

至此我们能总结出springIOC容器的本质：（我的理解）

由BeanDefinitionMap、BeanFactoryPostProcessor、BeanPostProcessor、BeanMap等等容器共同组成、共同完成、提供依赖注入和控制反转功能的一组集合，叫IOC容器。

4. BeanDefinition结构

既然讲到了BeanDefinition，我们来看一下BeanDefinition里面究竟定义了些什么

让我们点进AbstractBeanDefinition这个类，一探究竟：

哇！好多成员变量，整个人都要看晕了@_@

我们来重点关注以下三个成员：

private volatile Object beanClass;
private int autowireMode = AUTOWIRE_NO;
private ConstructorArgumentValues constructorArgumentValues;

4.1 beanClass

这个属性决定了该Bean定义的真正class到底是谁，接下来我们来做点实验

我们定义两个Bean类，A和B

@Component
public class A {
    @Value("我是AAA")
    private String name;
}
@Component
public class B {
    @Value("我是BBB")
    private String name;
}

接下来我们实现上面的BeanFactoryPostProcessor接口，来创建一个自定义的bean后置处理器

/**
 * 自定义的bean后置处理器
 * 通过这个MyBeanPostProcessor来修改bean定义的属性
 * @author dzzhyk
 */
public class MyBeanPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        GenericBeanDefinition defA = (GenericBeanDefinition) beanFactory.getBeanDefinition("a");
        System.out.println("这里是MyBeanPostProcessor，我拿到了：" + defA.getBeanClassName());
    }
}

最后在XML配置文件中开启包扫描

<context:component-scan base-package="pojo"/>
<context:annotation-config />

注意：这里不要使用JavaConfig类来配置bean，不然会报如下错误

ConfigurationClassBeanDefinition cannot be cast to org.springframework.beans.factory.support.GenericBeanDefinition

这个错误出自这一句：

GenericBeanDefinition defA = (GenericBeanDefinition) beanFactory.getBeanDefinition("a");

最后，我们创建一个测试类：

public class Test {
    @org.junit.Test
    public void test(){
        ClassPathXmlApplicationContext ca = new ClassPathXmlApplicationContext("applicationContext.xml");
        A aaa = ca.getBean("a", A.class);
        System.out.println("最终拿到了==> " + aaa);
    }
}

测试运行！

这里是MyBeanPostProcessor，我拿到了：pojo.A
最终拿到了==> A(name=我是AAA, b=B(name=我是BBB))

可以看到MyBeanPostProcessor成功拿到了A的Bean定义，并且输出了提示信息

接下来让我们做点坏事

我们在MyBeanPostProcessor中修改A的Bean对象，将A的beanClass修改为B.class

System.out.println("这里是MyBeanPostProcessor，我修改了："+ defA.getBeanClassName() + " 的class为 B.class");
// 把A的class改成B
defA.setBeanClass(B.class);

重新运行Test类，输出了一些信息后：报错了！

这里是MyBeanPostProcessor，我拿到了：pojo.A
这里是MyBeanPostProcessor，我修改了：pojo.A 的class为 B.class

BeanNotOfRequiredTypeException: 
 Bean named 'a' is expected to be of type 'pojo.A' but was actually of type 'pojo.B'

我要拿到一个A类对象，你怎么给我一个B类对象呢？这明显不对

综上所述，我们可以得出beanClass属性控制bean定义的类

4.2 autowireMode

我们继续看第二个属性：autowireMode，自动装配模式

我们在AbstractBeanDefinition源码中可以看到：

private int autowireMode = AUTOWIRE_NO;

自动装配模式默认是AUTOWIRE_NO，就是不开启自动装配

可选的常量值有以下四种：不自动装配，通过名称装配，通过类型装配，通过构造器装配

• AUTOWIRE_NO
• AUTOWIRE_BY_NAME
• AUTOWIRE_BY_TYPE
• AUTOWIRE_CONSTRUCTOR

接下来我们来模拟一个自动装配场景，仍然是A和B两个类，现在在A类中添加B类对象

@Component
public class A {
    @Value("我是AAA")
    private String name;
    @Autowired
    private B b;
}

我们希望b对象能够自动装配，于是我们给他加上了@Autowired注解，其他的完全不变，我们自定义的MyBeanPostProcessor中也不做任何操作，让我们运行测试类：

这里是MyBeanPostProcessor，我拿到了：pojo.A
最终拿到了==> A(name=我是AAA, b=B(name=我是BBB))

自动装配成功了！我们拿到的A类对象里面成功注入了B类对象b

现在问题来了，如果我把@Autowired注解去掉，自动装配会成功吗？

这里是MyBeanPostProcessor，我拿到了：pojo.A
最终拿到了==> A(name=我是AAA, b=null)

必然是不成功的

但是我就是想要不加@Autowired注解，仍然可以实现自动装配，需要怎么做？

这时就要在我们的MyBeanPostProcessor中做文章了，加入如下内容：

defA.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_NAME);

再输出结果：

这里是MyBeanPostProcessor，我拿到了：pojo.A
最终拿到了==> A(name=我是AAA, b=B(name=我是BBB))

自动装配成功了！这次我们可没加@Autowired，在我们的自定义的bean后置处理器中设置了autowireMode属性，也实现了自动装配

综上，autowireMode属性是用来控制自动装配模式的，默认值是AUTOWIRE_NO，即不自动装配

4.3 constructorArgumentValues

constructorArgumentValues的字面含义是构造器参数值

改变这个参数值，我们可以做到在实例化对象时指定特定的构造器

话不多说，show me your code：

因为要研究构造器，只能先”忍痛“关掉lombok插件，手写一个pojo.Student类

/**
 * Student类
 * @author dzzhyk
 */
@Component
public class Student {
    private String name;
    private Integer age;

    public Student() {
        System.out.println("==>使用空参构造器 Student()");
    }

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        System.out.println("==>使用双参数构造器 Student(String name, Integer age)");
    }
}

我们都知道，spring在实例化对象时使用的是对象的默认空参构造器：

我们新建一个测试方法test

@Test
public void test(){
    ApplicationContext ca = new ClassPathXmlApplicationContext("applicationContext.xml");
    Student student = ca.getBean("stu", Student.class);
    System.out.println("==>" + student);
}

运行可以得到下面结果：

这里是MyBeanPostProcessor，我拿到了：pojo.Student
==>使用空参构造器 Student()
==>pojo.Student@402e37bc

可以看到，确实使用了空参构造器

但是如何指定（自定义）使用哪个构造器呢？我根本看不见摸不着，Spring全帮我做了，实在是太贴心了。

接下来就聊聊constructorArgumentValues的使用：

我们在MyBeanPostProcessor中加入如下内容，对获取到的pojo.Student的bean定义进行操作：

ConstructorArgumentValues args = new ConstructorArgumentValues();
args.addIndexedArgumentValue(0, "我指定的姓名");
args.addIndexedArgumentValue(1, 20);
defStu.setConstructorArgumentValues(args);

再次运行test：

这里是MyBeanPostProcessor，我拿到了：pojo.Student
==>使用双参数构造器 Student(String name, Integer age)
==>pojo.Student@2f177a4b

可以看到这次使用了双参数构造器

有人会好奇ConstructorArgumentValues到底是个什么东西，我点进源码研究一番，结果发现这个类就是一个普通的包装类，包装的对象是ValueHolder，里面一个List一个Map<Integer, ValueHolder>

而ValueHolder这个对象继承于BeanMetadataElement，就是构造器参数的一个包装类型

通过这个例子我们可以看到ConstructorArgumentValues就是用来管控构造器参数的，指定这个值会在进行bean注入的时候选择合适的构造器。

5. 装配对象

现在我们把目光放回到SpringBoot的自动装配上来，原来在真正进行bean实例化对象前，我们前面还有这些过程，尤其是存在使用后置处理器BeanFactoryPostProcessor来对bean定义进行各种自定义修改的操作。

经过上面我们漫长的研究过程，我们终于可以回答第一个问题了：

自动装配的对象：Bean定义 （BeanDefinition）

6. My自动装配

看到这里又自然会产生疑问：不会吧，上面可都是自动装配啊，我在配置文件或者使用注解都配置了变量的值，然后加个@Autowired注解就OK了，spring也是帮我自动去装配。

再高端一点话，我就把XML文件写成JavaConfig配置类，然后使用@Configuration注解，这样也能自动装配，这不是很nice了吗？

6.1 自动装配之再思考

我的理解，上面的自动装配，我们至少要写一个配置文件，无论是什么形式，我们都至少需要一个文件把它全部写下来，就算这个文件的内容是固定的，但是为了装配这个对象，我们不得不写。

我们甚至都可以做成模板了，比如我在学习spring框架整合时，把经常写的都搞成了模板：

有了这些模板，我们只需要点点点，再进行修改，就能用了。

这样做确实很好，可是对于越来越成型的项目体系，我们每次都搞一些重复动作，是会厌烦的。而且面对这么多xml配置文件，我太难了。

于是我有了一个想说但不敢说的问题：

我一个配置文件都不想写，程序还能照样跑，我只关心有我需要的组件就可以了，我只需要关注我的目标就可以了，我想打开一个工程之后可以1秒进入开发状态，而不是花3小时写完配置文件（2.5小时找bug）希望有个东西帮我把开始之前的准备工作全做了，即那些套路化的配置，这样在我接完水之后回来就可以直接进行开发。

说到这里，想必大家都懂了：SpringBoot

6.2 一个例子

让我们在偷懒的道路上继续前进。

来看下面这个例子：

仍然是A类和B类，其中A类仍然引用了B类，我们给A类组件起id=“a”，B类组件起id=“b”

@Component("a")
public class A {
    @Value("我是AAA")
    private String name;
    @Autowired
    private B b;
}

@Component("b")
public class B {
    @Value("我是BBB")
    private String name;
}

可以看到我们使用了@Autowired注解来自动注入b，测试类如下：

@Test
public void test(){
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyAutoConfig.class);
A aaa = ac.getBean("a", A.class);
System.out.println(aaa);
}

细心的同学已经发现了：我们这里使用了AnnotationConfigApplicationContext这个JavaConfig配置类会使用到的加载类，于是我们顺利成章地点开它所加载的MyAutoConfig类文件

文件内容如下：

@Configuration
@MyEnableAutoConfig
public class MyAutoConfig {
    // bean 都去哪了 ???
}

what? 我要声明的Bean对象都去哪了（注意：这里的applicationContext.xml是空的）？

让我们运行test：

A(name=我是AAA, b=B(name=我是BBB))

竟然运行成功了，这究竟是为什么？（元芳，你怎么看？）

细心的同学已经发现了：@MyEnableAutoConfig是什么注解？我怎么没有这个注解

让我们点进@MyEnableAutoConfig一探究竟：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(MyImportSelector.class)   // 导入bean定义
public @interface MyEnableAutoConfig {
}

原来如此！你是用了@Import注解导入了Bean定义对吧，注释都写着呢！

可是客官，@Import导入bean定义是没错，但是它导入的是MyImportSelector这个bean，不是A也不是B啊…

6.3 @Import注解

@Import的功能就是获取某个类的bean对象，他的使用形式大致如下：

@Import(A.class)
@Import(MyImportBeanDefinitionRegister.class)
@Import(MyImportSelector.class)

6.3.1 @Import(A.class)

第一种形式@Import(A.class)，是最简单易懂的形式

我们需要哪个Bean定义，直接Import他的class即可

6.3.2 @Import(MyImportBeanDefinitionRegister.class)

第二种形式@Import(MyImportBeanDefinitionRegister.class)

传递了一个bean定义注册器，这个注册器的具体内容如下：

public class MyImportBeanDefinitionRegister implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        
        RootBeanDefinition aDef = new RootBeanDefinition(A.class);
        registry.registerBeanDefinition("a", aDef);
        
    }
}

这个注册器实现了ImportBeanDefinitionRegistrar接口，并且重写了里面的registerBeanDefinitions方法

看他做了什么事：创建了一个新的bean定义，他的类型就是A，然后把这个bean定义注册到BeanDefinitionMap（还记得吧！）里面，key值我们可以人为设置，这里就设置成"a"

这样在传递一个注册器的时候，我们就可以把注册器中新增的bean定义注册进来使用

6.3.3 @Import(MyImportSelector.class)

可以看到，这种使用方式就是我们刚才的注解中使用的方式

他传递了一个叫MyImportSelector的类，这个类依然是我们自己定义的，具体内容如下：

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 导入配置类
        return new String[]{"config.MyConfig"};
    }
}

这个类实现了ImportSelector接口，并且重写了selectImports方法，返回一个字符串数组

我们可以看到，返回的字符串数组中是我们要导入类的全类名

这个Importer返回的类如果是组件bean对象，就会被加载进来使用；如果是一个配置类，就会加载这个配置类

第三种和第二种的区别是第三种可以一次性写很多类，而且比较简洁，只需要清楚类的全包名即可。而第二种方式需要自己清楚包类名，手动创建bean定义，然后手动加入BeanDefinitionMap。

6.4 例子的研究

我们打开MyImportSelector，发现里面赫然写着几个大字：

return new String[]{"config.MyConfig"};

然后我们找到config.MyConfig类，发现这个类竟然就是我们刚才写的JavaConfig版本的配置文件：

@Configuration
public class MyConfig {
    @Bean
    public A a(){
        return new A();
    }

    @Bean
    public B b(){
        return new B();
    }
}

加载这个MyConfig配置类，就相当于加载了A和B两个Bean定义

喂！你是不是搞我！绕了一大圈，怎么还是加载这个配置文件啊！这个配置文件明明就是我自己写的。

总结一下，我们这个例子大概绕了这些过程：

6.5 将偷懒进行到底

"没有会偷懒的人解决不掉的问题“ —— 鲁迅

上面的例子也没有多大优化啊，我怎么觉得更加麻烦了？不但绕了一大圈，定义了许多新东西，到最后还是加载了我写好的JavaConfig类，说到底我不是还在写javaConfig类吗…

但是你注意到没有：有了上面的机制，我只需要把JavaConfig类写一次，然后放在某个地方，在MyImportSelector中加入这个地方的全包名路径，下次用的时候直接导入最顶层的MyAutoConfig类，所有有关这个部件我需要的东西，就全部自动整理好了，甚至比鼠标点点点添加代码模板还要快！

我突然有了个很棒的想法，不知道你有了没有 。

如果你开始有点感觉了，就会自然提出另一个问题：我这样做确实可以提高效率，但是一段代码里写入我自己定制的内容，每次更改起来不是太费劲了吗？

想到这里，我就不禁回想起使用JDBC的时候，在代码里改SQL语句的痛苦了，那真是生不如死…这种情况就构成了硬编码的行为，是不好的。

我们自然会想到：要是我创建一个配置文件properties来专门保存我这个需求所使用的bean对象，然后使用的时候在MyImportSelector中读取配置文件并且返回全包名，不就更加nice了吗？

于是MyImportSelector中的代码又改成了下面这样：

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    
        Properties properties = MyPropertyReader.readPropertyForMe("/MyProperty.properties");
        String strings = (String) properties.get(MyEnableAutoConfig.class.getName());
       
        return new String[]{strings};
    }
}

其中MyPropertyReader是我们自己新创建的用于读取properties文件的工具类

之所以要自己再定义这样一个工具类，是为了以后在其中可以做一些其他操作（比如：去重、预检查）

public class MyPropertyReader {
    public static Properties readPropertyForMe(String path){
        Properties properties = new Properties();
        try(InputStream sin = MyPropertyReader.class.getResourceAsStream(path)){
            properties.load(sin);
        }catch (IOException e){
            e.printStackTrace();
            System.out.println("读取异常...");
        }
        return properties;
    }
}

我们的配置文件里面这么写：

anno.MyEnableAutoConfig=config.MyConfig

可以看到，key是注解@MyEnableAutoConfig的类名，也就是根据这个注解，就会导入后面的MyConfig这个Bean，这个Bean就是我们的配置文件

如此一来我们读取这个配置文件，然后加载跟这个注解名称相符的value（即JavaConfig配置文件），就相当于我们在代码里手写的"config.MyConfig"，只不过现在的形式已经发生了巨大的变化：我们添加或者删除一个配件，完全只需要修改MyProperty.properties这个配置文件就行了！

至此，无论是添加或者删除组件，无非是在配置文件中加上或者删除一行的问题了。

让我们在更新之后运行程序，可以看到成功拿到了配置文件的全类名

程序的运行当然也是没问题的：

A(name=我是AAA, b=B(name=我是BBB))

到此，我仿佛又领悟了一些东西。。。

我的配置文件好像活了，在我需要的时候他会出现，在我不需要的时候只需要在配置文件里面给他”打个叉“，他自己就跑开了

7. 自动装配源码分析

终于来到了大家喜闻乐见的部分：源码分析

在我们前面6节学习了各种”招式“之后，让我们请出对手：SpringBoot

现在在你面前的是一个SpringBoot”空项目“，没有添加任何依赖包和starter包

启动项目：

正常启动，让我们从@SpringBootApplication开始研究

7.1 @SpringBootConfiguration

会看到@SpringBootApplication这个注解由好多注解组成

主要的有以下三个：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

先来看第一个：@SpringBootConfiguration

进入这个注解之后会发现

原来你就是一个@Configuration啊，一个JavaConfig配置类

那我们使用JavaConfig不就是用来配置bean吗，所以有了这个注解之后我们可以在SpringBoot运行的主类中使用@Bean标签配置类了，如下图所示：

7.2 @ComponentScan

这个注解相信大家都认识了，组件扫描

这个扫描的范围是：SpringBoot主启动类的同级路径及子路径

7.3 @EnableAutoConfiguration

来看这个注解，也是最核心的内容

这个注解怎么这么眼熟啊，还记得刚才的@MyEnableAutoConfig注解吗？就是我们自己写的那个注解

进入@EnableAutoConfiguration：

看图中红圈位置的注解：@Import(AutoConfigurationImportSelector.class)

是不是跟我们上面自己写的内容一样！

这里的作用便是导入了 AutoConfigurationImportSelector 这个类的bean定义

我们都知道，如果这个类实现了ImportSelector接口，那他肯定重写了一个方法，就是我们上面重写过的selectImports方法：

果然，在这个类里面确实有这个selectImports方法：

我的天，好长的一串代码，一行都放不下！

此时此刻，我又回想起了在家乡的母亲，夏天的蝉鸣，池塘的荷花…

等等等等，这个类我们当时返回的是什么？是一个字符串数组String[ ]，那这个类无论多么长，返回的肯定就是一个字符串数组，不信你自己看：

这个字符串数组存放的内容我们是否清楚呢？当然清楚了！我们返回的是要加载的Config配置文件的全包名，通过返回这个全包名，我们就能自动装配上这些配置文件下定义的bean对象，从而达到了自动装配的目的！

根据刚才我们自己实现的selectImports方法，我们是通过注解类的名字来查找，并且最终得到需要加载的Config类的全类名，最后返回的。

因此，这里必然有一个根据注解类名字来查找相应的Config文件的操作

我们继续反推，看到返回时的定义如下：

我们发现autoConfigurationEntry中保存着我们需要的配置信息，它是通过getAutoConfigurationEntry方法获取的，于是我们继续深入，进入getAutoConfigurationEntry方法

这一段代码真是把人难住了，好大一片，不知道在做什么

此时此刻，我又回想起了在家乡的母亲，夏天的蝉鸣，池塘的荷花…

回家！有了！我们先想这个方法应该返回什么，根据我们前面的经验，这里应该返回一个类似于Entry的保存了我们需要的配置信息的对象

这个方法返回的是新建的AutoConfigurationEntry对象，根据最后一行的构造函数来看，给他了两个参数：

configurations, exclusions

configurations显然使我们需要的配置文件，也是我们最关心的，而exclusions字面意思是排除，也就是不需要的，那我们接下来应该关注configurations到底是怎么来的

根据我们前面的经验，我们是根据注解类名来从一个配置文件中读取出我们需要的Config配置类，这里configurations就代表了Config配置类，那么我们应该找到一个入口，这个入口跟注解相关，并且返回了configurations这个参数。

正如我们所料，这个方法的参数确实传递过来了一个东西，跟注解有关：

看见那个大大的Annotation（注解）了吗！

那么根据这条”线索“，我们按图索骥，找到了三行代码，范围进一步缩小了！

此时再加上返回了configurations，我们最终确定了一行代码：

就是这个getCandidateConfigurations方法，符合我们的要求！

从字面意思上分析，获取候选的配置，确实是我们需要的方法

OK，让我们继续前进，进入这个方法：

这个方法是不是也似曾相识呢？我们之前写过一个专门用于读取配置文件的类MyPropertyReader，还记得吗？

如果你还记得的话，我们自己写的工具类里面也是一个静态方法readPropertyForMe来帮我读取配置文件

但是我们的配置文件路径一定是需要指定的，不能乱放。

从这个loadFactoryNames方法体来看，好像没有给他传递一个具体路径

但是从下面的Assert断言中，我们发现了玄机：

在META-INF/spring.factories文件中没有找到自动配置类Config，你要检查balabala。。。。

根据我不太灵光的脑袋的判断，他的这个配置文件就叫spring.factories，存放的路径是META-INF/spring.factories

于是我们打开spring boot自动装配的依赖jar包：

那这个配置文件里面的内容，是不是跟我们想的一样呢？

原来如此。

这里的EnableAutoConfiguration注解，正是我们此行的起点啊…

到这里，自动装配到底是什么，应该比较清楚了，原来他是帮我们加载了各种已经写好的Config类文件，实现了这些JavaConfig配置文件的重复利用和组件化

7.4 loadFactoryNames方法

行程不能到此结束，学习不能浅尝辄止。

我们还有最后一块（几块）面纱没有解开，现在还不能善罢甘休。

让我们进入loadFactoryNames方法：

这个方法非常简短，因为他调用了真正实现的方法：loadSpringFactories

这一行return代码我复制在下面：

loadSpringFactories(classLoader)
     .getOrDefault(factoryTypeName, Collections.emptyList());

可以分析得出：loadSpringFactories方法的返回值又调用了一个getOrDefault方法，这明显是一个容器类的方法，目的是从容器中拿点东西出来

就此推测：loadSpringFactories返回了一个包含我们需要的Config全类名（字符串）的集合容器，然后从这个集合容器中拿出来的东西就是我们的configurations

让我们看这个loadSpringFactories方法：

它确实返回了一个容器：Map<String, List> 这个容器的类型是：MultiValueMap<String, String>

这个数据结构就非常牛逼了，多值集合映射（我自己的翻译）简单来说，一个key可以对应多个value，根据他的返回值，我们可以看到在这个方法中一个String对应了一个List

那么不难想到MultiValueMap中存放的形式：是”注解的类名——多个Config配置类“ 让我们打个断点来验证一下：

果然是这样，并且@EnableAutoConfiguration注解竟然加载了多达124个配置类！

接下来我们继续思考：我们来的目的是获取configurations，所以无论你做什么，必须得读取配置文件，拿到configurations

于是我们在try方法体中果然发现了这个操作：

他获取了一个路径urls，那么这个路径是否就是我们前面验证的META-INF/spring.factories呢？

我们查看静态常量FACTORIES_RESOURCE_LOCATION的值：

果真如此，bingo！继续往下看，果然他遍历了urls中的内容，从这个路径加载了配置文件：终于看到了我们熟悉的loadProperties方法！

那我们大概就知道了，他确实是通过找到路径，然后根据路径读取了配置文件，然后返回了读取的result

这就是loadFactoryNames方法的内部实现。

7.5 cache探秘

到这里有的人又要问了：是不是结束了？其实还远没有！

细心地朋友已经发现了玄机，隐藏在loadFactoryNames方法的开头和结尾：

喂喂，这个返回的result好像并不是直接new出来的哦

它是从cache缓存中取出来的，你发现了没有

根据下面的if判断，如果从缓存中读取出来了result，并且result的结果不为空，就直接返回，不需要再进行下面的读写操作了，这样减少了磁盘频繁的读写I/O

同理，在我更新完所有的配置文件资源之后，退出时也要更新缓存。

7.6 getAutoConfigurationEntry再探

关键部分已经过去，让我们反过头来重新审视一下遗漏的内容：

还记得getAutoConfigurationEntry方法吗？

我们最后来研究一下这个类除了getCandidateConfigurations还干了哪些事情：

• removeDuplicates
• configurations.removeAll(exclusions)

可以看到，这里对加载进来的配置进行了去重、排除的操作，这是为了使得用户自定义的排除包生效，同时避免包冲突异常，在SpringBoot的入口函数中我们可以通过注解指定需要排除哪些不用的包：

例如我不使用RabbitMQ的配置包，就把它的配置类的class传给exclude

@SpringBootApplication(exclude = {RabbitAutoConfiguration.class})

8. 自动装配本质

我的理解：

• SpringBoot自动装配的本质就是通过Spring去读取META-INF/spring.factories中保存的配置类文件然后加载bean定义的过程。
• 如果是标了@Configuration注解，就是批量加载了里面的bean定义
• 如何实现”自动“：通过配置文件获取对应的批量配置类，然后通过配置类批量加载bean定义，只要有写好的配置文件spring.factories就实现了自动。

9. 总结

Spring Boot的自动装配特性可以说是Spring Boot最重要、最核心的一环，正是因为这个特性，使得我们的生产复杂性大大降低，极大地简化了开发流程，可以说是给我们带来了巨大的福音了~~

笔者本人对源码的理解仍然没有那么深刻，只是喜欢分享自己的一些学习经验，希望能和大家共同学习，毕竟掌握一门新技术的快感嘛… 大家都懂的！

写这篇文章耗费了巨大的精力，每一个字均是手码，真的希望喜欢的朋友可以点赞收藏关注支持一波，这就是对我这个未出世的学生的最大激励了！

最后，我画了一份Spring Boot自动装配详细流程图，分享给大家。

Spring Boot自动装配详细流程图：