ja培训SpringBoot自动装配法则

来源：动力 2025年05月16日 12:20

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的配备和基于JaConfig类的配备模式，【关心唯科学城，得心应手讲授IT】这对于解释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汇入一样，用作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 基于JaConfig类的配备

只想要带进JaConfig类，需用作@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来给予记事配备

/**

* 用作JaConfig配备

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

这个装入存储了bean假定，但是bean此时还不才会透过一般来说转化，在透过一般来说转化此年前，还有一个

BeanFactoryPostProcessor

可以对bean取向透过一些自假定处理

我们开启BeanFactoryProcessor这个模块的源代码可以可推测如下段落：

* Modify the application context's internal bean factory after its standard

* initialization. All bean definitions will he been loaded, but no beans

* will he 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源明文中的开启包内成像

注意：这那时候绝不用作JaConfig类来配备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

而ValueHolder这个取向继承于BeanMetadataElement，就是基底筒倍数的一个包内装种类

通过这个都是我们可以看不到ConstructorArgumentValues就是用来监管基底筒倍数的，【关心唯科学城，得心应手讲授IT】原则上这个倍数才会在透过bean汇入的时候选择合适的基底筒。

5. 装有取向

过去我们把注意力捡回老家到SpringBoot的系统才会装有跟着，取而代之在根本透过bean一般来说转化取向年前，我们年下面还有这些煽动复，更是是存在用作在后处理筒BeanFactoryPostProcessor来对bean假定透过各种自假定修订的操控。

经过后面我们漫窄的科学研究煽动复，我们事与愿违可以回老家答第一个原因了：

系统才会装有的取向：Bean假定（BeanDefinition）

6. My系统才会装有

看不到这那时候又自然地才会产生或许：不才会吧，后面可都是系统才会装有啊，我在源明文或者用作记事都配备了数组的倍数，然后纳个@Autowired记事就OK了，spring也是帮手我系统才会去装有。

终于中端一点话里，我就把XML明文写到成JaConfig配备类，然后用作@Configuration记事，这样也能系统才会装有，这不是很nice了吗？

6.1 系统才会装有之终于直觉

我的解释，后面的系统才会装有，我们至少要写到一个源明文，无论是什么表达方式，我们都至少需一个明文把它全部写到慢慢地，就算这个明文的段落是固定的，但是为了装有这个取向，我们不得不写到。

我们甚至都可以来作成COM了，比如我在讲授习spring框架整合时，把经常写到的都从来不成了COM：

有了这些COM，我们只需有如点，终于透过修订，就能用了。

这样来作无论如何很好，可是对于越来越固化的概念设计基底系，我们每次都从来不一些直复单手，是才会厌烦的。而且遭遇这么多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这个JaConfig配备类才会用作到的激来生到类，于是我们好不容易成章处开它所激来生到的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) // 增ean假定

public @interface MyEnableAutoConfig {

}

取而代之如此！你是用了@Import记事增添了Bean假定对吧，批注都写到着呢！

可是客官，@Import增ean假定是没错，但是它增添的是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类，可推测这个类早就就是我们就让写到的JaConfig新版本的源明文：

@Configuration

public class MyConfig {

@Bean

public A a(){

return new A();

}

@Bean

public B b(){

return new B();

}

激来生到这个MyConfig配备类，就相等于激来生到了A和B两个Bean假定

喂！你究竟从来不我！环绕了最主要圈，怎么还是激来生到这个源明文啊！这个源明文明明就是我自己写到的。

总结一下，我们这个都是至少环绕了这些煽动复：

6.5 将偷懒透过确实

"不才会才会偷懒的人应付忘了的原因“ —— 鲁迅

后面的都是也不才会多大优转化啊，我怎么说道更纳麻烦了？不但环绕了最主要圈，假定了许多新的路，到终于还是激来生到了我写到好的JaConfig类，却说确实我不是还在写到jaConfig类吗…

但是你了解到不才会：有了后面的机制，我只需把JaConfig类写到一次，然后捡在某个大多，在MyImportSelector中的纳入这个大多的全包内名方向上，再多用的时候必要增添最顶部的MyAutoConfig类，所有有关这个模块我需的的路，就全部系统才会搜集好了，甚至比触摸屏有如点添纳字符COM还要快！

我突然有了个很棒的只尝试，不真的你有了不才会。

如果你开始有点感受了，就才会自然地提出另一个原因：我这样来作无论如何可以提高效率，但是一段字符那时候写到入我自己自带的段落，每次修改上去不是以致于费劲了吗？

只看看这那时候，我就流泪回老家只见到用作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（即JaConfig源明文），就相等于我们在字符那时候手写到的"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啊，一个JaConfig配备类

那我们用作JaConfig不就是用来配备bean吗，所以有了这个记事不久我们可以在SpringBoot开始运行的主类中的用作@Bean标签配备类了，如下由此可知所示：

7.2 @ComponentScan

这个记事相信大家都认识到了，模块成像

这个成像的以内是：SpringBoot主重启类的同级方向上及子方向上

7.3 @EnableAutoConfiguration

来看这个记事，也是最核心的段落

这个记事怎么这么眼熟啊，还回老家只想就让的@MyEnableAutoConfig记事吗？就是我们自己写到的那个记事

进到@EnableAutoConfiguration：

看由此可知中的红圈年前方的记事：@Import(AutoConfigurationImportSelector.class)

究竟跟我们后面自己写到的段落一样！

这那时候的起着；还有增添了 AutoConfigurationImportSelector 这个类的bean假定

我们都真的，如果这个类借助了ImportSelector模块，那他肯定编写到了一个步骤，【关心唯科学城，得心应手讲授IT】就是我们后面编写到过的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记事，正是我们此行的起始啊…

到这那时候，系统才会装有确实是什么，应非常明确了，www.atguigu.com取而代之他是帮手我们激来生到了各种仍未写到好的Config类明文，借助了这些JaConfig源明文的直复依靠和模块转化

7.4 loadFactoryNames步骤

同一时间不能到此落幕，讲授习不能浅尝辄止。

我们还有终于一块（几块）外衣不才会解开，过去还不能善罢甘休。

让我们进到loadFactoryNames步骤：

这个步骤非常简短，因为他绑定了根本借助的步骤：loadSpringFactories

这悄悄return字符我激来生在后面：

loadSpringFactories(classLoader)

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

可以系统性计算出来：loadSpringFactories步骤的留在倍数又绑定了一个getOrDefault步骤，这引人注意是一个装入类的步骤，目标都从装入中的拿点的路出来

先前可推测：loadSpringFactories留在了一个包内含我们需的Config全类名（字符）的可数装入，然后从这个可数装入中的拿出来的的路就是我们的configurations

让我们看这个loadSpringFactories步骤：

它无论如何留在了一个装入：Map 这个装入的种类是：MultiValueMap

这个链表就非常牛逼了，多倍数可数给定（我自己的翻译）简单来却说，一个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就借助了系统才会。