本系列文章简介：

        Spring Boot是一种用于构建Java应用程序的开发框架，它提供了一种简化的方式来快速搭建和部署应用程序。在Spring Boot中，配置文件是一种重要的工具，用于配置应用程序的行为和属性。配置文件可以包含各种配置选项，例如数据库连接信息、日志级别、端口号等。

        配置文件的设计和使用对于开发人员来说非常重要。良好的配置文件设计可以使应用程序更易维护和可扩展。本文将详细介绍Spring Boot中的配置文件，并提供一些最佳实践和注意事项。

        首先，我们将介绍配置文件的种类和常见的语法格式。Spring Boot支持多种配置文件格式，包括properties文件、yml文件和XML文件。每种格式都有其特定的语法规则和用法。

        接下来，我们将讨论配置文件的加载顺序和优先级。Spring Boot按照一定的顺序加载配置文件，并根据优先级确定最终的配置值。了解加载顺序和优先级可以帮助开发人员更好地控制配置文件的行为。

        然后，我们将介绍配置文件的常见用途和场景。配置文件可以用于定义数据库连接信息、配置日志、设置缓存等。了解这些用途和场景可以帮助开发人员更好地利用配置文件来实现应用程序的需求。

        最后，我们将分享一些配置文件的最佳实践和注意事项。这些实践和注意事项包括如何避免敏感信息泄露、如何处理多环境配置等。遵循这些最佳实践可以提高应用程序的安全性和稳定性。

        通过学习本系列文章，大家可以更好地理解和运用配置文件，使自己的应用程序更加灵活和可配置。

        欢迎大家订阅《Java技术栈高级攻略》专栏，一起学习，一起涨分

目录

1、前言

2、配置文件的加载

2.1 Springboot配置文件的默认位置

2.2 外部配置文件的加载方式

2.3 配置文件的优先级和加载顺序

3、配置属性的使用

3.1 使用@ConfigurationProperties注解绑定属性

3.2 使用@Value注解绑定属性

3.3 使用Environment对象获取属性值

4、自定义配置文件

4.1 创建自定义配置文件

4.2 加载自定义配置文件

4.3 使用自定义配置属性

5、配置文件相关的高级特性

5.1 使用Spring表达式SpEL

5.2 使用占位符

5.3 使用Profile配置不同环境

6、结语

---

1、前言

        Spring Boot配置文件的作用是用来配置应用程序的属性和行为。配置文件可以包含应用程序的各种配置项，如数据库连接信息、日志配置、服务端口等。通过配置文件，可以对应用程序进行灵活的配置，而不需要修改源代码。Spring Boot支持多种类型的配置文件，如.properties、.yaml、.json等，可以根据需要选择合适的配置文件格式。配置文件可以放在不同的位置，如classpath根路径、外部文件系统、环境变量等，Spring Boot会自动扫描并加载配置文件。配置文件中的属性可以通过 @Value 注解或@ConfigurationProperties 注解注入到应用程序中，从而实现属性的读取和使用。通过配置文件，可以方便地修改应用程序的行为和属性，从而满足不同的需求。

        本文将跟随《Springboot的配置文件详解：从入门到精通（一）》的进度，继续介绍Spring Boot配置文件。希望通过本系列文章的学习，您将能够更好地理解Spring Boot配置文件的内部工作原理，掌握Spring Boot配置文件的使用技巧，以及通过合理的设计完成最佳实践，充分发挥优化Spring Boot配置文件的潜力，为系统的高效运行提供有力保障。

2、配置文件的加载

2.1 Springboot配置文件的默认位置

Spring Boot的配置文件有两种位置：

1. src/main/resources/application.properties或src/main/resources/application.yml：这是默认的配置文件位置。在这里定义的属性将应用于所有的环境。

2. 外部配置文件：如果想要在不同的环境中使用不同的配置文件，可以将配置文件放在以下位置之一，并使用spring.config.name和spring.config.location属性指定文件名和位置：

   • 文件系统中的某个目录，如/etc/myapp/
   • Java系统属性，如-Dspring.config.name=myapp和-Dspring.config.location=file:/etc/myapp/
   • 环境变量，如export SPRING_CONFIG_NAME=myapp和export SPRING_CONFIG_LOCATION=file:/etc/myapp/

除了以上位置，Spring Boot还支持其他一些位置，具体信息可以参考官方文档。

2.2 外部配置文件的加载方式

Spring Boot提供了多种外部配置文件的加载方式，具体有以下几种方式：

1. application.properties/application.yml文件： 在Spring Boot项目的src/main/resources目录下创建application.properties或application.yml文件，并在其中定义配置属性。Spring Boot会自动加载这些配置文件。

2. 自定义配置文件： 可以在application.properties/application.yml文件中使用spring.config.name和spring.config.location属性来指定自定义的配置文件。例如，可以在application.properties中添加以下配置： spring.config.name=myconfig spring.config.location=file:/path/to/myconfig.properties 这样Spring Boot会在指定的位置加载名为myconfig的配置文件。

3. 命令行参数： 可以在启动Spring Boot应用时通过命令行参数来指定配置属性。例如，可以使用--server.port=8080来指定应用的端口号。

4. 环境变量： 可以通过设置环境变量来定义配置属性。例如，可以设置一个名为SPRING_APPLICATION_JSON的环境变量，其中定义了配置属性的值，Spring Boot会自动加载这个环境变量中的配置属性。

5. 配置服务器： Spring Cloud Config提供了一种集中管理和动态刷新配置的方式。可以使用配置服务器来加载和管理配置属性。

总结来说，Spring Boot提供了多种方式来加载外部配置文件，可以根据实际需求选择适合的方式。

2.3 配置文件的优先级和加载顺序

Spring Boot 的配置文件有以下优先级和加载顺序：

1. 内嵌配置文件（Embedded Configuration）：Spring Boot 允许将配置文件嵌入到应用程序中，比如将配置文件直接写在代码中。这种方式拥有最高的优先级，配置会覆盖其他所有配置。

2. 命令行参数（Command-line Arguments）：通过命令行传递的参数会覆盖配置文件中的相应配置。比如可以通过 java -jar myproject.jar --server.port=8081 的方式指定端口号。

3. 系统环境变量（System Environment）：操作系统的环境变量中定义的配置会被加载，并覆盖默认的配置。环境变量的名称要符合一定的规则，如将配置 server.port 设置为 SPRING_SERVER_PORT=8082。

4. 配置文件（Application Properties 或者 Application.yml）：Spring Boot 支持两种配置文件格式，.properties 和 .yml，.properties 的优先级高于 .yml。配置文件可以在 src/main/resources 目录下，或者在外部指定的位置。

5. 默认配置（Default Properties）：Spring Boot 提供了一些默认的配置，被打包在应用程序中，优先级最低。这些配置可以通过 spring-configuration-metadata.json 和 spring-boot-features.properties 进行扩展和定制。

在加载配置文件时，Spring Boot 具有以下的加载顺序：

1. 首先，Spring Boot 会尝试从类路径下的 config 目录中加载配置文件。例如，/config/application.properties 或 /config/application.yml。

2. 如果在 config 目录中没有找到配置文件，Spring Boot 会加载类路径下的根目录的配置文件。例如，/application.properties 或 /application.yml。

3. 如果既没有在 config 目录中找到配置文件，也没有在根目录下找到配置文件，Spring Boot 会加载默认的配置文件。例如，META-INF/spring-boot-default.properties 或 META-INF/spring-boot-default.yml。

4. 最后，Spring Boot 会将加载到的配置文件合并，并应用于应用程序。

3、配置属性的使用

3.1 使用@ConfigurationProperties注解绑定属性

@ConfigurationProperties是Spring Boot提供的一个注解，用于将属性值注入到一个Java Bean中。

使用@ConfigurationProperties注解的步骤如下：

1. 创建一个Java Bean类，用于存储属性值。这个类需要使用@Component或@Configuration注解进行标注，以便Spring Boot能够自动扫描并创建它的实例。

@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {private String name;private String version;// Getters and setters
}

        2. 在application.properties或application.yml文件中，配置属性值，并使用前缀来区分不同的属性。

myapp.name=MyApp
myapp.version=1.0.0

或

myapp:name: MyAppversion: 1.0.0

        3. 在使用属性的地方，通过@Autowired注解将属性绑定到需要使用的地方。

@Autowired
private MyAppProperties myAppProperties;

这样，属性值就会被注入到MyAppProperties对象中，可以在代码中使用它们了。

需要注意的是，使用@ConfigurationProperties注解时，需要保证属性名称和Java Bean类中的属性名称一致，否则绑定会失败。可以使用@Value注解来进行属性名称的映射。另外，如果属性值有多个值，可以使用@Value注解搭配@Qualifier注解来指定属性的值。

3.2 使用@Value注解绑定属性

@Value注解是Spring框架提供的一种属性绑定方式，可以用来绑定属性值到Java类中的字段或方法参数。

使用@Value注解绑定属性的步骤如下：

1. 在Spring配置文件中配置占位符，用来表示需要绑定的属性值。例如，在application.properties文件中配置一个属性值：

   my.property=value
   

2. 在需要绑定属性的Java类中使用@Value注解来注入属性值。例如，假设我们要绑定上述配置文件中的my.property属性值到一个String类型的字段：

   @Component
   public class MyComponent {@Value("${my.property}")private String myProperty;// ...
   }
   

   这样，Spring容器会自动将配置文件中的my.property属性值注入到myProperty字段中。

通过@Value注解可以绑定属性的方式有以下几种：

• ${...}：用来引用配置文件中的属性值。
• #{...}：用来引用Spring表达式语言（SpEL）表达式的结果。
• #{systemProperties['...']}：用来引用系统属性。
• #{systemEnvironment['...']}：用来引用环境变量。

此外，@Value注解还可以用在方法参数上，用来绑定方法参数的值。例如：

@Component
public class MyComponent {@Autowiredprivate Environment env;public void myMethod(@Value("${my.property}") String myProperty) {// ...}
}

在上述示例中，myMethod方法的参数myProperty会被自动注入为配置文件中的my.property属性值。

3.3 使用Environment对象获取属性值

要获取属性值，可以通过Environment对象的get()方法来完成。该方法接收一个字符串，表示要获取的属性名，然后返回对应属性的值。

下面是一个例子：

import java.util.Map;public class Main {public static void main(String[] args) {Environment env = Environment.getCurrent();// 获取属性值String javaHome = env.get("JAVA_HOME");System.out.println("JAVA_HOME: " + javaHome);// 获取所有属性值Map<String, String> properties = env.getProperties();for (Map.Entry<String, String> entry : properties.entrySet()) {System.out.println(entry.getKey() + ": " + entry.getValue());}}
}

上面的代码首先使用Environment.getCurrent()方法获取当前的Environment对象，然后通过get()方法获取JAVA_HOME属性值，并打印出来。接着使用getProperties()方法获取所有属性值，遍历打印出来。

4、自定义配置文件

4.1 创建自定义配置文件

在Spring Boot中，我们可以使用自定义配置文件来管理应用程序的配置。以下是在Spring Boot中创建自定义配置文件的步骤：

1. 在src/main/resources目录下创建一个新的配置文件。可以使用任何名称，通常使用application.properties或application.yml作为默认配置文件。

2. 添加所需的配置属性到特定文件中。例如，可以在application.properties文件中添加以下内容：

   myapp.name=My Application
   myapp.version=1.0.0
   myapp.author=John Doe
   

   或者，在application.yml文件中添加以下内容：

   myapp:name: My Applicationversion: 1.0.0author: John Doe
   

   这里使用的是"myapp"前缀，你可以根据自己的需求自定义前缀。

3. 在Spring Boot应用程序中，使用@ConfigurationProperties注解将配置属性映射到Java类中。

   import org.springframework.boot.context.properties.ConfigurationProperties;
   import org.springframework.stereotype.Component;@Component
   @ConfigurationProperties(prefix = "myapp")
   public class MyAppProperties {private String name;private String version;private String author;// getter and setter methodspublic void printProperties() {System.out.println("Name: " + name);System.out.println("Version: " + version);System.out.println("Author: " + author);}
   }
   

4. 在需要使用配置属性的地方注入MyAppProperties对象。

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
   public class MyApp implements CommandLineRunner {@Autowiredprivate MyAppProperties myAppProperties;public static void main(String[] args) {SpringApplication.run(MyApp.class, args);}@Overridepublic void run(String... args) throws Exception {myAppProperties.printProperties();}
   }
   

   在上面的示例中，我们在CommandLineRunner.run()方法中打印了配置属性，你可以根据自己的需求使用这些属性。

通过以上步骤，我们成功创建了一个自定义的配置文件，并将其映射到了一个Java类中。这样我们可以方便地管理和使用配置属性。

4.2 加载自定义配置文件

在Spring Boot中，可以加载自定义的配置文件来覆盖默认的配置项。以下是加载自定义配置文件的步骤：

1. 创建一个自定义的配置文件，可以是properties格式或者yml格式。例如，可以创建一个名为custom.properties的文件，或者一个名为custom.yml的文件。

2. 在Spring Boot的配置类中，使用@PropertySource注解或者@ConfigurationProperties注解来加载自定义配置文件。例如：

   @Configuration
   @PropertySource("classpath:custom.properties") // 加载自定义的properties文件
   public class CustomConfig {// 配置项对应的属性，使用@Value注解获取配置项的值@Value("${custom.property1}")private String property1;// 其他配置项// ...// 配置项的Getter和Setter方法// ...
   }
   

   或者

   @Configuration
   @ConfigurationProperties(prefix = "custom") // 加载以custom为前缀的配置项
   public class CustomConfig {private String property1;// 其他配置项// ...// 配置项的Getter和Setter方法// ...
   }
   

3. 在application.properties或application.yml文件中，指定默认的配置项。例如，在application.properties文件中配置：

   # 默认的配置项
   property1=default-value
   

   或者在application.yml文件中配置：

   # 默认的配置项
   property1: default-value
   

   这样，在启动Spring Boot应用时，会先加载默认的配置项，然后再加载自定义的配置项，自定义的配置项会覆盖默认的配置项。

通过以上步骤，就可以在Spring Boot中加载自定义的配置文件并覆盖默认的配置项。

4.3 使用自定义配置属性

要在Spring Boot中使用自定义配置属性，您需要执行以下步骤：

1. 创建一个配置类，用于定义和读取自定义配置属性。您可以使用@ConfigurationProperties注解将配置绑定到属性类上。例如：

@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {private String name;private int version;// getters and setters
}

        2. 在Spring Boot的配置文件（application.properties或application.yml）中，定义自定义配置属性。例如：

myapp.name=My Application
myapp.version=1

        3. 在您的应用程序中，通过注入MyAppProperties类来使用自定义配置属性。例如：

@RestController
public class MyController {@Autowiredprivate MyAppProperties myAppProperties;@GetMapping("/hello")public String hello() {return "Hello from " + myAppProperties.getName() + " " + myAppProperties.getVersion();}
}

这样，当您访问/hello端点时，将返回自定义配置属性的值。

        4. 确保在Spring Boot应用程序的入口类上，添加@EnableConfigurationProperties注解，并指定要启用的配置属性类。例如：

@SpringBootApplication
@EnableConfigurationProperties(MyAppProperties.class)
public class MyApp {public static void main(String[] args) {SpringApplication.run(MyApp.class, args);}
}

这样，Spring Boot将扫描并加载自定义配置属性类。

以上就是在Spring Boot中使用自定义配置属性的基本步骤。您可以根据需要扩展和定制自定义配置属性类和配置文件。

5、配置文件相关的高级特性

5.1 使用Spring表达式SpEL

Spring表达式（SpEL）是一种强大的表达式语言，可以在Spring应用程序的配置文件中使用。SpEL提供了以下高级特性：

1. 访问属性和方法：SpEL可以访问Java对象的属性和方法。可以使用点号（.）来访问对象的属性，使用括号（()）来调用对象的方法。

2. 调用静态方法：SpEL可以调用Java类的静态方法。可以使用T()表示静态方法调用，后跟类的完全限定名和方法名称。

3. 计算数学运算：SpEL支持常见的数学运算，如加法、减法、乘法和除法。可以在表达式中使用+、-、*和/符号进行数学运算。

4. 逻辑运算和比较：SpEL支持逻辑运算符（与、或、非）和比较运算符（等于、不等于、大于、小于等）。可以使用&&、||和!运算符执行逻辑运算，使用==、!=、>、<、>=和<=运算符进行比较。

5. 条件表达式：SpEL可以根据条件选择不同的值。可以使用三元运算符（条件 ? trueValue : falseValue）执行条件表达式。

6. 集合操作：SpEL可以对集合进行操作，如访问集合元素、添加元素、移除元素等。可以使用[]来访问集合元素，使用#符号和{}来添加集合元素。

7. 条件判断：SpEL可以执行条件判断，如if-else语句。可以使用"?:", "#if", "#unless"等关键字进行条件判断。

8. 正则表达式匹配：SpEL可以使用正则表达式进行字符串匹配。可以使用matches操作符进行匹配。

这些是SpEL的一些高级特性，可以在Spring应用程序的配置文件中使用它们来动态地配置和管理应用程序的属性和行为。

5.2 使用占位符

占位符是一种在配置文件中使用的特殊标记，它可以在运行时根据实际的值进行替换。

使用占位符有多种好处，包括：

1. 可以提高配置文件的灵活性。通过使用占位符，可以将配置文件中的某些值动态地替换为不同的值，而无需修改配置文件本身。这使得在不同的环境中使用相同的配置文件变得更加方便，例如在开发、测试和生产环境中。

2. 可以隐藏敏感信息。有时配置文件中包含敏感信息，如密码、API密钥等。使用占位符可以将这些敏感信息存储在安全的地方，并在运行时动态替换为实际的值，从而避免将敏感信息暴露在配置文件中。

3. 可以方便地进行配置项的重用。通过使用占位符，可以将配置文件中的某些值定义为可重用的变量，并在其他地方引用这些变量。这样可以减少重复的配置项，并提高配置文件的可维护性。

常见的占位符使用语法包括：

• ${variable}：引用一个变量
• ${variable:default}：引用一个变量，如果变量不存在则使用默认值
• ${variable^}：引用一个变量并将其转换为大写
• ${variable,}：引用一个变量并将其转换为小写
• ${variable:pattern}：引用一个变量并应用一个正则表达式模式

使用占位符可以在配置文件中定义和引用变量，例如：

database.url=jdbc:mysql://${db.host}:${db.port}/${db.name}
db.host=localhost
db.port=3306
db.name=mydatabase

在上面的示例中，database.url配置项使用了占位符${db.host}、${db.port}和${db.name}，这些占位符在运行时会被实际的值替换，从而生成最终的数据库连接URL。

总的来说，使用占位符可以使配置文件更加灵活、安全和可维护，提高应用程序的配置管理能力。

5.3 使用Profile配置不同环境

在Java的Spring框架中，可以使用@Profile注解来配置不同环境下的配置文件。

首先，在application.properties或application.yml中定义不同环境的配置：

spring.profiles.active=dev

spring:profiles:active: dev

然后，在不同的配置文件中，可以使用@Profile注解来标注该配置适用的环境：

@Configuration
@Profile("dev")
public class DevConfig {// dev环境的配置
}@Configuration
@Profile("prod")
public class ProdConfig {// prod环境的配置
}@Configuration
@Profile("test")
public class TestConfig {// test环境的配置
}

在运行时，通过设置spring.profiles.active属性的值来指定使用哪个环境的配置文件。例如，可以通过命令行参数指定：

java -jar myapp.jar --spring.profiles.active=prod

或者在application.properties或application.yml中指定：

spring.profiles.active=prod

这样，Spring框架会根据当前指定的环境来加载相应的配置文件，并根据@Profile注解来创建对应的Bean。

6、结语

        文章至此，已接近尾声！希望此文能够对大家有所启发和帮助。同时，感谢大家的耐心阅读和对本文档的信任。在未来的技术学习和工作中，期待与各位大佬共同进步，共同探索新的技术前沿。最后，再次感谢各位的支持和关注。您的支持是作者创作的最大动力，如果您觉得这篇文章对您有所帮助，请分享给身边的朋友和同事！