2、SpringBoot配置

配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好

创建一个新的springboot项目，并创建Dog Person类

Person.java

package com.atguigu.springboot.bean;


import org.hibernate.validator.constraints.Email;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.Null;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 将配置文件中配置的每一个属性的值，映射到这个组件中
 * @ConfigurationProperties:告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
 * prefix="person" ：配置文件中的哪个下面的所有属性进行一一映射
 * */

@Component

@ConfigurationProperties(prefix = "person")

public class Person {

   private String lastName;
   private Integer age;
   private Boolean Boss;
   private Date birth;

   private Map<String,Object> maps;
   private List<Object> lists;
   private Dog dog;

    @Override
    public String toString() {
        return "Person{" +
                "lastName='" + lastName + '\'' +
                ", age=" + age +
                ", Boss=" + Boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", dog=" + dog +
                '}';
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean getBoss() {
        return Boss;
    }

    public void setBoss(Boolean boss) {
        Boss = boss;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Map<String, Object> getMaps() {
        return maps;
    }

    public void setMaps(Map<String, Object> maps) {
        this.maps = maps;
    }

    public List<Object> getLists() {
        return lists;
    }

    public void setLists(List<Object> lists) {
        this.lists = lists;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }
}

Dog.java

package com.atguigu.springboot.bean;

public class Dog {

    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

配置application.yml

在pom文件导入依赖

<!--导入配置文件处理器，配置文件进行绑定就会有提示-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

启动主程序：

现在我们对application.properties进行配置，先把application.yml的内容注释掉

修改编码方式，因为有中文信息：

重新修改配置文件，改过配置后，配置文件的中文会变成乱码

编写测试类：

package com.atguigu.springboot;

import com.atguigu.springboot.bean.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.junit4.SpringRunner;


/**
 * SpringBoot单元测试;
 *
 * 可以在测试期间很方便的类似编码一样进行自动注入等容器的功能
 *
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBoot02ConfigApplicationTests {

    @Autowired
    Person person;

    @Autowired
    ApplicationContext ioc;

    @Test
    public void testHelloService(){
        boolean b = ioc.containsBean("helloService02");
        System.out.println(b);
    }


    @Test
    public void contextLoads() {
        System.out.println(person);
    }

}

运行测试类

通过@value获取值，启动测试类，观察终端打印的信息

	@ConfigurationProperties	@value
功能	批量注入配置文件中的属性	一个个指定
松散绑定	支持	不支持
SpEL	不支持	支持
JSR303数据校验	支持	不支持
复杂类型封装	支持	不支持

配置文件yml还是properties他们都能获取到值

如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@value

如果说，我们专门编写一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties

我们新建一个controller类：

package com.atguigu.springboot.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @Value("${person.last-name}")
    private String name;

    @RequestMapping("/sayHello")
    public String sayHello(){
        return "Hello"+name;
    }
}

启动主程序

访问地址 http://localhost:8081/sayHello

@PropertySource：加载指定的配置文件

我们创建一个person.properties配置文件

注释掉application.properties的person配置

指定配置文件：

运行测试类：

@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效：

创建beans.xml配置文件

修改测试主程序：

package com.atguigu.springboot;

import com.atguigu.springboot.bean.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.junit4.SpringRunner;


/**
 * SpringBoot单元测试;
 *
 * 可以在测试期间很方便的类似编码一样进行自动注入等容器的功能
 *
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBoot02ConfigApplicationTests {

    @Autowired
    Person person;

    @Autowired
    ApplicationContext ioc;

    @Test
    public void testHelloService(){
        boolean b = ioc.containsBean("helloService");
        System.out.println(b);
    }


}

运行测试类：

Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；

想让Spring的配置文件生效，加载进来；@ImportResource标注在一个配置类上

运行测试类：

SpringBoot推荐给容器中添加组件的方式；推荐使用全注解的方式

1、配置类=====Spring配置文件

2、使用@Bean给容器中添加组件

注释掉

创建MyAppConfig类

package com.atguigu.springboot.config;

import com.atguigu.springboot.service.HelloService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @Configuration：指明当前类是一个配置类；就是来替代之前Spring配置文件
 * */
@Configuration
public class MyAppConfig {
  //将方法的返回值添加到容器中，容器中这个组件默认的id就是方法名
    @Bean
    public HelloService helloService(){
        System.out.println("配置类@Bean给容器中添加组件了。。。");
        return new HelloService();
    }
}

运行测试主程序：

将其注释掉，我们读取主配置文件

修改主配置文件application.properties

#配置person信息
person.last-name=张三${random.uuid}
person.age=${random.int}
person.birth=2020/8/8
person.boss=false
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c
person.dog.name=${person.last-name}_dog
person.dog.age=4

编写测试类主程序

package com.atguigu.springboot;

import com.atguigu.springboot.bean.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.junit4.SpringRunner;


/**
 * SpringBoot单元测试;
 *
 * 可以在测试期间很方便的类似编码一样进行自动注入等容器的功能
 *
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBoot02ConfigApplicationTests {

    @Autowired
    Person person;

    @Autowired
    ApplicationContext ioc;

    @Test
    public void testHelloService(){
        boolean b = ioc.containsBean("helloService");
        System.out.println(b);
    }

    @Test
    public void contextLoads(){
        System.out.println(person);
    }


}

运行测试类主程序

我们在主配置文件编写的时候，文件名可以是application-{profile}.properties/yml

默认使用application.properties

我们新建两个配置文件，分别表示开发环境的配置文件和生产环境的配置文件

我们启动主程序

从打印的日志中我们可以看出，默认使用的是application.properties配置文件

通过在默认的配置文件中激活开发环境的配置文件，这个时候我们就会用到application-dev.properties配置文件

启动主程序

这个时候就用到了application-dev.properties配置文件

Yml支持多文档块方式，以application.yml作为主怕配置文件

先把properties文件的内容注释掉

编写application.yml文件，此时是激活dev模块

启动主程序，可以看到dev模块被激活了

我们重新创建一个工程

调整一下端口号，启动主程序

在类路径下创建config包，并创建application.properties配置文件，可以看到读取的是config包里面的配置文件，因为config包的优先级更高

同理，在文件的跟目录下的配置文件以及跟目录下的config包里面的配置文件优先级更高，我们可以总结以下：

springboot会从这四个位置全部加载主配置；互补配置

我们在低优先级的配置文件里面增加以下内容

创建HelloController类

package com.gong.springboot02config02.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }
}

启动主程序，可以看到访问了高优先级的8082端口

在浏览器访问 http://localhost:8082/boot02/hello

我们还可以通过spring.config.location来改变默认的配置文件位置

我们把配置文件复制到本地的某个路径下

修改端口号

在工程项目里面的配置文件加上这个配置，相当与指定配置文件的路径

启动主程序，可以看到并没有指定我们要求的配置文件路径

我的得出这样的结论，项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置，

指定配置文件和默认加载的这些配置文件共同起作用形成互补配置

我们来打包这个项目

在pom文件添加依赖

<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>

打包

我们可以看到生成的jar包

直接通过idea自带的终端访问，通过命令行访问指定路径的配置文件

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=D:/MyCode/test/application.properties

从打印的日志可以看出来

打开浏览器访问地址 http://localhost:8085/boot02/hello

SpringBoot也可以从以上位置加载配置，优先级从高到低，高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置

我们新建一个工程项目

自动配置原理

1、SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration

2、@EnableAutoConfiguration的作用就是

利用EnableAutoConfigurationImportSelector给容器中导入一些组件？

可以查看selectImports()方法的内容；
List configurations = getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置

SpringFactoriesLoader.loadFactoryNames()
扫描所有jar包类路径下 META‐INF/spring.factories
把扫描到的这些文件的内容包装成properties对象
从properties中获取到EnableAutoConfiguration.class类（类名）对应的值，然后把他们添加在容器中

将类路径下 META-INF/spring.factories 里面配置的所有EnableAutoConfiguration的值加入到了容器中；

3、每一个自动配置类进行自动配置功能；

4、以HttpEncodingAutoConfiguration为例解释自动配置原理