SpringBoot（二） 依赖管理、自动配置、容器注解功能

二、依赖管理与自动配置

2.1 父项目做依赖管理

父项目里面会声明非常多的依赖，子项目只要继承了这个父项目，子项目以后写依赖，就不需要版本号了。我们这个父项目是2.3.4版本，我们子项目写依赖，都是不需要加版本号的。

比如以后我们想要引入mysql-connector

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

几乎声明了所有开发中常用的依赖的版本号，自动仲裁机制。

如果不想用它给的这个版本，而是想自定义版本：

我们写一个来声明我们的mysql版本，把我们满意的版本写进去

    <properties>
        <mysql.version>5.1.43</mysql.version>
    </properties>

2.2 各种场景启动器

我们现在可以看到，我们开发一个web应用，无需关心到底要导哪些包，我们只需要导入一个

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

未来我们在SpringBoot里会见到非常多的以spring-boot-starter-*命名的东西。“*”代表某种场景。

我们只需要引入这个starter，这个场景下我们常规所需要的依赖，都会自动引入。

几乎我们常用的开发场景，SpringBoot都有抽取。

当然，也有第三方starter，也就是如果SpringBoot给你提供的这些场景还不能满足你的开发，你自己可以自定义一些starter。

所有场景启动器最底层的依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>2.3.4.RELEASE</version>
            <scope>compile</scope>
        </dependency>

这是SpringBoot自动配置的核心依赖。

2.3 自动配置

• 自动配好Tomcat

  • 引入Tomcat依赖
  • 配置Tomcat

• 自动配好SpringMVC

  • 引入SpringMVC全套组件
  • 自动配好SpringMVC常用组件（功能）

• 自动配好Web常见功能，如：字符编码问题

  • SpringBoot帮我们配置好了所有web开发的常见场景

• 默认的包结构

  • 我们以前在整合的时候，我们得指定一些base-package=“com.cff.springwork”，包扫描，来指定一些规则。但是我们没有配任何的包扫描，但是我们写的一些例如controller组件，它就能发现。官方文档中说了，这是因为构造我们的代码有一个默认的包扫描规则，主程序所在的包及其下面的所有子包，里面的组件都会被默认扫描进来。这就解释了为什么连包扫描都不用配，我们的controller就都能进来。但是，如果在主程序所在的包的外面，就不行了。（新建一个controller文件夹，把控制类放到文件夹里，只是起到一个目录分类的作用，当然你把controller.java直接和主程序并列放置也是可以的，因为都是在同一目录下）

  • 如果确实想让同一目录外面的也能生效（主程序在com.wyl.boot目录下），我们可以在主程序类上面的注解里添加@SpringBootApplication(scanBasePackages="com.wyl")，这样的话，改变扫描路径，也相当于使包扫描的范围扩大了一点。

  • 除了这个方法，还可以添加一个包扫描的注解，@ComponentScan指定扫描路径，也是一样的效果（这三行等于原来的一行）：

    //@SpringBootApplication
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan("com.wyl")
    

• 各种配置拥有默认值

  • 默认配置最终都是映射到MutiPartProperties
  • 配置文件的值最终会绑定到某个类上，这个类会在容器中创建对象

• 按需加载所有自动配置项

  • 非常多的starter
  • 引入了哪些场景，这个场景的自动配置才会开启
  • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

三、容器功能

3.1 组件添加@Configuration和@Bean

我们原来在Spring开发的时候，例如在com.wyl.boot.bean目录下创建了两个组件：Pet和User：

public class Pet {
    private String name;
    public Pet() {
    }
    public Pet(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class User {
    private String name;
    private Integer age;

    public User() {
    }
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public Integer getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

如果想要把这两个组件添加到容器中，需要先在resources目录下创建一个Spring的配置文件beans.xml，然后使用标签进行创建：

<bean id="user01" class="com.wyl.boot.bean.User">
    <property name="name" value="zhangsan"></property>
    <property name="age" value="18"></property>
</bean>

<bean id="cat" class="com.wyl.boot.bean.Pet">
    <property name="name" value="Tom"></property>
</bean>

现在我们给容器中注册了一个User组件和一个Pet组件，这是我们以前Spring中用xml配置的方式。现在我们SpringBoot不用写这些xml文件，也有配置的办法。

@Configuration这个注解就是配置的意思。我们可以来编写一个类，这个类放在config文件夹下，比如就叫MyConfig，然后在这个类上表上这个注解

@Configuration
public class MyConfig {
}

我们创建一个类就相当于创建了一个文件，然后给这个类说明上@Configuration，就相当于这个类就是配置文件。@Configuration就是告诉SpringBoot这是一个配置类，相当于beans.xml配置文件。

在配置类里面，我们就不能写标签了，我们要写方法：

    public User user01(){
        return new User("zhangsan",18);
    }

直接获取一个User对象（根据有参构造器）

然后，我们不用标签了，我们用@Bean注解：

    @Bean
    public User user01(){
        return new User("zhangsan",18);
    }

@Bean注解，就是以方法名作为组件的id。返回类型就是组件类型。返回的对象/值就是在容器中的实例。

于是，我们可以看到，我们的容器中就注册了这两个组件。

@Configuration
public class MyConfig {

    @Bean
    public User user01(){
        return new User("zhangsan",18);
    }

    @Bean
    public Pet catPet(){
        return new Pet("Tom");
    }
}

组件的名字默认是方法名，如果你想给它取一个自定义的名字，你也可以在@Bean标签中给它定义一个名字：

    @Bean("cat")
    public Pet catPet(){
        return new Pet("Tom");
    }

我们给容器中注册的这两个组件，它默认是单实例的，就是无论从容器中获取多少次，都是一样的。

我们可以在主程序中获取组件看看：

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        //返回我们的IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //从容器中获取组件
        Pet cat01 = run.getBean("cat", Pet.class);
        Pet cat02 = run.getBean("cat", Pet.class);
        System.out.println("组件" + (cat01 == cat02));	//输出结果：组件true
    }
}

值得注意的是，我们这个@Configuration标注的这个类MyConfig，它本身也是一个组件，因为在我们这个容器中，你既然是一个配置类，配置类也是一个组件。我们可以在主程序里获取它验证一下：

        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

输入：com.wyl.boot.config.MyConfig$$EnhancerBySpringCGLIB$$246692b6@2aa27288，可以获取到。

@Configuration中有一个属性proxyBeanMethods很重要：

由于MyConfig这个配置类本身也是一个组件，这个组件里有两个方法user01()和catPet()，那么我们可以调用这两个方法。我们连续调用两次user01()方法，看看获取的这个对象，它是从容器中拿，还是就是个普通的调用方法

        MyConfig bean = run.getBean(MyConfig.class);
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);//输出结果：true

也就是说，我们配置类里面一旦组件配置了一个方法，无论外部方法对这个组件注册方法调用多少次，获取的都是容器中的那个单实例对象。原因是什么，原因就是我们@Configuration(proxyBeanMethods=true)，这个属性为true的意思就是，我们的方法会不会被代理，会。MyConfig本身它不是一个普通对象，它是被SpringCGLIB增强了的代理对象，所以我们MyConfig bean = run.getBean(MyConfig.class);本身获取到的就是一个代理对象，代理对象调这个方法bean.user01();，我们SpringBoot里面的默认逻辑就是，如果@Configuration(proxyBeanMethods=true)，那么我们这个类获取到的就是代理对象调用方法，SpringBoot就会检查容器中有没有这个方法已经返回的组件，如果有就拿，如果没有就new一个，也就是SpringBoot总会检查这个组件是否在容器中有，也就是它要保持组件单实例。如果把这个改为false，proxyBeanMethods=false，那么这个对象MyConfig拿到的就不再是代理对象，多次调用方法得到的就不是相等的值（user==user1就会为false了）。

这个也引申出了，SpringBoot在底层，Configuration的两种配置：

Full全配置，@Configuration(proxyBeanMethods=true)

Lite轻量级配置，@Configuration(proxyBeanMethods=false)

这个解决什么场景呢，组件依赖。举一个例子，来到bean->User里，假设我们这个User要养一个宠物Pet

public class User {
    private String name;
    private Integer age;

    private Pet pet;
    
    ...

相当于，我给这个容器中注册了一个组件User，但是呢，这个用户想要用我们容器中之前注册的宠物Pet。如果我们是proxyBeanMethods=false模式。我们这个zhangsan用户，它想要我们容器中的这个宠物，这个宠物由于这个方法已经在容器中放好了，我们可以把这个方法调用一下。但是，如果proxyBeanMethods=true的话，它就是对的，我们用户的这个宠物，跟容器中的宠物，就是一模一样的。这说明我们User组件依赖了Pet组件。如果我们是true模式，这种依赖就是成立的。但是如果我们是false模式，我们用户想用我们的宠物，我们把原先的方法调了一下，但是这个方法又不是经过代理的，它就是直接调用，就又new了一个宠物对象。

    @Bean
    public User user01(){
        User zhangsan = new User("zhangsan",18);
        zhangsan.setPet(catPet());	//调用
        return zhangsan;
    }

调成false的优点就是，SpringBoot启动比较快，因为它不用去检查容器中是否已经存有这个对象。如果我们只是往容器中注册组件，且别的组件不依赖这个组件，我们一般把它调成false，这样的话SpringBoot整个启动过程会很快。但是我们的组件，明显别人要用，我们就调成true，来保证它依赖的组件就是容器中那个一模一样的组件。

总结：

1、配置类里面使用@Bean标注在方法上，给容器注册组件，默认是单实例的。

2、配置类本身也是组件。

3、proxyBeanMethods：代理bean的方法。Full全配置，

​ @Configuration(proxyBeanMethods=true)；

​ Lite轻量级配置，@Configuration(proxyBeanMethods=false)；

​ 组件依赖。

3.2 @Component、@Controller、@Service、@Repository

在类上面加上

@Component，代表它是一个组件；

@Controller，代表它是一个控制器；

@Service，代表它是一个业务逻辑组件；

@Repository，代表它是一个数据库层组件。

而且，只要我们这些组件写在我们包扫描的范围内，就可以生效。于是我们的主程序类也可以叫做主配置类。

3.3 @Import

写在任何一个组件上面都行。你的这个类可以是配置类也可以是其他的Controller什么的都行。只要是容器中的组件上就行。

import的本意就是导入。我们可以使用@Import({ … })导入很多组件，它里面是一个数组。我们可以给它导入我们注册的组件比如User.class，我们也可以导入第三方jar包提供的一些组件

@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = true)
public class MyConfig {
    ...

通过@Import({User.class, DBHelper.class})，可以给容器中自动创建出这两个类型的组件。

通过注解的方式获取的组件的名字就是全类名，例如com.wyl.boot.bean.User，而不是刚刚我们使用@Bean注解得到的user01这样的名字。

3.4 @Conditional条件装配

翻译过来就是，按照什么条件。也就是条件装配，当满足它指定的条件的时候，我们才给容器中注入相关的组件，或者做相应的事。

它是一个根注解，下面派生了很多的派生注解，每个派生注解都代表了不同的功能。比如@ConditionalOnBean。

我们希望的效果是，我们用户组件，因为它依赖宠物组件，那么，如果容器中没有这个宠物组件，那你也别给我注册我的用户组件了。可以使用这个条件注解：@ConditionalOnBean，容器中有没有某个组件，使用name来指定。

public class MyConfig {


    @ConditionalOnBean(name = "cat")
    @Bean
    public User user01(){
        User zhangsan = new User("zhangsan",18);
        zhangsan.setPet(catPet());
        return zhangsan;
    }

//    @Bean("cat")	注释掉了组件注入，容器中没有这个组件
    public Pet catPet(){
        return new Pet("Tom");
    }
}

当我们容器中有cat这个组件的时候，我们再给容器中注入user01。

我们也可以把这个注解直接标在类上，也就是容器中有这个组件的时候，类中所有的东西才能生效。

@ConditionalOnBean(name = "cat")
public class MyConfig {
    @Bean
    public User user01(){
        User zhangsan = new User("zhangsan",18);
        zhangsan.setPet(catPet());
        return zhangsan;
    }

//    @Bean("cat")
    public Pet catPet(){
        return new Pet("Tom");
    }
}

3.5 @ImportResource

翻译过来就是“导入资源”。它的使用场景是。我们以前可能会在Spring中给容器写非常多的组件导入，

<bean id="haha" class="com.wyl.boot.bean.User">
    <property name="name" value="zhangsan"></property>
    <property name="age" value="18"></property>
</bean>

<bean id="hehe" class="com.wyl.boot.bean.Pet">
    <property name="name" value="Tom"></property>
</bean>

因为以前很多人是用Spring的xml注解的方式导入组件的。如果我们想把这些xml组件都迁移成@Bean注解的方式，感觉有点麻烦，或者我们引入的人家第三方包，比较老，包里就是使用的xml配置方式。那对于这些组件，我们容器中肯定是没有的，因为你通过写xml配置文件的方式，我们的SpringBoot也不知道你是想干什么的。

如果你已经有了xml配置文件，你不想一点一点迁移成@Bean注解的形式，你也可以这样，随便在某一个配置类上写一个@ImportSource(“classpath:beans.xml”)

相当于你给我把这个配置文件里面的内容重新解析，放到容器里面。

3.6 @ConfigurationProperties配置绑定

场景例子。我们习惯于把经常变化的一些东西写到配置文件里面。我们以前比如把数据库的一些属性，配到配置文件里面。为了方便，我们会把配置文件里面的内容，又一一解析，解析到某个对象里面。

例如我们要把数据库配置文件.properties中的配置文件，封装到JavaBean中，以供随时使用。

如果用Java原生的方法，还是比较麻烦的。我们要先获取Properties对象，然后通过FileInputStream读取.properties文件的文件流，然后再获取里面每一个键值对，然后一一对应，封装到JavaBean指定的属性里面。这还算比较简单的，如果比较复杂，可能还要涉及到正则表达式等一大堆的东西，才能把它完成。

但是在SpringBoot里面，这个过程就会变得非常简单，这个过程叫配置绑定。

比如我们的bean目录里面有个Car，包含品牌、价格（get、set方法，以及构造器、toString方法暂且省略不写在这里面了）：

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

我现在想把跟汽车有关的东西放到配置文件里面，就放到SpringBoot的application.properties配置文件里面。

mycar.brand=BYD
mycar.price=100000

现在我配了汽车的两个信息。以前我们读取这个信息并且封装很麻烦。现在怎么办？一个注解，就可以完成。

@ConfigurationProperties(prefix = "mycar")

prefix就是前缀，指的是，我们这个类里面的每一个属性，跟配置文件哪个前缀下的所有属性一一绑定。此处是"mycar"。写上以后，我们为了使它生效，我们把它加到容器中。因为只有是容器中的组件，才可以拥有SpringBoot给它提供的一些强大的功能。所以加一个@Component注解。

@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private Integer price;
}

我们可以测试一下，在某个controller类中写一个方法。

    public Car car(){
        return
    }

直接返回一个类型为Car的对象，那么我们这个Car从哪来。因为我们的Car已经通过@Component放到容器中了，而且它里面每个属性的值，是跟配置文件绑定了的。我在这想要用的话，我直接利用Spring的自动注入，把容器中的Car拿过来就行。@AutoWired。在方法中直接return car;来返回这个car。然后再加上一个@RequestMapping处理一个请求。

    @Autowired
    Car car;

    @RequestMapping("/car")
    public Car car(){
        return car;
    }

访问一下

如果配置文件改了，那么获取到的属性也会跟着改。

所以现在配置文件绑定一个JavaBean，就很简单了。

除了这种@Component+@ConfigurationProperties注解的方式，

还有另外一种方式，叫@EnableConfigurationProperties注解的方式，这种方式一定要在配置类里面写，因为，首先配置类它在容器中、是容器中的组件，然后，配置类上写@EnableConfigurationProperties，意思就是开启属性配置功能，开启谁的属性配置功能？因为我们的Car想要跟人绑定，所以我们把Car，传进来。

@EnableConfigurationProperties(Car.class)
public class MyConfig {
	...
}

这个注解，它其实就有两个功能。

1、开启Car的配置绑定功能。你只有开启了Car的属性配置功能，你Car上的@ConfigurationProperties(prefix = “mycar”)属性配置才能生效。

2、把这个Car这个组件自动注册到容器中。

这样写，就不用写@Component了。为什么要这样写，因为有些时候我们不是引用的自己写的Car，而是引用的第三方包里面的，那你不能给人家的类上面标@Component吧。就可以用这种方式。

四、自动配置原理

看一看SpringBoot是如何帮我们做了那么做的事情，好让我们我们只需要关心业务逻辑开发。

4.1 引导加载自动配置类

刚才说了，主程序类上@SpringBootApplication等于以下三个注解的结合。

1、@SpringBootConfiguration

点进去看一下，它上面也标有@Configuration。代表当前是一个配置类。也就是主程序实际上也就是一个主配置类。

2、@ComponentScan

指定扫描哪些Spring注解。

3、@EnableAutoConfiguration

点进去看，它是@AutoConfigurationPackage和@Import(AutoConfigurationImportSelector.class)这两个注解的合成。

@AutoConfigurationPackage：

翻译一下就叫，自动配置包。点进去看一下，它头上也有一个@Import(AutoConfigurationPackage.Registrar.class)，就是给容器导入一个组件。Registrar可以给容器中导入一系列组件。将指定的一个包下的所有组件导入进来，MainApplication所在的包。com.wyl.boot。也可以看出来，每一个功能都在源码中有所体现。

@Import(AutoConfigurationImportSelector.class)：

1）利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件；

2）调用List configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类；

3）利用工厂加载 Map<String, List> loadSpringFactories(@Nullable Classloader classLoader); 得到所有的组件。

4）从META-INF/spring.factories位置来加载一个文件。

​ 默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件。

​ spring-boot-autoconfiguration-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories。文件里面写死了spring-boot一启动就要给容器中加载的所有配置类（有127个）。

4.2 按需开启自动配置项

虽然我们127个场景的所有自动配置启动的时候会默认全部加载。

但是按照条件装配规则（@Conditional），最终会按需配置。

• SpringBoot先加载所有的自动配置类，xxxxAutoConfiguration
• 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值，xxxxProperties里面拿。xxxxProperties又和配置文件进行了绑定。
• 生效的配置类就会给容器中装配很多组件
• 只要容器中有这些组件，相当于这些功能就有了
• 只要用户有自己配置的，就以用户的优先
• 定制化配置
  • 用户直接自己@Bean替换底层的组件
  • 用户去看这个组件是获取的配置文件什么值，在application.properties里去修改赋值就行了。