SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用
application.properties或者application.yml（application.yaml）进行配置。

  SpringBoot配置文件的类型：SpringBoot默认加载resources目录下的application.properties或application.yml(application.yaml)文件。

  根据spring-boot-starter-parent中读取文件顺序，所以配置文件的优先级：.properties > .yaml > .yml

<excludes>
  <exclude>**/application*.yml</exclude>
  <exclude>**/application*.yaml</exclude>
  <exclude>**/application*.properties</exclude>
</excludes>

一、yaml 配置文件

1. 配置普通数据

name: lisi

ps: value之前有一个空格，键-值之间都有一个空格

字符串默认不用加引号：

“ ”：双引号：不会转义字符串里面的特殊字符，特殊字符会作为本身想表达的意思：

​ name: “zhangsan \n lisi” ==> 输出：zhangsan 换行 lisi

’ '：单引号：会转义特殊字符，特殊字符最终只是一个普通的字符串数据：

​ name: ‘zhangsan \n lisi’ ==> 输出：zhangsan \n lisi

2. 配置对象数据、map数据

person:
  name: zhangsan
  age: 18
  addr: 上海
  
#或者(注意缩进)

person: {name: zhangsan,age: 18,addr: 上海}

ps: 以空格的多少表示层级关系，相同缩进代表同一级级别

3. 配置数组(List、Set)数据

city:
- beijing
- tianjin
- shanghai
- chongqing

#或者

city: [beijing,tianjin,shanghai,chongqing]

#集合中的元素是对象形式
student:
  - name: zhangsan
    age: 18
    score: 100
  - name: lisi
    age: 28
    score: 88
  - name: wangwu
    age: 38
    score: 90

ps: value与 - 之间存在空格

SpringBoot常见的配置

# QUARTZ SCHEDULER (QuartzProperties)
spring.quartz.jdbc.initialize-schema=embedded # Database schema initialization mode.
spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.
sql # Path to the SQL file to use to initialize the database schema.

spring.quartz.job-store-type=memory # Quartz job store type.
spring.quartz.properties.*= # Additional Quartz Scheduler properties.

# ----------------------------------------
# WEB PROPERTIES
# ----------------------------------------

# EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080 # Server HTTP port.
server.servlet.context-path= # Context path of the application.
server.servlet.path=/ # Path of the main dispatcher servlet.

# HTTP encoding (HttpEncodingProperties)
spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and responses. Added to
the "Content-Type" header if not set explicitly.

# JACKSON (JacksonProperties)
spring.jackson.date-format= # Date format string or a fully-qualified date format
class name. For instance, `yyyy-MM-dd HH:mm:ss`.

# SPRING MVC (WebMvcProperties)
spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the dispatcher
servlet.
spring.mvc.static-path-pattern=/** # Path pattern used for static resources.
spring.mvc.view.prefix= # Spring MVC view prefix.
spring.mvc.view.suffix= # Spring MVC view suffix.

# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.driverClassName=###
spring.datasource.url= # JDBC URL of the database.
spring.datasource.password= # Login password of the database.
spring.datasource.username= # Login username of the database.

# JEST (Elasticsearch HTTP client) (JestProperties)
spring.elasticsearch.jest.password= # Login password.
spring.elasticsearch.jest.proxy.host= # Proxy host the HTTP client should use.
spring.elasticsearch.jest.proxy.port= # Proxy port the HTTP client should use.
spring.elasticsearch.jest.read-timeout=3s # Read timeout.
spring.elasticsearch.jest.username= # Login username.

二、配置文件

1. 使用注解@Value映射

我们可以通过@Value注解将配置文件中的值映射到一个Spring管理的Bean的字段上

application.yml
person:
  name: zhangsan
  age: 18
  addr: 上海
===================
@RestController
public class QuickController {
    @Value("${person.name}")
    private String name;
    @Value("${person.age}")
    private int age;
    @Value("${person.addr}")
    private String addr;

    @RequestMapping("/ymlTest")
    public String ymlTest(){
        return "SpringBoot访问成功。姓名:" + name + ",年龄:" + age + ",地址:" + addr;
    }

2. 使用注解@ConfigurationProperties映射

  通过注解@ConfigurationProperties(prefix=“配置文件中的key的前缀”)可以将配置文件中的配置自动与实体进行映射

ps: 这种方式可以进行配置文件与实体字段的自动映射，但需要字段必须提供set方法才可以；

​ 并且，该类必须在容器中（使用@Component、@Controller类似的注解修饰）

// Person类
@Getter
@Setter
@ToString
@Component
@ConfigurationProperties(prefix = "person")
public class Person {

    public String name;
    public Integer age;
    public Boolean boss;
    public Date birth;
    public String nickName;

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

}

## application.yml
person:
  name: 小贱
  age: 22
  boss: false
  birth: 1999/09/30

  maps: {k1: 博客,k2: 分享网站}
  lists: [123,625,342,803]
  dog:
   name: 小黑
   age: 4
  nick-name: Raining

配置文件configuration-processor的作用

<!-- @ConfiguartionProperties的执行器的配置 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

​ 在实体类中，使用@ConfigurationProperties注解，先声明prefix，在书写yml配置文件时，输入对应prefix就会有实体类中属性的提示。

测试

@RunWith(SpringRunner.class)
@SpringBootTest
class SpringBootReturn02ApplicationTests {

    @Autowired
    Person person;

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

application.properties文件出现乱码现象

​ 原因：idea使用的是utf-8编码，peoperties使用ASCII

​ 解决：File --> Setting

3. @Value和@ConfigurationProperties 比较

JSR303数据校验(@ConfigurationProperties为例)

• 导入依赖

  <dependency>
  	<groupId>org.hibernate.validator</groupId>
  	<artifactId>hibernate-validator</artifactId>
  	<version>6.1.5.Final</version>
  </dependency>
  

• 校验类加注解

  @Getter @Setter @ToString
  @Component
  @ConfigurationProperties(prefix = "person")
  @Validated
  public class Person {
  
      @Email
      public String name;
      public Integer age;
      public Boolean boss;
      public Date birth;
      public String nickName;
  
      public Map<String,Object> maps;
      public List<Object> lists;
      public Dog dog;
  
  }
  

• 测试
  

4. @PropertySource 与 @ImportResource

@PropertySource（默认不支持yml配置文件！所以老实用properties吧）

# person.properties

person.name=死侍
person.age=24
person.boss=false
person.birth=1998/3/23
person.maps.k1=点数
person.maps.k2=大小
person.lists=a,s,d
person.dog.name=小白
person.dog.age=3
person.nick-name=小贱贱

@Getter @Setter @ToString
@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
public class Person {

    public String name;
    public Integer age;
    public Boolean boss;
    public Date birth;
    public String nickName;

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

}

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

Spring Boot 中没有Spring的配置文件，我们自己编写的配置文件，也不能被识别生效；

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

@ImportResource(locations = {"classpath:beans.xml"})
@SpringBootApplication
public class SpringBootReturn02Application {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootReturn02Application.class, args);
    }

}

Spring Boot 推荐给容器中添加组件的方式：推荐使用全注解的配置类

配置类 代替 spring配置文件

@Configuration
public class MyAppConfig {

    @Bean
    public HelloService helloService(){	// 这里的方法名就是获取该bean的名称，区分大小写
        System.out.println("配置类注入helloService");
        return new HelloService();
    }
}

// 测试类
@RunWith(SpringRunner.class)
@SpringBootTest
class SpringBootReturn02ApplicationTests {

    @Resource
    ApplicationContext ioc;

    @Test
    public void testHelloService(){
        boolean b = ioc.containsBean("helloService");	// 区分大小写
        System.out.println(b);
    }

}

5. 配置文件占位符

​ 可以在配置文件中作为未定义数值

• 随机数

  ${random.value}、${random.int}、${random.long}
  ${random.int(10)}、${random.int[1024,65535]}
  

• 占位符获取配置的值，如果没有可以指定默认值

  person.name=张三${random.uuid}
  person.age=${random.int}
  person.boss=false
  person.birth=1998/3/23
  person.maps.k1=点数
  person.maps.k2=大小
  person.lists=a,s,d
  person.dog.name=${person.nick-name}_小白
  person.dog.age=3
  person.nick-name=${person.hello:你好}		// 指定默认值
  

6. Profile

(1). 多Profile文件

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

​ 默认使用 application.properties 的配置

(2). yml支持多文档快方式

# application.yml

server:
  port: 8082
spring:
    profiles:
      active: dev

---
server:
  port: 8083

spring:
  profiles: dev
  
---
server:
  port: 8084
spring:
  profiles: prod

(3). 激活指定profile

• 在主配置文件中指定：spring.profiles.active=dev

• 命令行：–spring.profiles.active=dev

  • 在项目启动选项框里 Edit Configurations --> Program arguments栏 填入 --spring.profiles.active=dev

  • 运行jar包时激活

    java -jar spring-boot-return02-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

• 虚拟机参数

  ​ -Dspring.profiles.active=dev

  ​ 在项目启动选项框里 Edit Configurations --> VM option栏 填入 -Dspring.profiles.active=dev

7. 配置文件加载位置

​ Spring Boot 启动会扫描以下位置的 application.properties 或 application.yml文件作为 Spring Boot 的默认配置文件。

• file:./config
• file:./
• classpath:/config
• classpath:/

– file代表该项目所在位置，classpath代表resources文件夹

– 以上是按照优先级从高到低的顺序，高优先级配置内容会覆盖低优先级配置内容；Spring Boot 会从这四个位置加载全部的主配置文件：互补配置

– 我们也可以通过配置 –spring.config.location 来改变默认配置；项目打包后，使用命令行参数的形式，启动项目的时候指定配置文件的新位置；指定配置文件和默认加载的配置文件共同起作用，互补配置

java -jar spring-boot-return03-config-0.0.1-SNAPSHOT.jar --spring.config.location=F:/application.properties

8、外部配置加载顺序

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

1.命令行参数

所有的配置都可以在命令行上进行指定

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc

多个配置用空格分开； --配置项=值

2.来自java:comp/env的JNDI属性

3.Java系统属性（System.getProperties()）

4.操作系统环境变量

5.RandomValuePropertySource配置的random.*属性值

由jar包外向jar包内进行寻找；

优先加载带profile

6.jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件

7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件

再来加载不带profile

8.jar包外部的application.properties或application.yml(不带spring.profile)配置文件

9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件

10.@Configuration注解类上的@PropertySource

11.通过SpringApplication.setDefaultProperties指定的默认属性

所有支持的配置加载来源；

参考官方文档

三、日志

1. 日志框架

市面上的日志框架；

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…

左边选一个门面（抽象层）、右边来选一个实现；

日志门面： SLF4J；

日志实现：Logback；

SpringBoot：底层是Spring框架，Spring框架默认是用JCL；

​ SpringBoot选用 SLF4j和logback；

2. SLF4J的使用

1、如何在系统中使用SLF4j https://www.slf4j.org

以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里的方法；

给系统里面导入 slf4j 的jar包和 logback 的实现jar包；

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

图示：

每个日志的实现框架都有自己的配置文件，使用 slf4j 以后，配置文件还是做成日志实现框架自己本身的配置文件；

2. 遗留问题

当一个项目集成了多个框架，而每个框架都依赖于特定的日志框架，如何统一使用我们自己选择的日志框架呢？

​ application（slf4j+logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx

统一日志记录，即使是别的框架和我一起统一使用slf4j进行输出？

如何让项目中的所有日志都统一到slf4j：

1. 将项目中其他日志框架先排除出去；

2. 用中间包来替换原有的日志框架；
3. 我们导入 slf4j 其他的实现

3. Spring Boot 日志关系

SpringBoot使用它来做日志功能：

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

底层关系：

总结：

1. Spring Boot 底层也是使用 slf4j + logback 的方式进行日志记录；

2. Spring Boot 也把其他的日志都替换成了 slf4j;使用中间替换包，如：log4j-to-slf4j、jul-to-slf4j;

3. 如果要引入其他框架，一定要把这个框架的默认日志依赖移除

   ​ Spring框架用的是 commons-logging;

   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-core</artifactId>
       <exclusions>
           <exclusion>
               <groupId>commons-logging</groupId>
               <artifactId>commons-logging</artifactId>
           </exclusion>
       </exclusions>
   </dependency>
   

SpringBoot能自动适配所有的日志，而且底层使用 slf4j+logback 的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；

4. 日志的使用

1. 默认配置

​ Spring Boot 默认给我们配置好了日志：

// 测试类

@SpringBootTest
class   SpringBootReturn05LoggingApplicationTests {

    // 记录器
    Logger logger = LoggerFactory.getLogger(getClass());

    @Test
    void contextLoads() {
        // 日志的级别
        // 由低到高 ，trace < debug < info < warn < error
        // 可以调整输出的日志级别，日志就只会在这个级别及以后的高级别生效
        logger.trace("这是Trace");
        logger.debug("这是debug日志");
        // Spring Boot 默认给我们使用的是info级别的，可自行设置，没有设置使用默认级别
        logger.info("这是info日志");
        logger.warn("这是warn日志");
        logger.error("这是error日志");
    }
}

# application.properties

# 配置日志输出级别，没有该配置，使用默认级别info
logging.level.com.xiaojian=trace

# 输出日志 springboot.log 文件
# 可以指定完整路径；不指定路径会在当前项目下生成日志文件
#logging.file.name=F:/springboot.log

# 两者冲突，只能写其中一个，两个都写时，使用 file

# 在当前磁盘下的根路径下创建 spring 文件夹，和 log 子文件夹，并使用 spring.log 为默认文件
#logging.file.path=/spring/log


# 在控制台输出的日志格式
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n
# 指定文件中日志输出的格式
loggin.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} === %msg%n

2、指定配置

给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不使用他默认配置的了

logback.xml：直接就被日志框架识别了；

logback-spring.xml：日志框架就不直接加载日志的配置项，由Spring Boot解析日志配置，可以使用SpringBoot的高级Profile功能

<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
  	可以指定某段配置只在某个环境下生效
</springProfile>

使用Spring Boot 的高级 Profile功能，如果是logback.xml文件就会报错，因为使用了 springProfile

​ 在 application.properties 或 application.yml 文件中配置开发环境。

<!--logback-spring.xml，如果是logback.xml文件就会报错，因为使用了 springProfile-->

<!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志输出格式：
			%d表示日期时间，
			%thread表示线程名，
			%-5level：级别从左显示5个字符宽度
			%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
			%msg：日志消息，
			%n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <springProfile name="dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ->>>>>>>>>>>>>>> [%thread] %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
            <springProfile name="!dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} -=============== [%thread] %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
        </layout>
    </appender>

5. 切换日志框架

可以按照slf4j的日志适配图，进行相关的切换；

slf4j+log4j的方式；

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <exclusion>
      <artifactId>logback-classic</artifactId>
      <groupId>ch.qos.logback</groupId>
    </exclusion>
    <exclusion>
      <artifactId>log4j-over-slf4j</artifactId>
      <groupId>org.slf4j</groupId>
    </exclusion>
  </exclusions>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
</dependency>

切换log4j2

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

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