SpringBoot3之配置文件（学习SpringBoot3的配置这一篇足够）_百度小程序

您的位置：上海毫米网络优化公司 > 小程序 > 百度小程序 >

一、SpringBoot3介绍

1.1 SpringBoot3简介

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

SpringBoot的主要目标是：

为所有 Spring 开发提供更快速、可广泛访问的入门体验。
开箱即用，设置合理的默认值，但是也可以根据需求进行适当的调整。
提供一系列大型项目通用的非功能性程序（如嵌入式服务器、安全性、指标、运行检查等）。
约定大于配置，基本不需要主动编写配置类、也不需要 XML 配置文件。
总结：简化开发，简化配置，简化整合，简化部署，简化监控，简化运维。

1.2 系统要求

技术&工具版本（or later）
maven 3.6.3 or later 3.6.3 或更高版本
Tomcat 10.0+
Servlet 9.0+
JDK 17+

1.3 快速入门

场景：浏览器发送 /hello请求，返回"Hello,Spring Boot 3!"
1. 开发步骤
  1. 创建Maven工程
  2. 添加依赖(springboot父工程依赖 , web启动器依赖)
  3. 编写启动引导类(springboot项目运行的入口)
  4. 编写处理器Controller
  5. 启动项目
2. 创建项目
3. 添加依赖
  
  3.1 添加父工程坐标
  
  SpringBoot可以帮我们方便的管理项目依赖 , 在Spring Boot提供了一个名为spring-boot-starter-parent的工程，里面已经对各种常用依赖的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标(不需要添加版本)即可！
```
    org.springframework.boot
    spring-boot-starter-parent
    3.1.3
```
  3.2 添加web启动器
  
  为了让Spring Boot帮我们完成各种自动配置，我们必须引入Spring Boot提供的自动配置依赖，我们称为启动器。因为我们是web项目，这里我们引入web启动器，在 pom.xml 文件中加入如下依赖：
```
    
        org.springframework.boot
        spring-boot-starter-web
    
```
  1. 创建启动类
  创建package：com.gedeshidai
  
  创建启动类：MainApplication
```
package com.gedeshidai.springboottest01;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * @SpringBootApplication是一个特殊的注解，用于标识一个Spring Boot应用程序的入口类。它的主要作用是将三个常用注解组合在一起，简化了配置的过程。
 *
 * 具体而言，@SpringBootApplication注解包含以下三个注解的功能：
 *     @Configuration：将该类标识为应用程序的配置类。它允许使用Java代码定义和配置Bean。
 *     @EnableAutoConfiguration：启用Spring Boot的自动配置机制。它根据项目的依赖项自动配置Spring应用程序的行为。自动配置根据类路径、注解和配置属性等条件来决定要使用的功能和配置。
 *     @ComponentScan：自动扫描并加载应用程序中的组件，如控制器、服务、存储库等。它默认扫描@SpringBootApplication注解所在类的包及其子包中的组件。
 *
 * 使用@SpringBootApplication注解，可以将上述三个注解的功能集中在一个注解上，简化了配置文件的编写和组件的加载和扫描过程。它是Spring Boot应用程序的入口点，标识了应用程序的主类，
 * 并告诉Spring Boot在启动时应如何配置和加载应用程序。
 */
@SpringBootApplication
public class MainApplication {
    //SpringApplication.run() 方法是启动 Spring Boot 应用程序的关键步骤。它创建应用程序上下文、
    // 自动配置应用程序、启动应用程序，并处理命令行参数，使应用程序能够运行和提供所需的功能
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }
}
```
4. 编写处理器Controller
  
  创建package：com.gedeshidai.controller
  
  创建类：HelloController
  
  注意： IoC和DI注解需要在启动类的同包或者子包下方可生效！无需指定，约束俗称。
```
package com.gedeshidai.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello(){
        return "Hello,Spring Boot 3!";
    }
}
```
5. 启动测试
1.4 入门总结
1. 为什么依赖不需要写版本？
  - 每个boot项目都有一个父项目spring-boot-starter-parent
  - parent的父项目是spring-boot-dependencies
  - 父项目版本仲裁中心，把所有常见的jar的依赖版本都声明好了。
  - 比如：mysql-connector-j
  - 启动器(Starter)是何方神圣？
    
    Spring Boot提供了一种叫做Starter的概念，它是一组预定义的依赖项集合，旨在简化Spring应用程序的配置和构建过程。Starter包含了一组相关的依赖项，以便在启动应用程序时自动引入所需的库、配置和功能。
    
    主要作用如下：
    1. 简化依赖管理：Spring Boot Starter通过捆绑和管理一组相关的依赖项，减少了手动解析和配置依赖项的工作。只需引入一个相关的Starter依赖，即可获取应用程序所需的全部依赖。
    2. 自动配置：Spring Boot Starter在应用程序启动时自动配置所需的组件和功能。通过根据类路径和其他设置的自动检测，Starter可以自动配置Spring Bean、数据源、消息传递等常见组件，从而使应用程序的配置变得简单和维护成本降低。
    3. 提供约定优于配置：Spring Boot Starter遵循“约定优于配置”的原则，通过提供一组默认设置和约定，减少了手动配置的需要。它定义了标准的配置文件命名约定、默认属性值、日志配置等，使得开发者可以更专注于业务逻辑而不是繁琐的配置细节。
    4. 快速启动和开发应用程序：Spring Boot Starter使得从零开始构建一个完整的Spring Boot应用程序变得容易。它提供了主要领域（如Web开发、数据访问、安全性、消息传递等）的Starter，帮助开发者快速搭建一个具备特定功能的应用程序原型。
    5. 模块化和可扩展性：Spring Boot Starter的组织结构使得应用程序的不同模块可以进行分离和解耦。每个模块可以有自己的Starter和依赖项，使得应用程序的不同部分可以按需进行开发和扩展。
    Spring Boot提供了许多预定义的Starter，例如spring-boot-starter-web用于构建Web应用程序，spring-boot-starter-data-jpa用于使用JPA进行数据库访问，spring-boot-starter-security用于安全认证和授权等等。
    
    使用Starter非常简单，只需要在项目的构建文件（例如Maven的pom.xml）中添加所需的Starter依赖，Spring Boot会自动处理依赖管理和配置。
    
    通过使用Starter，开发人员可以方便地引入和配置应用程序所需的功能，避免了手动添加大量的依赖项和编写冗长的配置文件的繁琐过程。同时，Starter也提供了一致的依赖项版本管理，确保依赖项之间的兼容性和稳定性。
    
    spring boot提供的全部启动器地址：
    
    https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters
    
    命名规范：
    - 官方提供的场景：命名为：spring-boot-starter-*
    - 第三方提供场景：命名为：*-spring-boot-starter
    - @SpringBootApplication注解的功效？
      
      @SpringBootApplication添加到启动类上，是一个组合注解，他的功效有具体的子注解实现！
```
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public @interface SpringBootApplication {}
```
      @SpringBootApplication注解是Spring Boot框架中的核心注解，它的主要作用是简化和加速Spring Boot应用程序的配置和启动过程。
      
      具体而言，@SpringBootApplication注解起到以下几个主要作用：
      1. 自动配置：@SpringBootApplication注解包含了@EnableAutoConfiguration注解，用于启用Spring Boot的自动配置机制。自动配置会根据应用程序的依赖项和类路径，自动配置各种常见的Spring配置和功能，减少开发者的手动配置工作。它通过智能地分析类路径、加载配置和条件判断，为应用程序提供适当的默认配置。
      2. 组件扫描：@SpringBootApplication注解包含了@ComponentScan注解，用于自动扫描并加载应用程序中的组件，例如控制器（Controllers）、服务（Services）、存储库（Repositories）等。它默认会扫描@SpringBootApplication注解所在类的包及其子包中的组件，并将它们纳入Spring Boot应用程序的上下文中，使它们可被自动注入和使用。
      3. 声明配置类：@SpringBootApplication注解本身就是一个组合注解，它包含了@Configuration注解，将被标注的类声明为配置类。配置类可以包含Spring框架相关的配置、Bean定义，以及其他的自定义配置。通过@SpringBootApplication注解，开发者可以将配置类与启动类合并在一起，使得配置和启动可以同时发生。
        总的来说，@SpringBootApplication注解的主要作用是简化Spring Boot应用程序的配置和启动过程。它自动配置应用程序、扫描并加载组件，并将配置和启动类合二为一，简化了开发者的工作量，提高了开发效率。
二、SpringBoot3配置文件

2.1 统一配置管理概述

SpringBoot工程下，进行统一的配置管理，你想设置的任何参数（端口号、项目根路径、数据库连接信息等等)都集中到一个固定位置和命名的配置文件（application.properties或application.yml）中！

配置文件应该放置在Spring Boot工程的src/main/resources目录下。这是因为src/main/resources目录是Spring Boot默认的类路径（classpath），配置文件会被自动加载并可供应用程序访问。
功能配置参数说明：

https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties

细节总结：
- 集中式管理配置。统一在一个文件完成程序功能参数设置和自定义参数声明。
- 位置：resources文件夹下，必须命名application 后缀 .properties / .yaml / .yml 。
- 如果同时存在application.properties | application.yml(.yaml) , properties的优先级更高。
- 配置基本都有默认值。
  2.2 属性配置文件使用
  1. 配置文件
    
    在 resource 文件夹下面新建 application.properties 配置文件
```
# application.properties 为统一配置文件
# 内部包含: 固定功能的key,自定义的key
# 此处的配置信息,我们都可以在程序中@Value等注解读取
# 固定的key
# 启动端口号
server.port=80 
# 自定义
spring.jdbc.datasource.driverClassName=com.mysql.cj.jdbc.driver
spring.jdbc.datasource.url=jdbc:mysql:///springboot_01
spring.jdbc.datasource.username=root
spring.jdbc.datasource.password=root
```
  2. 读取配置文件
```
package com.gedeshidai.properties;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class DataSourceProperties {
    @Value("${spring.jdbc.datasource.driverClassName}")
    private String driverClassName;
    @Value("${spring.jdbc.datasource.url}")
    private String url;
    @Value("${spring.jdbc.datasource.username}")
    private String username;
    @Value("${spring.jdbc.datasource.password}")
    private String password;
    // 生成get set 和 toString方法
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "DataSourceProperties{" +
                "driverClassName='" + driverClassName + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
```
    1. 测试效果
    在controller注入，输出进行测试
```
@Autowired
private DataSourceProperties dataSourceProperties ;
@RequestMapping(path = "/hello")
public String sayHello() {
  System.out.println(dataSourceProperties);
  return "Hello Spring Boot ! " ;
}
```
    2.3 YAML配置文件使用
  3. yaml格式介绍
    
    YAML（YAML Ain’t Markup Language）是一种基于层次结构的数据序列化格式，旨在提供一种易读、人类友好的数据表示方式。
    
    与.properties文件相比，YAML格式有以下优势：
    1. 层次结构：YAML文件使用缩进和冒号来表示层次结构，使得数据之间的关系更加清晰和直观。这样可以更容易理解和维护复杂的配置，特别适用于深层次嵌套的配置情况。
    2. 自我描述性：YAML文件具有自我描述性，字段和值之间使用冒号分隔，并使用缩进表示层级关系。这使得配置文件更易于阅读和理解，并且可以减少冗余的标点符号和引号。
    3. 注释支持：YAML格式支持注释，可以在配置文件中添加说明性的注释，使配置更具可读性和可维护性。相比之下，.properties文件不支持注释，无法提供类似的解释和说明。
    4. 多行文本：YAML格式支持多行文本的表示，可以更方便地表示长文本或数据块。相比之下，.properties文件需要使用转义符或将长文本拆分为多行。
    5. 类型支持：YAML格式天然支持复杂的数据类型，如列表、映射等。这使得在配置文件中表示嵌套结构或数据集合更加容易，而不需要进行额外的解析或转换。
    6. 更好的可读性：由于YAML格式的特点，它更容易被人类读懂和解释。它减少了配置文件中需要的特殊字符和语法，让配置更加清晰明了，从而减少了错误和歧义。
      综上所述，YAML格式相对于.properties文件具有更好的层次结构表示、自我描述性、注释支持、多行文本表示、复杂数据类型支持和更好的可读性。这些特点使YAML成为一种有力的配置文件格式，尤其适用于复杂的配置需求和人类可读的场景。然而，选择使用YAML还是.properties取决于实际需求和团队的偏好，简单的配置可以使用.properties，而复杂的配置可以选择YAML以获得更多的灵活性和可读性
  4. yaml语法说明
    1. 数据结构用树形结构呈现，通过缩进来表示层级，
    2. 连续的项目（集合）通过减号 ” - ” 来表示
    3. 键值结构里面的key/value对用冒号 ” : ” 来分隔。
    4. YAML配置文件的扩展名是yaml 或 yml
    5. 例如：
```
# YAML配置文件示例
app_name: 我的应用程序
version: 1.0.0
author: 张三
database:
  host: localhost
  port: 5432
  username: admin
  password: password123
features:
  - 登录
  - 注册
  - 仪表盘
settings:
  analytics: true
  theme: dark
```
  5. 配置文件
```
spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql:///springboot_02
      username: root
      password: root
      
server:
  port: 80
```
  6. 读取配置文件
    
    读取方式和properties一致
```
package com.gedeshidai.properties;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class DataSourceProperties {
    @Value("${spring.jdbc.datasource.driverClassName}")
    private String driverClassName;
    @Value("${spring.jdbc.datasource.url}")
    private String url;
    @Value("${spring.jdbc.datasource.username}")
    private String username;
    @Value("${spring.jdbc.datasource.password}")
    private String password;
    // 生成get set 和 toString方法
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "DataSourceProperties{" +
                "driverClassName='" + driverClassName + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
```
  7. 测试效果
    
    在controller注入，输出进行测试
```
@Autowired
private DataSourceProperties dataSourceProperties ;
@RequestMapping(path = "/hello")
public String sayHello() {
  System.out.println(dataSourceProperties);
  return "Hello Spring Boot ! " ;
}
```
    2.4 批量配置文件注入
  @ConfigurationProperties是SpringBoot提供的重要注解, 他可以将一些配置属性批量注入到bean对象。
  1. 创建类，添加属性和注解
    
    在类上通过@ConfigurationProperties注解声明该类要读取属性配置
    
    prefix=“spring.jdbc.datasource” 读取属性文件中前缀为spring.jdbc.datasource的值。前缀和属性名称和配置文件中的key必须要保持一致才可以注入成功
```
package com.gedeshidai.properties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSourceConfigurationProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "DataSourceConfigurationProperties{" +
                "driverClassName='" + driverClassName + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
```
  2. 测试效果
```
@RestController
public class HelloController {
    @Autowired
    private DataSourceProperties dataSourceProperties;
    @Autowired
    private DataSourceConfigurationProperties dataSourceConfigurationProperties;
    @GetMapping("/hello")
    public String hello(){
        System.out.println("dataSourceProperties = " + dataSourceProperties);
        System.out.println("dataSourceConfigurationProperties = " + dataSourceConfigurationProperties);
        return "Hello,Spring Boot 3!";
    }
}
```
    2.5 多环境配置和使用
  3. 需求
    
    在Spring Boot中，可以使用多环境配置来根据不同的运行环境（如开发、测试、生产）加载不同的配置。SpringBoot支持多环境配置让应用程序在不同的环境中使用不同的配置参数，例如数据库连接信息、日志级别、缓存配置等。
    
    以下是实现Spring Boot多环境配置的常见方法：
    1. 属性文件分离：将应用程序的配置参数分离到不同的属性文件中，每个环境对应一个属性文件。例如，可以创建application-dev.properties、application-prod.properties和application-test.properties等文件。在这些文件中，可以定义各自环境的配置参数，如数据库连接信息、端口号等。然后，在application.properties中通过spring.profiles.active属性指定当前使用的环境。Spring Boot会根据该属性来加载对应环境的属性文件，覆盖默认的配置。
    2. YAML配置文件：与属性文件类似，可以将配置参数分离到不同的YAML文件中，每个环境对应一个文件。例如，可以创建application-dev.yml、application-prod.yml和application-test.yml等文件。在这些文件中，可以使用YAML语法定义各自环境的配置参数。同样，通过spring.profiles.active属性指定当前的环境，Spring Boot会加载相应的YAML文件。
    3. 命令行参数(动态)：可以通过命令行参数来指定当前的环境。例如，可以使用--spring.profiles.active=dev来指定使用开发环境的配置。
      通过上述方法，Spring Boot会根据当前指定的环境来加载相应的配置文件或参数，从而实现多环境配置。这样可以简化在不同环境之间的配置切换，并且确保应用程序在不同环境中具有正确的配置。
  4. 多环境配置（基于方式b实践）
    
    创建开发、测试、生产三个环境的配置文件
    application-dev.yml（开发）
```
spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql:///dev
      username: root
      password: root
```
    application-test.yml（测试）
```
spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql:///test
      username: root
      password: root
```
    application-prod.yml（生产）
```
spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql:///prod
      username: root
      password: root
```
  5. 环境激活
```
spring:
  profiles:
    active: dev
```
    注意 :
    
    如果设置了spring.profiles.active，并且和application有重叠属性，以active设置优先。
    
    如果设置了spring.profiles.active，和application无重叠属性，application设置依然生效！

技术&工具	版本（or later）
maven	3.6.3 or later 3.6.3 或更高版本
Tomcat	10.0+
Servlet	9.0+
JDK	17+

上一篇：毕业设计——基于SpringBoot+Mybatis+Thymeleaf架构实现的员工管理系统（源码+数据库）

下一篇：springboot项目报Could not resolve view with name ‘xxxxxxxxxxx‘ in servlet with name ‘dispatcherServlet‘

一、SpringBoot3介绍

1.1 SpringBoot3简介

1.2 系统要求

1.3 快速入门

1.4 入门总结

二、SpringBoot3配置文件

2.1 统一配置管理概述

2.2 属性配置文件使用

2.3 YAML配置文件使用

2.4 批量配置文件注入

2.5 多环境配置和使用