How to Access a Value from application.properties

Introduction

Spring Boot is a popular framework for building Java-based web applications. One of its key features is the ability to configure application properties using the `application.properties` or `application.yml` file. These properties can be used to configure various aspects of your Spring Boot application, such as database connections, server ports, and more. In this blog post, we will explore how to access a value defined in the `application.properties` file in Spring Boot.

Understanding application.properties

Before we dive into accessing properties, let's first understand how the `application.properties` file works in Spring Boot.

1. Default Location: By default, Spring Boot looks for an `application.properties` or `application.yml` file in the classpath root. You can also place it in the `src/main/resources` directory of your project.

2. Property Definitions: In the `application.properties` file, you define properties in a key-value pair format. For example:

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb

3. Property Hierarchy: Spring Boot uses a hierarchy to resolve property values. It first checks the properties defined in `application.properties` and then overlays them with properties defined in other files, such as `application.yml`, `application-{profile}.properties`, and environment variables.

Now that we understand how the `application.properties` file works, let's see how to access these properties in your Spring Boot application.

Accessing Properties in Spring Boot

Spring Boot provides several ways to access properties defined in the `application.properties` file.

1. Using the `@Value` Annotation

You can use the `@Value` annotation to inject property values directly into your Spring beans. Here's an example of how to use it in a Spring component:

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {
@Value("${server.port}")
private int serverPort;

@Value("${spring.datasource.url}")
private String dataSourceUrl;

public void printProperties() {
System.out.println("Server Port: " + serverPort);
System.out.println("Data Source URL: " + dataSourceUrl);
}
}

In the code above, we've injected the `server.port` and `spring.datasource.url` properties into the `MyComponent` bean. You can now use these values as needed within your component.

2. Using `Environment` Bean

The `Environment` bean allows you to access properties programmatically. Here's an example of how to do it:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {
@Autowired
private Environment env;

public void printProperties() {
String serverPort = env.getProperty("server.port");
String dataSourceUrl = env.getProperty("spring.datasource.url");

System.out.println("Server Port: " + serverPort);
System.out.println("Data Source URL: " + dataSourceUrl);
}
}

In this example, we've injected the `Environment` bean and used the `getProperty` method to retrieve property values.

3. Using `@ConfigurationProperties`

If you have a lot of properties to manage, it's a good idea to group them into a configuration class. Here's how you can do it:

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
private int serverPort;
private String dataSourceUrl;

// Getters and setters

public void printProperties() {
System.out.println("Server Port: " + serverPort);
System.out.println("Data Source URL: " + dataSourceUrl);
}
}

In this example, we've defined a `MyAppProperties` class and used the `@ConfigurationProperties` annotation with a `prefix` to specify the common prefix for our properties. Spring Boot will automatically bind properties with the specified prefix to this class.

To use this configuration class, you'll need to include the `@EnableConfigurationProperties` annotation in your main application class:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

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

Now you can inject and use the `MyAppProperties` class in your components.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {
@Autowired
private MyAppProperties myAppProperties;

public void printProperties() {
myAppProperties.printProperties();
}
}

Conclusion

Accessing properties defined in the `application.properties` file is a common task when working with Spring Boot applications. You can use the `@Value` annotation, the `Environment` bean, or create configuration classes with `@ConfigurationProperties` to make your code more organized and maintainable. Choose the approach that best fits your project's requirements and coding style, and start harnessing the power of externalized configuration in your Spring Boot applications.