การแยกคุณสมบัติแอปพลิเคชันออกจากโค้ด

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.

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.

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}").

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

src/main/resources/application.properties:

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

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.

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

src/main/resources/application.yml:

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

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.

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.

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.

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.

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!