尚硅谷springboot3核心特性-快速入门(一)

发表于 2023-12-19 更新于 2023-12-24 分类于 java框架本文字数： 17k 阅读时长 ≈ 31 分钟

简介

前置知识

Java17
Spring、SpringMVC、Mybatis
Maven、IDEA

环境要求

环境&工具	版本(or later)
SpringBoot	3.0.5+
IDEA	2021.2.1+
Java	17+
Maven	3.5+
Tomcat	10.0+
Servlet	5.0+
GraalVM Community	22.3+
Native Build Tools	0.9.19+

SpringBoot是什么

SpringBoot帮我简单、快速地创建一个独立的、生产级别的Spring应用（说明：SpringBoot底层是Spring）
大多数SpringBoot应用只需要编写少量配置即可快速整合Spring平台以及第三方技术

特性：

快速创建独立 Spring 应用
- SSM：导包、写配置、启动运行
直接嵌入Tomcat、Jetty、or Undertow（无需配属war包）【Servlet容器】
- Linux java tomcat mysql：war放到tomcat的webapps下
- jar：java环境；java -jar xxx.jar
重点：提供可选的starter，简化应用整合
- 场景启动器（starter）:web、json、邮件、oss（对象存储）、异步、定时任务、缓存….
- 导包一堆，控制好版本
- 为每一种场景准备了一个依赖；web-starter、mybatis-starter
重点：按需自动配置Spring以及第三方库
- 如果这些场景我需要使用（生效）。这个场景的所有配置都会自动配置好。
- 约定大于配置：每个场景都有很多默认配置
- 自定义：配置文件中修改几项就可以
提供生产级特性：如监控指标、健康检查、外部化配置等
- 监控指标、健康检查（k8s）、外部化配置
无代码生成、无xml

总结：简化开发、简化配置、简化整合、简化部署、简化运维

快速体验

场景：浏览器发送/hello请求，返回”Hello,Spring Boot 3!“

开发流程

创建项目

maven项目

<!-- 所有springboot项目都必须继承自spring-boot-starter-parent -->
<parent> 
	<groupId>org.springframework.boot</groupId> 
	<artifactId>spring-boot-starter-parent</artifactId> 
	<version>3.2.0</version> 
</parent>
<!-- 也可以使用maven的多继承方式 -->
<dependencyManagement>  
  <dependencies>  
    <dependency>  
      <groupId>org.springframework.boot</groupId>  
      <artifactId>spring-boot-dependencies</artifactId>  
      <version>3.2.0</version>  
      <type>pom</type>  
    </dependency>  
  </dependencies>  
</dependencyManagement>

导入场景

<dependency>  
<!--- 导入web场景启动器 -->
  <groupId>org.springframework.boot</groupId>  
  <artifactId>spring-boot-starter-web</artifactId>  
</dependency>

主程序

@SpringBootApplication  //springboot项目
public class MainApplication {  
    public static void main(String[] args) {  
        SpringApplication.run(MainApplication.class,args);  
    }  
}

业务

@RestController  
public class HelloController {  
    @GetMapping("/hello")  
    public String hello(){  
        return "Hello,Spring Boot 3!";  
    }  
}

测试

启动访问：127.0.0.1:8080/hello

打包

<!-- springboot应用打包插件 -->
<build>  
  <plugins>  
    <plugin>  
      <groupId>org.springframework.boot</groupId>  
      <artifactId>spring-boot-maven-plugin</artifactId>  
    </plugin>  
  </plugins>  
</build>

执行命令 mvn clean package 把项目打成可执行的jar包
java -jar demo.jar 启动项目

特性小结

简化整合

只需要导入相关的场景，就可以拥有相关的功能，场景启动器
springboot默认支持的所有场景：Developing with Spring Boot

官方提供的场景：命名为：spring-boot-starter-*
第三方提供的场景：命名为：*-spring-boot-starter

简化开发

无需编写任何配置，直接开始开发业务

简化配置

application.properties :

集中式管理配置，只需要在这个文件里面修改即可。
配置基本都有默认值（即便不做任何自定义配置，项目也基本可用）。
能写的所有的配置：Common Application Properties (spring.io)

简化部署

打包为可执行的jar包
只需要服务器上有java环境，即可通过java -jar 命令启动服务

简化运维

修改配置（外部放一个application.properties文件即可）、监控、健康检查

SpringBoot项目创建向导

可以使用 Spring Initializr idea中springboot项目创建向导进行创建

Spring Initializr示意图

也可以通过浏览器在线创建
- Spring Initializr
- Cloud Native App Initializer (aliyun.com)
  一键创建好整个项目结构

应用分析

依赖管理机制

思考：

为什么导入 starter-web 所有相关依赖就都导入进来？
- 开发什么场景，导入什么场景启动器
- maven依赖传递原则，A-B-C,A就拥有了B和C
- 导入场景启动器，场景启动器自动把这个场景的所有核心依赖全部导入进来
为什么版本号都不用写？
- 每个boot项目都有一个父项目，spring-boot-starter-parent
- parent的父项目是spring-boot-dependencies
- 父项目版本仲裁中心，把所有常见的jar的依赖版本都声明好了
- 比如mysql-connector-j
自定义版本号
- 利用maven的就近原则
  - 直接在当前项目properties标签中申明父项目用的版本属性的key
  - 直接在导入依赖的时候声明版本号
第三方的jar包
- boot父项目没有管理的依赖需要自行声明

springboot依赖传递图示

自动配置机制

初步理解

自动配置的Tomcat、SpringMVC等

导入场景，容器中就会自动配置好这个场景的核心组件
以前：DispatcherServlet、ViewResolver、CharacterEncodingFilter….
现在：自动配置好了这些组件

验证：容器中有了申明组件，就具有了生么功能

@SpringBootApplication  
public class Boot302DemoApplication {  
    public static void main(String[] args) {  
       //java10: 局部变量类型的自动推断  
       var ioc = SpringApplication.run(Boot302DemoApplication.class, args);  
       //1. 获取容器中所有组件的名字  
       String[] beanDefinitionNames = ioc.getBeanDefinitionNames();  
       //2.循环遍历  
       //dispatcherServlet、beanNameViewResolver、characterEncodingFilter、multipartResolver  
       //springboot把以前需要自己配置的核心组件现在都给我自动配置好了  
       for (String beanName : beanDefinitionNames) {  
          System.out.println(beanName);  
       }  
    }  
}

默认的包扫描规则
- @SpringBootApplication 标注的类就是主程序类
- SprinBoot只会扫描主程序所在的包及其下面的子包，（自动的ComponentScan功能）
- 自定义扫描路径
  - ``@SpringBootApplication(scanBasePackages = “com.ys”)`
  - ``@ComponentScan(“com.ys”)`
配置默认值
- 配置文件的配置项都是和某个类的对象值进行一一绑定的
- 绑定了配置文件中每一项值的类：属性类
- 比如：
  - ServerProperties绑定了所有Tomcat服务器有关的配置
  - MultipartProperties绑定了所有文件上传相关的配置
  - 参考官方文档：或者参考绑定的属性类
按需加载自动配置
- 导入场景spring-boot-starter-web
- 场景启动器除了会导入相关功能依赖，还会导入一个spring-boot-starter，这是所有starter的starter（基础核心starter）
- spring-boot-starter导入了一个包spring-boot-autoconfigure，里面是各种场景的AutoConfiguration自动配置类
- 虽然全场景自动配置都在spring-boot-autoconfigure这个包，但是并不会全部都开启生效
  - 导入哪个场景就开启对应的自动配置

总结：导入场景启动器、触发spring-boot-autoconfigure这个包的自动配置生效，容器中就会具有相关场景的功能。

完整流程

思考：

SpringBoot怎么实现导入一个starter、写一些简单配置，应用就能跑起来？

为什么Tomcat的端口号可以配置在application.properties中，并且Tomcat能启动成功？

导入场景后哪些自动配置能生效？

自动配置生效示意图

自动配置流程细节梳理：

导入starter-web: 导入了web开发场景
- 1、场景启动器导入了相关场景的所有依赖：starter-json、starter-tomcat、springmvc
- 2、每个场景启动器都引入了一个spring-boot-starter，核心场景启动器
- 3、核心场景启动器引入了spring-boot-autoconfigure包
- 4、spring-boot-autoconfigure里面囊括了所有场景的所有配置
- 5、只要这个包下的所有类都能生效，那么相当于SpringBoot官方写好的整合功能就生效了
- 6、SpringBoot默认却扫描不到spring-boot-autoconfigure下写好的所有配置类。（这些配置类给我们做了整合操作）默认只扫描主程序所在的包及其子包
主程序：@SpringBootApplication
- 1、@SpringBootApplication由三个注解组成@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan
- 2、SpringBoot默认只能扫描自己主程序所在的包及其下面的子包，扫描不到spring-boot-autoconfigure包中官方写好的配置类
- 3、@EnableAutoConfiguration：SpringBoot开启自动配置的核心
  - 1、是由@Import(AutoConfigurationImportSelector.class)提供功能：批量给容器中导入组件。
  - 2、SpringBoot启动会默认加载152个配置类
  - 3、这152个配置类来自于spring-boot-autoconfigure下META-INF\spring\org.springframework.boot.autoconfigure.AutoConfiguration.imports文件指定的
  - 启动项目的时候利用@Import注解批量导入组件机制把autoconfigure包下的152个xxxAutoConfiguration类导入进来（自动配置）
  - 虽然导入了152个自动配置类，但并不会全部生效
- 4、按需生效
  - 并不是这152个自动配置类都能生效
  - 每个自动配置类都有条件注解@ConditionalOnxxx，只有条件成立，才能生效
xxxAutoConfiguration自动配置
- 1、给容器中使用@Bean放一堆组件
- 2、每个自动配置类都可能有这个注解@EnableConfigurationProperties({ ServerProperties.class, WebMvcProperties.class })，用来把配置文件中配的指定前缀的属性值封装到xxxProperties属性类中
- 3、以Tomcat为例：把服务器的所有配置都是以server开头的，配置都封装到了ServerProperties类中。
- 4、给容器中放的所有组件的一些核心参数，都来自于xxxProperties。xxxProperties都是和配置文件中的配置项绑定的。
- 只需要修改配置文件中配置项的值，核心组件的底层参数就都能修改。
写业务，全程无需关系各种整合（底层这些整合写好，而且也都生效了）。

核心流程总结：

导入starter，就会导入autoconfigure包。
autoconfigure包里面有一个文件META-INF\spring\org.springframework.boot.autoconfigure.AutoConfiguration.imports，里面指定了所有启动要加载的自动配置类。
@EnableAutoConfiguration会自动把上面文件里面写的所有自动配置类都导入进来。（xxxAutoConfiguration是有条件朱姐进行按需加载）
xxxAutoConfiguration给容器中导入一堆组件，组件都是从xxxProperties中提取的属性值。
xxxProperties又是和配置文件进行了绑定。

效果：导入starter、修改配置文件，就能修改底层行为。

如何学会SpringBoot

框架的框架、底层基于Spring，能调整某一个场景的底层行为，可以自定义底层组件。

理解自动配置原理
- 导入starter —> 生效xxxAutoConfiguration —> 组件 —> xxxProperties —> 配置文件
理解其他框架
- 拦截器
可以随时定制化任何组件
- 配置文件
- 自定义组件

普通开发：导入starter，Controller，Service，Mapper，偶尔修改配置文件
高级开发：自定义组件，自定义配置，自定义starter

核心：

这个场景自动配置导入了哪些组件，我们能不能注入进来使用
能不能通过修改配置改变组件的一些默认参数
需不需要自己完全定义这个组件
场景定制化

最佳实战：

选场景，导入到项目
- 官方：starter
- 第三方：去仓库搜或者去官网查看
写配置，改配置文件关键项
- 数据库参数（链接地址，账号秘密…）
分析这个场景给我们导入了哪些能用的组件
- 自动装配这些组件进行后续使用
- 不满意boot提供的自动配好的默认组件
  - 定制化
    - 改配置
    - 自定义组件

整合redis：

选场景：spring-boot-starter-data-redis
- RedisAutoConfiguration，redis场景自动配置类
写配置
- 分析这个场景的自动配置类开启了哪些属性绑定关系
- @EnableConfigurationProperties(RedisProperties.class)
- 修改redis相关的配置项（提供的有默认值）
分析组件
- 分析到RedisAutoConfiguration给容器中放了StringRedisTemplate
- 可以给业务代码中自动装配StringRedisTemplate
定制化
- 修改配置文件
- 自定义组件，自己给容器中放一个StringRedisTemplate

核心技能

常用注解

SpringBoot摒弃了XML配置方式，改为全注解驱动

组件注册

@Configuration：指定该类为配置类
@SpringBootConfiguration：指定该类为SpringBoot的配置类
@Bean：标记在方法上，将方法的返回值注入成Bean
@Scope：指定Bean的模式（单例、多例等，默认单例）
@Controller：标记类为一个Controller组件
@Service：标记类为一个Service组件
@Repository：标记类为数据访问层Bean
@Component：标记类为一个组件
@Import：将某个或者某几个类加载成组件
@ComponentScan：指定SpringBoot扫描包路径

步骤：

@Configuration 编写一个配置类
在配置类中，自定义方法给容器中注册组件，配合@Bean
或使用@Import导入第三方的组件

条件注解

@ConditionalOnXxx
@ConditionalOnClass：如果类路径中存在这个类，则触发指定行为
@ConditionalOnMissingClass：如果类路径中不存在这个类，则触发指定行为
@ConditionalOnBean：如果容器中存在这个Bean，则触发指定行为
@ConditionalOnMissingBean：如果容器中不存在这个Bean，则触发指定行为

@ConditionalOnBean(value = 组件类型, name = 组件名称)：判断容器中是否存在这个类型的组件，并且名字是指定的值。

@ConditionalOnRepositoryType (org.springframework.boot.autoconfigure.data)
@ConditionalOnDefaultWebSecurity (org.springframework.boot.autoconfigure.security)
@ConditionalOnSingleCandidate (org.springframework.boot.autoconfigure.condition)
@ConditionalOnWebApplication (org.springframework.boot.autoconfigure.condition)
@ConditionalOnWarDeployment (org.springframework.boot.autoconfigure.condition)
@ConditionalOnJndi (org.springframework.boot.autoconfigure.condition)
@ConditionalOnResource (org.springframework.boot.autoconfigure.condition)
@ConditionalOnExpression (org.springframework.boot.autoconfigure.condition)
@ConditionalOnClass (org.springframework.boot.autoconfigure.condition)
@ConditionalOnEnabledResourceChain (org.springframework.boot.autoconfigure.web)
@ConditionalOnMissingClass (org.springframework.boot.autoconfigure.condition)
@ConditionalOnNotWebApplication (org.springframework.boot.autoconfigure.condition)
@ConditionalOnProperty (org.springframework.boot.autoconfigure.condition)
@ConditionalOnCloudPlatform (org.springframework.boot.autoconfigure.condition)
@ConditionalOnBean (org.springframework.boot.autoconfigure.condition)
@ConditionalOnMissingBean (org.springframework.boot.autoconfigure.condition)
@ConditionalOnMissingFilterBean (org.springframework.boot.autoconfigure.web.servlet)
@Profile (org.springframework.context.annotation)
@ConditionalOnInitializedRestarter (org.springframework.boot.devtools.restart)
@ConditionalOnGraphQlSchema (org.springframework.boot.autoconfigure.graphql)
@ConditionalOnJava (org.springframework.boot.autoconfigure.condition)

属性绑定

@ConfigurationProperties：声明组件的属性和配置文件哪些前缀开始项进行绑定
@EnableConfigurationProperties：快速注册注解：
- 场景：SpringBoot默认只扫描自己主程序所在包，如果导入第三方包，即使类上标注了@Component、@ConfigurationProperties注解，也没有用，因为组件都扫描不进来，此时使用这个注解就可以快速进行属性绑定并把组件注册进容器。

将容器中任意组件（Bean）的属性值和配置文件的配置项的值进行绑定
1、给容器中注册组件（@Component、@Bean）
2、使用@ConfigurationProperties声明组件和配置文件的哪些配置项进行绑定

YAML配置文件

痛点：SpringBoot集中化管理配置，application.properties
问题：配置多了以后难以阅读和修改，层级结构辨识度不高

YAML另一种标记语言。
1、设计目标，就是方便人类读写
层次分明，更适合做配置文件
使用.yaml或.yml作为文件后缀

基本语法

大小写敏感
使用缩进表示层级关系，k: v，使用空格分割k、v
缩进的空格数目不重要，主要相同层级的元素左侧对齐即可
# 表示注释，从这个字符一直到行尾，都会被解析器忽略

支持的写法：

对象：键值对的集合：如映射（map）、哈希（hash）、字典（dictionary）
数组：一组安次序排列的值，如序列（sequence）、列表（list）
纯量：单个的、不可再分割的值，如：字符串、数字、bool、日期

注意：日期格式需要使用/分割，而不是常用的-（默认 2023/12/24）

示例

@Component
@ConfigurationProperties(prefix = "person") //和配置文件person前缀的所有配置进行绑定
@Data //自动生成JavaBean属性的getter/setter
//@NoArgsConstructor //自动生成无参构造器
//@AllArgsConstructor //自动生成全参构造器
public class Person {
    private String name;
    private Integer age;
    private Date birthDay;
    private Boolean like;
    private Child child; //嵌套对象
    private List<Dog> dogs; //数组（里面是对象）
    private Map<String,Cat> cats; //表示Map
}

@Data
public class Dog {
    private String name;
    private Integer age;
}

@Data
public class Child {
    private String name;
    private Integer age;
    private Date birthDay;
    private List<String> text; //数组
}

@Data
public class Cat {
    private String name;
    private Integer age;
}

properties表示写法

person.name=张三
person.age=18
person.birthDay=2010/10/12 12:12:12
person.like=true
person.child.name=李四
person.child.age=12
person.child.birthDay=2018/10/12
person.child.text[0]=abc
person.child.text[1]=def
person.dogs[0].name=小黑
person.dogs[0].age=3
person.dogs[1].name=小白
person.dogs[1].age=2
person.cats.c1.name=小蓝
person.cats.c1.age=3
person.cats.c2.name=小灰
person.cats.c2.age=2

YAML表示写法

person:
  name: 张三
  age: 18
  birthDay: 2010/10/10 12:12:12
  like: true
  child:
    name: 李四
    age: 20
    birthDay: 2018/10/10
    text: ["abc","def"]
  dogs:
    - name: 小黑
      age: 3
    - name: 小白
      age: 2
  cats:
    c1:
      name: 小蓝
      age: 3
    c2: {name: 小绿,age: 2} #对象也可用{}表示

细节

birthDay 推荐写为 birth-day(实体类中驼峰命名建议在yml中映射为横线分割)
文本：
- 单引号不会转义（\n则为普通字符串显示）
- 双引号会转义（\n会显示为换行符）
大文本
- |开头，大文本写在下层，保留文本格式，换行符正确显示
- >开头，大文本写在下层，折叠换行符
多行文档合并
- 使用---可以把多个yaml文档合并在一个文件里面，每个文档区依然认为内容独立

小技巧：lombok

简化JavaBean开发，自动生成构造器、getter/setter、自动生成Buider模式等

<dependency>  
    <groupId>org.projectlombok</groupId>  
    <artifactId>lombok</artifactId>  
    <!--不传递依赖-->
    <optional>true</optional>  
</dependency>
<!--lombok在代码编译的时候自动修改字节码以达到自动生成各种方法的目的，在代码编译之后打包的时候字节码已经生成，所以并不需要将lombok依赖包打入jar或者war，所以可以在springboot的maven插件中使用 excludes 标签进行排除-->

日志配置

规范：项目开发不要编写 System.out.println()，应该用日志记录信息

日志门面	日志实现
JCL（Jakarta Commons Logging） SLF4J（Simple Logging Facade for Java） Jboss-logging	Log4j JUL（java.util.logging） Log4j2 Logback

日志门面为接口层，想要使用日志，需要选取一个接口层，然后再选取一个实现层配合使用。

SpringBoot默认使用的是SLF4J+Logback

简介

Spring使用commons-logging作为内部日志，但底层日志实现是开放的，可对接其他日志框架
- spring5及以后commons-logging被spring直接自己写了spring-jcl
支持jul、log4j2、logback，SpringBoot提供了默认的控制台输出配置，也可以配置输出为文件。
logback是默认使用的。
虽然日志框架很多，但是我们不用担心，使用SpringBoot的默认配置就能工作的很好。

SpringBoot怎么把日志默认配置好的：

每个starter场景，都会导入一个核心场景spring-boot-starter
核心场景引入了日志的所有功能spring-boot-starter-logging
默认使用logback + slf4j组合作为默认底层日志
日志是系统一启动就要使用的，xxxAutoConfiguration是系统启动好放的组件，后来用的。
日志是利用监听机制配置好的，ApplicationListener
日志所有的配置都可以通过修改配置文件实现，以logging开始的所有配置

日志格式

1
2

2023-12-24T09:42:24.038+08:00  INFO 31224 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2023-12-24T09:42:24.038+08:00  INFO 31224 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.17]

日志默认输出格式：

时间和日期：毫秒级精度
日志级别：ERROR, WARN, INFO, TRACE
进程ID
—：消息分隔符
线程名：使用[]包含
Logger名：通常是产生日志的类名
消息：日志记录的内容

注意：logback没有FATAL级别，对应的是REEOR

默认值：参照：spring-boot包下的additional-spring-configuration-metadata.json文件

默认输出格式：%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd'T'HH:mm:ss.SSSXXX}}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}

可在配置文件中修改logging.pattern.console（修改控制台输出日志格式）%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{15} ===> %msg%n

记录日志

1 2	Logger log = LoggerFactory.getLogger(Xxxx.class); //或者使用Lombok的@Slf4j注解自动生成

日志级别

由低到高：ALL, TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF;
- 如果设定某个级别的日志，那么只会打印指定级别以及以上级别的日志
- ALL：打印所有日志，是最低级别
- TRACE：最终框架详细流程日志，一般不使用
- DEBUG：开发调试细节日志
- INFO：关键、感兴趣信息日志
- WARN：警告但不是错误的信息日志，比如；版本过时
- ERROR：业务错误日志，比如出现各种异常
- FATAL：致命错误日志，比如jvm系统崩溃
- OFF：关闭所有日志记录
不指定级别的所有类，都使用root分组logging.level.root指定的级别作为默认级别
SpringBoot日志默认级别是INFO

在application.properties/yaml中配置logging.level.<logger-name>=<level>指定日志级别
level可取值范围：TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF（org.springframework.boot.logging.LogLevel）
root的logger-name叫root可以配置logging.level.root=warn表示所有未指定日志级别都使用root的warn级别
日志分组
将相关的logger分组在一起，统一配置，SpringBoot也支持，比如：tomcat相关的日志统一
1
2
logging.group.tomcat=org.apache.catalina,org.apache.coyote,org.apache.tomcat
logging.level.tomcat=trace

SpringBoot预定义的两个组：

Name	Loggers
web	org.springframework.core.codec, org.springframework.http, org.springframework.web, org.springframework.boot.actuate.endpoint.web, org.springframework.boot.web.servlet.ServletContextInitializerBeans
sql	org.springframework.jdbc.core, org.hibernate.SQL, org.jooq.tools.LoggerListener

文件输出

SpringBoot默认只把日志写在控制台，如果想额外记录到文件，可以在application.properties中添加logging.file.path或者logging.file.name配置项

logging.file.name	logging.file.path	示例	效果
未指定	未指定		仅输出到控制台
指定	未指定	my.log	写入指定文件，可以加路径，没有路径默认在当前项目下
未指定	指定	/var/log	写入指定目录，文件名为`spring.log`
指定	指定		以`logging.file.name` 为准

文件归档与滚动切割

归档：每天的日志单独存到一个文件中
切割：每个文件默认10MB，超过大小切割成另外一个文件

每天的日志应该独立分割出来存档，如果使用logback（SpringBoot默认整合），可以通过application.properties/yml文件指定日志滚动规则。
如果是其他日志系统，需要自动配置（添加log4j2.xml或log4j2-spring.xml）
支持的滚动规则设置如下：

配置项	描述
`logging.logback.rollingpolicy.file-name-pattern`	日志存档的文件名格式（默认值：`${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz`）
`logging.logback.rollingpolicy.clean-history-on-start`	应用启动时是否清除以前存档（默认值：`false`）
`logging.logback.rollingpolicy.max-file-size`	存档前，每个日志文件的最大大小（默认值：`10MB`）
`logging.logback.rollingpolicy.total-size-cap`	日志文件被删除之前，可以容纳的最大大小（默认值：`0B`），设置`1GB`则磁盘存储超过1GB日志后，就会删除旧日志文件
`logging.logback.rollingpolicy.max-history`	日志文件保存的最大天数（默认值：`7`）

自定义配置

通常我们配置application.properties就够了，当然也可以自定义

日志系统	自定义
Logback	logbock-spring.xml, logback-spring.groovy, logback.xml, logback.groovy
Log4j2	log4j2-spring.xml , log4j2.xml
JDK (Java Util Logging)	logging.properties

如果可能，建议在日志配置中使用-spring方式的命名（例如：logbock-spring.xml），如果使用的是标准配置文件（logbock.xml），那么是由框架本身做控制，spring无法完全控制日志初始化

切换日志组合

将springboot默认的logback切换到log4j2

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

log4j2支持yaml和json格式的配置文件

格式	依赖	文件名
YAML	com.fasterxml.jackson.core:jackson-databind + com.fasterxml.jackson.dataformat:jackson-dataformat-yaml	log4j2.yaml / log4j2.yml
JSON	com.fasterxml.jackson.core:jackson-databind	log4j2.json / log4j2.jsn

最佳实战

导入任何第三方框架，先排除它的日志包，因为Boot底层控制好了日志
修改application.properties配置文件，就可以调整日志的所有行为，如果不够，可以编写日志框架自己的配置文件放在类路径下就行。
如果对接专业日志系统，也只需要把logback记录到日志灌到kafka之类的中间件，这和SpringBoot没有关系，都是日志框架自己的配置，修改配置文件即可
业务中使用了日志api记录日志，不要在使用System.out.println()

附录：SpringBoot3改变&新特性快速总结

自动配置包位置变化
META-INF\spring\org.springframework.boot.autoconfigure.AutoConfiguration.imports
jakata api迁移
新特性-函数式web、ProblemDetails
GraalVM与AOT

简介