这篇文章，小编带着大家了解下spring的配置文件及其日志

首先来了解下配置文件。

配置文件：

这个文件是用来存储和管理配置信息的，比如数据库连接、服务端口、日志等级等

它一般是分为.properties和.yml文件

.properties文件：

这个文件是传统的配置文件格式，使用键值对来设置配置项

• 优点就是： 格式简单、易于编辑

• 每一行是一个key=value或key：value形式

• 注释使用#

.yml文件：

这个是Sprinboot推荐的配置格式，语法更清晰，支持层级结构

优点：

• 更易读，特别适合结构化配置

• 用缩进来表示层级（注意是空格，不是tab键）

• 注释也是用#

接下来学习下properties语法吧

默认是使用的是application.properties

properties语法：

配置服务器相关属性：

举例

#配置spring boot应用名称
spring.application.name=Spring-boot_Test
#配置嵌入式Web服务器的IP地址
server.address=127.0.0.2
#配置嵌入式Web服务器的端口号
server.port=9091

自定义属性值：

#整数类型
my.key=1
#布尔类型
my.key2=true
#字符串类型
my.key3=test

取值:

引入@Value注解，该注解会找到对应的属性值绑定到当前的变量值中

import org.springframework.beans.factory.annotation.Value;
@Component
public class PropertiesComponent {
 //取配置文件值
  @Value("${my.key}")
  private Integer ret1;
  @Value("${my.key2}")
  private boolean ret2;
  @Value("${my.key3}")
  private String ret3;
  //这些属性被注入完后，就会执行这个方法
  @PostConstruct
    public void Init(){
        System.out.println("参数1："+ret1);
        System.out.println("参数2："+ret2);
        System.out.println("参数3："+ret3);
     }
}

@PostConstruct注解：

是Java中用于定义一个方法的注解，该方法应该在依赖注入完成后和类实例投入使用之前被容器自动调用

注解要求：

• 被该注解标记的方法可以是public、protected、package-private或private

• 该方法不能有参数

• 该方法不能抛出编译时异常

• 方法只能被标注一次该注解，不能多次

配置对象：

sutdent.name=zhangsan
student.id=1
student.grade=Class1

取值：

此时再次介绍另一个注解

@ConfigurationProperties

这是spring boot提供的一个注解，用于将配置属性绑定到一个对象上。它使得从配置文件（.properties/.yml文件）中加载的属性可以自动映射到Java类的字段中，从而简化了配置管理

参数：prefix（参数值一定得是小写）

被赋予的值，意味着配置对象的前缀是什么，这里以student举例，所以前缀就是student

注解主要特性：

• 类型安全：与直接使用 @Value 注解相比，@ConfigurationProperties 提供了更结构化和类型安全的方式来处理配置属性。

• 宽松绑定：Spring Boot 支持多种方式来匹配配置键和Java类中的属性名，包括破折号(-)转驼峰命名、大小写不敏感等。

• 验证支持：可以通过在字段上添加JSR-303 (javax.validation) 注解（如 @NotNull, @Min, 等）来进行属性值的校验。

如何取值呢？

首先定义一个StudentConfig的类，（名字可以随便起）

@Data
@Component
@ConfigurationProperties(prefix = "student") // 绑定前缀为 "student" 的配置
public class StudentConfig {
    private String name;
    private int id;
    private String grade;
}

使用该对象:

创建一个MyController类：

@Controller
public class MyController {
    private final StudentConfig studentConfig;

    @Autowired
    public MyController(StudentConfig studentConfig) {
        this.studentConfig = studentConfig;
    }
      @PostConstruct
    public void getStudent() {
         System.out.println("参数1："+studentConfig.getName());
           System.out.println("参数1："+studentConfig.getId());
             System.out.println("参数1："+studentConfig.getGrade());
      }
}

配置数组：

student.names[0]=张三
student.names[1]=李四
student.names[2]=王五

取值：

@Component
@ConfigurationProperties(prefix="student")
public class PropertiesComponent {
    //绑定属性值
    public String [] names;
    //通过setter方法注入
    public void setNames(String [] names){
        this.names=names;
    }
     @PostConstruct
    public void Init(){
     for(String name:names){
                System.out.println(name);
            }
      }      
}

配置Map：

student.score[math]=90
student.score[chinese]=80
student.score[english]=100

取值：

 @Component
@ConfigurationProperties(prefix="student")
public class PropertiesComponent {
 //绑定Map
    private Map<String,Integer> score;
    public void setScore(Map<String,Integer> score){
        this.score=score;
    }
    @PostConstruct
   public void Init(){
     for(Map.Entry<String,Integer> temp:score.entrySet()){
               System.out.println("key:"+temp.getKey()+" "+"value:"+temp.getValue());
          }
   }
}

那么对于这个properties的语法就先介绍到这里

接下来介绍下yml文件的语法：

yml文件语法

以application.yml文件讲解

配置服务器相关属性：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/testdb?characterEncoding=utf8&useSSL=false
    username: root
    password: root

值得注意的是，嵌套的层级结构，要分开

正比如datasource是spring下一个子空间 ，所以两者之间要进行分开，两个层级之间保持两个空格隔开，同级别之间不用，比如url和username、password

这里呢，不进行值读取，和properties文件那里，差不多的，引入@Value注解，写上参数即可

自定义属性配值：

#自定义配置
yml:
#注意key 和 value之间要有空格
  value: java
  key: 112

这里呢，也不进行值读取，和properties文件那里，差不多的，引入@Value注解，写上参数即可

设置对象、数组、Map

student:
    id: 1
    name: 张三
    age: 18
    hobbies:
    #-和值之间要有空格
       - sing
      - jump
    map:
    #key value之间也要有空格
      k1: 1
      k2: 2
      k3: 3

取值：

创建一个对应的类，存储

@Data
@Component
@ConfigurationProperties(prefix = "student") // 绑定前缀 "student"
public class StudentConfig {
    private int id;
    private String name;
    private int age;
    //数组用这个接收
    private List<String> hobbies;  // List 类型
    //Map用这个接收
    private Map<String, Integer> map;  // Map 类型
}

创建一个读取属性的类

@Controller
public class MainController {
    //属性注入
    @Autowired
    private StudentController studentController;

    @PostConstruct  // 启动后自动执行
    public void showStudentInfo() {
        System.out.println(studentController.getId());
        System.out.println(studentController.getName());
        System.out.println(studentController.getAge());
        System.out.println(studentController.getMap());
        System.out.println(studentController.getHobbies());
    }
}

在yml文件中，要值得一讲的是，单双引号的区别

string:
  str1: Hello \n Spring Boot.
  str2: 'Hello \n Spring Boot.'
  str3: "Hello \n Spring Boot."

属性读取后，str1、str2中的\n是不会生效的，即单引号是不会转义为换行

str3中呢，\n是生效的，即双引号是不会改变原来换行的意思

那么对于yml的文件语法，就分享到这里。

以上都是以application为开头的properties和yml文件进行讲解，但是我们要是自定义配置文件呢，即文件名不是application开头的，此时呢，springboot是不能直接加载这些自定义配置文件的，但是还是有方法的。

加载自定义的配置文件：

对于properties文件

方法一：启动时指定：

//命令行
java -jar demo.jar \
  --spring.config.location=classpath:test.properties,classpath:application.properties

同理可以在idea的运行参数中写入相关信息

test.properties是自定义的配置文件。

运行时先加载application的，然后再去加载test的，最后合并。

方法二：application.properties导入

spring.config.import=classpath:test.properties

方法三：使用注解加载

@Configuration
@PropertySource("classpath:test.properties")
@ConfigurationProperties(prefix="student")
public class StudentProps { 

}

对于yml文件：

方法一：同理启动时指定：

//命令行
java -jar demo.jar \
  --spring.config.location=classpath:test.properties,classpath:application.properties

方法二：application.yml导入

spring:
  config:
    import: classpath:test.yml

方法三：注解+工厂类加载

// 自定义 PropertySourceFactory，用于从 YAML 文件创建 PropertySource
public class YamlPropertySourceFactory implements PropertySourceFactory {

    // 重写 createPropertySource 方法，Spring 在加载配置时会调用它
    @Override
    public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
        // 创建一个 Spring 提供的 YamlPropertiesFactoryBean，用于将 YAML 转为 Properties
        YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
        // 设置要读取的资源（即你的 test.yml 或其他 YAML 文件）
        factory.setResources(resource.getResource());
        // 从 factory 中获取转换后的 java.util.Properties 对象
        Properties properties = factory.getObject();
        // resource.getResource().getFilename()：获取文件名（例如 "test.yml"），
        // 作为 PropertySource 的名字；properties：就是刚才转换得到的键值对
        return new PropertiesPropertySource(
                resource.getResource().getFilename(),  // PropertySource 名称
                properties                              // 包含所有属性的 Properties 对象
        );
    }
}

配置类上使用：

@Component
@PropertySource(value="classpath:test.yml", factory=YamlPropertySourceFactory.class)
@ConfigurationProperties(prefix="student")
public class StudentProperties {
    private int id;
    private String name;
    private List<String> hobbies;
    private Map<String, Integer> map;
    // getters/setters…
}

当然，有人会好奇，那么这个pom.xml配置文件呢？和application.yml/properties一样的吗？

当然是不一样的！

区别：

pom常见标签：

表格 还在加载中，请等待加载完成后再尝试复制

ok，到这里，对于配置文件这方面就分享到这。

接下来到日志！

日志：

说到日志，其实大家都并不陌生，因为最早接触日志的话，用我们平时System.out.println就可以进行打印了。

但是呢，经常这样写，不太“高级”，所以我们就需要用来日志框架，来规范我们的日志输出。

介绍日志框架前，先来介绍下日志门面。

日志门面（Logging Facade）：

• 定义：一种抽象层，统一暴露给业务代码的日志API

• 作用：解耦应用代码与具体日志实现，便于在不改动业务代码的情况下，切换底层日志框架

• 常见门面：

  • SLF4J（Simple Logging Facade for Java）

  • Apache Commons Logging

当然这里涉及到了一个叫门面模式的东西。

门面模式：

又称为外观模式，提供了一个统一的接口，用来访问子系统中的 一群接口。

其主要特征是定义了一个高层接口，让子系统更容易使用。

图形化表示：

门面模式主要是包含两种角色：

外观角色（Facade）：也称门面角色，系统对外的统一接口

子系统角色（SubSystem）：可以同时有一个或者多个SubSystem，每个SubSystem都不是单独一个类

而是一个类的集合。SubSystem并不知道Facde的存在，对于SubSystem而言，Facade只是另一个客户端而已

日志框架（Loggin FrameWork）

• 定义：负责日志事件的格式化、路由（输出到控制台、文件、远程系统等）、滚动策略、异步处理等具体功能实现

• 作用：接收门面传来的日志调用，进行实际的写入，过滤和管理

常见框架：

• Logback（Spring Boot默认）

• Log4j2

• java.util.logging（JUL）

图示：

那么接下来是如何使用呢？

使用

引入lombok依赖：

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

方法一：通过创建Logger实例

@RestController
@RequestMapping("/log")
public class LogLevel {
    private static Logger logger= LoggerFactory.getLogger(LogLevel.class)；
    @RequestMapping("/getLog")
    public String getLog(){
        logger.info("info……")；
        return "获取日志";
    }
}

方法二：通过注解

@Slf4j
@RequestMapping("/logger2")
@RestController
public class LogLevel2 {
    @RequestMapping("/print")
    public String print(){
        log.info("info级别日志....");
        return "打印日志";
    }
}

运行输出结果：

1.时间戳：精确到毫秒

2.日志级别：INFO

3.进程ID

4.应用名称

5.线程名称

6.类名（指明哪个类输出的信息）

7.日志内容

刚刚提到一个比较新的名词，日志级别

那么介绍下日志级别有什么吧

日志级别

举例常用五个：

表格 还在加载中，请等待加载完成后再尝试复制

默认展示的级别是Info的，如若是想修改下，那么可以在配置文件中修改

logging:
  level:
   root: trace

这个这个是默认全局以trace级别展示日志信息，在控制台上

如若你想让设置某个包下的日志级别，可以这样设置

logging:
  level:
   root: info
   #设置包日志级别
   com:
     nanxi:
       mybatis:
         log: trace

日志持久化

刚刚说的日志是保存在 控制台上的，重启idea后，就没有了。如何进行持久化呢？

也是可以通过配置文件设定的：

通过name配置：

含义：指定“完整文件名”，可以包含绝对或相对路径，Spring Boot 会把日志写入到这个路径下

logging:
    file:
      name: logger/springboot.log

通过path配置：

含义：只指定“目录”，Spring Boot 会在这个目录下生成一个默认名称为 spring.log 的日志文件。

logging:
  file:
    path: D:/temp/aa

注意如果都写了的情况下，以name配置为主，会忽略掉path配置。

日志文件分割及其格式

日志文件不可能存储在一个文件中，会分块到很多个文件中

所以如何配置呢？

file：
  logback:
       rollingpolicy:
       #每个日志文件存储容量
         max-file-size: 1KB
         #分割后的文件格式形式
         file-name-pattern: ${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz

注意，并不是说每一个文件都会是1kb，如若最后一行录入该到该文件的内容很多，它会把该内容全部写入到这一个文件中，才会进行分割，不会写一半，留一半到下一个文件

格式我们也是可以调整的

配置如下：

 file:
     pattern:
     #针对于控制台而言
        console: '%d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n'
        #针对于输出的配置文件而言
        file: '%d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n'

这些配置信息，在springdoc网站中都可以找到的

这里提供 一个中文文档：

https://springdoc.cn/spring-boot/features.html#features.logging.custom-log-configuration