0Pricing
Spring Boot 4 Complete Guide · 课时

外部化应用程序属性

使用 `application.properties` 和 `application.yml` 文件配置应用程序，并管理配置文件。

外部化应用程序属性 是 CoddyKit 上的免费 Spring Boot 4 Complete Guide 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Spring Boot 4 Complete Guide 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Spring Boot 4 Complete Guide 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Keep Config Flexible

Imagine building an app for different environments like development, testing, and production. Each might need unique database credentials, API keys, or server ports.

Hardcoding these values directly into your code is a bad practice. It makes your app inflexible and difficult to manage.

Externalizing configuration means storing these changeable values outside your main application code, allowing you to modify them without rebuilding your app.

application.properties

Spring Boot makes external configuration easy. The most common way is using the application.properties file, located in your src/main/resources folder.

It uses a simple key-value pair format, where each property is on a new line:

  • server.port=8080
  • spring.datasource.url=jdbc:h2:mem:testdb
  • my.custom.greeting=Hello CoddyKit!

These values can then be injected into your Spring components.

Injecting with @Value

To use an externalized property in your Java code, Spring provides the @Value annotation.

You can apply @Value to fields, constructor parameters, or method parameters. It reads the value associated with a specific key from your properties files.

The syntax is @Value("${property.key}"). If the property is not found, you can provide a default value like @Value("${property.key:Default Value}").

@Value in Action

Let's see how @Value works. First, we'll create an application.properties file.

src/main/resources/application.properties:

app.message=Welcome to CoddyKit!

Now, run this Spring Boot application. It will inject the property and print it on startup.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;

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

@Component
class MessagePrinter implements CommandLineRunner {

  @Value("${app.message}")
  private String message;

  @Override
  public void run(String... args) throws Exception {
    System.out.println("Application Message: " + message);
  }
}

Structured YAML Files

Another popular format for external configuration is YAML (YAML Ain't Markup Language), typically in an application.yml file.

YAML offers a more human-readable, hierarchical structure compared to the flat key-value pairs of .properties files. It uses indentation to define nested properties.

  • Readability: Easier to grasp complex configurations.
  • Hierarchy: Naturally groups related properties.
  • Less Repetition: Avoids repeating common prefixes.

YAML for Clarity

Here's how the same message property from before would look in application.yml:

src/main/resources/application.yml:

app: message: Welcome to CoddyKit! (YAML)

The Java code remains exactly the same as Spring Boot automatically supports both formats. Run this to see it in action.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;

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

@Component
class MessagePrinter implements CommandLineRunner {

  @Value("${app.message}")
  private String message;

  @Override
  public void run(String... args) throws Exception {
    System.out.println("Application Message: " + message);
  }
}

Who Wins? Precedence

What if you have both application.properties and application.yml in your project? Which one takes precedence?

Spring Boot has a specific order for loading configuration sources. Generally, properties defined in application.properties take precedence over those in application.yml when both exist and define the same key.

This allows you to override default values with more specific ones when needed, without changing the original files.

Adapting with Profiles

Spring Profiles provide a way to segregate parts of your application configuration and make it available only in certain environments.

For example, you might have different database settings for your development, test, and production environments. Instead of manually changing configuration files, you can define profiles.

When a specific profile is active, only the beans and configuration associated with that profile are loaded.

Tailoring for Environments

To define profile-specific properties, you create additional configuration files following a specific naming convention:

  • application-{profile}.properties
  • application-{profile}.yml

For example:

  • application-dev.properties for development settings.
  • application-prod.yml for production settings.

These files contain properties that apply only when their corresponding profile is active.

Switching Profiles

You can activate a Spring profile in several ways:

  • JVM System Property: Pass -Dspring.profiles.active=dev when running your app.
  • Environment Variable: Set SPRING_PROFILES_ACTIVE=prod.
  • Inside application.properties/.yml: Set spring.profiles.active=test.

It's common to use JVM arguments or environment variables for production deployments, keeping your main application.properties clean.

Quick Check: Config

You have an application.properties file with app.environment=development. You also have an application-prod.properties file with app.environment=production.

How would you activate the prod profile to ensure app.environment resolves to production?

Config Mastery Recap

Great job! You've learned how to externalize application properties in Spring Boot, making your applications more flexible and easier to manage across different environments.

  • We explored application.properties for simple key-value pairs.
  • We saw application.yml for structured, hierarchical configuration.
  • You learned to inject properties into your code using the @Value annotation.
  • Finally, we covered Spring Profiles to tailor configurations for specific environments and how to activate them.

This knowledge is crucial for building robust and adaptable Spring Boot applications!

常见问题解答

「外部化应用程序属性」课时是免费的吗？

是的 — 「外部化应用程序属性」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Complete Guide 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Complete Guide 课程共包含 4 节课。

「外部化应用程序属性」这节课中我会学到什么？

使用 `application.properties` 和 `application.yml` 文件配置应用程序，并管理配置文件。 你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Complete Guide，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Spring Boot 4 Complete Guide 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Spring Boot 4 Complete Guide 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

「外部化应用程序属性」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Spring Boot 4 Complete Guide 课中编写并运行代码吗？

能。每节 Spring Boot 4 Complete Guide 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 了解 Spring IoC 容器
  2. 在实践中进行依赖注入
  3. 外部化应用程序属性
  4. Bean 作用域与生命周期管理
← 返回 Spring Boot 4 Complete Guide