SpringBoot3—快速入门

一、简介

（1）前置知识

1. Java17
2. Spring、SpringMVC、MyBatis
3. Maven、IDEA

（2）环境要求

（3）SpringBoot3是什么

1. 核心概念：Spring Boot 底层是 Spring，能简单、快速地创建一个独立的、生产级别的 Spring 应用，多数应用只需少量配置就能整合 Spring 平台及第三方技术
2. 特性：
   1. 快速创建：相比 SSM 繁杂的导包、写配置、启动运行步骤，Spring Boot 能快速创建独立 Spring 应用
   2. 内置容器：直接嵌入 Tomcat、Jetty 或 Undertow 这些 Servlet 容器，无需部署 war 包。比如在 Linux 下，传统方式需将 war 包放到 Tomcat 的 webapps 下，而 Spring Boot 的 jar 包只需有 Java 环境，通过java -jar即可运行
   3. starter 简化整合：借助场景启动器（starter），像 web、json、邮件等场景，只需引入对应的 web-starter、mybatis-starter 等，就能自动添加所需依赖，无需手动导包和管理版本
   4. 自动配置：按需自动配置 Spring 及第三方库，每个场景有很多默认配置（约定大于配置），若要使用某个场景，其所有配置会自动配好，也可在配置文件中修改几项来自定义
   5. 生产级特性：提供监控指标、健康检查（用于 k8s 等）、外部化配置等生产级特性
   6. 无代码生成和 xml：开发过程中无代码生成，也无需 xml 配置
3. 总结：Spring Boot 实现了简化开发、配置、整合、部署、监控和运维

二、快速体验

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

（1）开发流程

2.1.1创建项目

maven项目

<!--    所有springboot项目都必须继承自 spring-boot-starter-parent --><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version></parent>

2.1.2导入场景

    <dependencies>
<!--        web开发的场景启动器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>

2.1.3主程序

只扫描主程序所在包的文件（及子包）

@SpringBootApplication //这是一个SpringBoot应用
public class MainApplication {public static void main(String[] args) {SpringApplication.run(MainApplication.class,args);}
}

2.1.4业务

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

2.1.5测试

默认启动访问： localhost:8080

2.1.6打包

<!--    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启动项目

（2）特性小结

2.2.1简化整合

1. 导入相关的场景，拥有相关的功能。场景启动器
2. 默认支持的所有场景：https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters
3. 官方提供的场景：命名为：spring-boot-starter-*
4. 第三方提供场景：命名为：*-spring-boot-starter

5. 场景一导入，万物皆就绪

2.2.2简化开发

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

2.2.3简化配置

application.properties

1. 集中式管理配置。只需要修改这个文件就行
2. 配置基本都有默认值
3. 能写的所有配置都在： https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties

2.2.4简化部署

1. 打包为可执行的jar包

2. linux服务器上有java环境

2.2.5简化运维

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

（3）Spring Initializr 创建向导

三、应用分析

（1）依赖管理机制

1. 导入 starter-web 相关依赖全部导入的原因
   1. 场景启动器理念：开发特定场景时，导入对应场景的启动器，场景启动器会自动将该场景的所有核心依赖全部导入
   2. Maven 依赖传递原则：若存在依赖关系 A → B → C，那么 A 会拥有 B 和 C 的依赖
2. 无需写版本号的原因（快捷键：Ctrl+F，可以在代码中搜索）
   1. 父项目层级：每个 Spring Boot 项目都有父项目 spring-boot-starter-parent，其又继承自 spring-boot-dependencies
   2. 版本仲裁：父项目作为版本仲裁中心，已声明了所有常见 JAR 依赖的版本。例如 mysql - connector - j 的版本已在父项目中声明
3. 自定义版本号的方法：利用 Maven 就近原则
   1. 在当前项目的 properties 标签中声明父项目使用的版本属性的键
   2. 在导入依赖时直接声明版本
4. 第三方的jar包：boot父项目没有管理的需要自行声明好

   <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
   <dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.16</version>
   </dependency>

（2）自动配置机制

3.2.1初步理解

1. 自动配置的 Tomcat、SpringMVC 等
   1. 导入场景，容器中就会自动配置好这个场景的核心组件
   2. 以前：DispatcherServlet（前端控制器）、ViewResolver（视图解析器）、CharacterEncodingFilter（字符编码过滤器）....
   3. 现在：自动配置好的这些组件
   4. 验证：容器中有了什么组件，就具有什么功能

          public static void main(String[] args) {//java10： 局部变量类型的自动推断var ioc = SpringApplication.run(MainApplication.class, args);//1、获取容器中所有组件的名字String[] names = ioc.getBeanDefinitionNames();//2、挨个遍历：// dispatcherServlet、beanNameViewResolver、characterEncodingFilter、multipartResolver// SpringBoot把以前配置的核心组件现在都给我们自动配置好了。for (String name : names) {System.out.println(name);}}

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

3.2.2完整流程

自动配置流程细节梳理：

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

核心流程总结： 

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

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

3.2.3如何学好SpringBoot

能通过配置文件覆盖组件默认配置调整底层行为，但实际还可通过自定义 Bean、扩展自动配置、实现接口或继承类等方式灵活定制

普通开发：导入starter，Controller、Service、Mapper、偶尔修改配置文件

高级开发：自定义组件、自定义配置、自定义starter

核心：

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

最佳实战：

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

整合redis：

1. 选场景：spring-boot-starter-data-redis：场景AutoConfiguration 就是这个场景的自动配置类
2. 写配置：
   1. 分析到这个场景的自动配置类开启了哪些属性绑定关系
   2. @EnableConfigurationProperties(RedisProperties.class)
   3. 修改redis相关的配置
3. 分析组件：
   1. 分析到 RedisAutoConfiguration 给容器中放了 StringRedisTemplate
   2. 给业务代码中自动装配 StringRedisTemplate
4. 定制化：
   1. 修改配置文件
   2. 自定义组件，自己给容器中放一个 StringRedisTemplate

四、核心技能

（1）常用注解

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

4.1.1组件注册

1. @Configuration、@SpringBootConfiguration
2. @Bean、@Scope
3. @Controller、 @Service、@Repository、@Component
4. @Import
5. @ComponentScan 

步骤：

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

4.1.2条件注解

如果注解指定的条件成立，则触发指定行为

1. @ConditionalOnXxx
2. @ConditionalOnClass：如果类路径中存在这个类，则触发指定行为
3. @ConditionalOnMissingClass：如果类路径中不存在这个类，则触发指定行为
4. @ConditionalOnBean：如果容器中存在这个Bean（组件），则触发指定行为
5. @ConditionalOnMissingBean：如果容器中不存在这个Bean（组件），则触发指定行为
6. @ConditionalOnBean（value=组件类型，name=组件名字）：判断容器中是否有这个类型的组件，并且名字是指定的值

场景： 

1. 如果存在FastsqlException这个类，给容器中放一个Cat组件，名cat01
2. 否则，就给容器中放一个Dog组件，名dog01否则，就给容器中放一个Dog组件，名dog01
3. 如果系统中有dog01这个组件，就给容器中放一个 User组件，名zhangsan
4. 否则，就放一个User，名叫lisi

4.1.3属性绑定

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

（2）YAML配置文件

痛点：SpringBoot 集中化管理配置，application.properties

问题：配置多以后难阅读和修改，层级结构辨识度不高

YAML 是 "YAML Ain't a Markup Language"（YAML 不是一种标记语言）。在开发的这种语言时，

YAML 的意思其实是："Yet Another Markup Language"（是另一种标记语言）

1. 设计目标，就是方便人类读写
2. 层次分明，更适合做配置文件
3. 使用.yaml或 .yml作为文件后缀

4.2.1基本语法

1. 大小写敏感
2. 使用缩进表示层级关系，k: v，使用空格分割k,v
3. 缩进时不允许使用Tab键，只允许使用空格。换行
4. 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
5. # 表示注释，从这个字符一直到行尾，都会被解析器忽略

支持的写法：

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

4.2.2示例

@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: 18birthDay: 2010/10/10 12:12:12like: truechild:name: 李四age: 20birthDay: 2018/10/10text: ["abc","def"]dogs:- name: 小黑age: 3- name: 小白age: 2cats:c1:name: 小蓝age: 3c2: {name: 小绿,age: 2} #对象也可用{}表示

4.2.3细节

1. birthDay 推荐写为 birth-day
2. 文本：
   1. 单引号不会转义【\n 则为普通字符串显示】
   2. 双引号会转义【\n会显示为换行符】
3. 大文本：
   1. |开头，大文本写在下层，保留文本格式，换行符正确显示
   2. >开头，大文本写在下层，折叠换行符
4. 多文档合并：使用---可以把多个yaml文档合并在一个文档中，每个文档区依然认为内容独立

   document1:key1: value1key2: value2
   ---
   document2:key3: value3key4: value4

4.2.4小技巧：lombok

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

<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><scope>compile</scope>
</dependency>

（3）日志配置

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

4.3.1简介

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

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

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

4.3.2日志格式 

1. 格式：

   2023-03-31T13:56:17.511+08:00  INFO 4944 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
   2023-03-31T13:56:17.511+08:00  INFO 4944 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.7]

2. 默认输出格式：
   1. 时间和日期：毫秒级精度
   2. 日志级别：ERROR, WARN, INFO, DEBUG, or TRACE
   3. 进程 ID
   4. ---： 消息分割符
   5. 线程名： 使用[]包含
   6. Logger 名： 通常是产生日志的类名
   7. 消息： 日志记录的内容
3. 默认值：参照（外部库）spring-boot包additional-spring-configuration-metadata.json文件
4. 默认输出格式值：

   %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}

   

5. 可修改为：

   '%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{15} ===> %msg%n'

   
6. 注意： logback 没有FATAL级别，对应的是ERROR

4.3.3记录日志

Logger logger = LoggerFactory.getLogger(getClass());或者使用Lombok的@Slf4j注解

4.3.4日志级别

1. 由低到高：ALL,TRACE, DEBUG, INFO, WARN, ERROR,FATAL,OFF
   1. 只会打印指定级别及以上级别的日志
   2. ALL：打印所有日志
   3. TRACE：追踪框架详细流程日志，一般不使用
   4. DEBUG：开发调试细节日志
   5. INFO：关键、感兴趣信息日志
   6. WARN：警告但不是错误的信息日志，比如：版本过时
   7. ERROR：业务错误日志，比如出现各种异常
   8. FATAL：致命错误日志，比如jvm系统崩溃
   9. OFF：关闭所有日志记录
2. 不指定级别的所有类，都使用root指定的级别作为默认级别
3. SpringBoot日志默认级别是 INFO

1.  在application.properties/yaml中配置logging.level.<logger-name>=<level>指定日志级别

   #默认所有日志没有精确指定级别就使用root的默认级别
   #logging.level.root=info#精确调整某个包下的日志级别
   #logging.level.com.atguigu.logging.controller=debug
   #logging.level.com.atguigu.logging.service=debug

2. level可取值范围：TRACE, DEBUG, INFO, WARN, ERROR, FATAL, or OFF，定义在 LogLevel类中
3. root 的logger-name叫root，可以配置logging.level.root=warn，代表所有未指定日志级别都使用 root 的 warn 级别

4.3.5日志分组

1. 将相关的logger分组在一起，统一配置。SpringBoot 也支持。比如：Tomcat 相关的日志统一设置

   logging.group.tomcat=org.apache.catalina,org.apache.coyote,org.apache.tomcat
   logging.level.tomcat=trace

2. SpringBoot 预定义两个组
3. additional-spring-configuration-metadata.json说明： 
4. 举例：
5. SpringBoot 预定义两个组

4.3.6文件输出

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

 

4.3.7文件归档与滚动切割

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

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

4.3.8自定义配置

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

如果可能，我们建议您在日志配置中使用-spring 变量（例如，logback-spring.xml 而不是 logback.xml）。如果您使用标准配置文件，spring 无法完全控制日志初始化 

最佳实战：自己要写配置，配置文件名加上 xx-spring.xml

4.3.9切换日志组合

<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>

4.3.10最佳实践

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

这两个类在