What is the role of the @Value annotation?

Table of Contents

• Introduction
• Role of the @Value Annotation
  • 1. Injecting Values from Property Files
    • Example: Injecting from application.properties
    • Example in Java Class:
  • 2. Injecting Values from Environment Variables
    • Example:
  • 3. Injecting Values from SpEL Expressions (Spring Expression Language)
    • Example of SpEL Expression:
  • 4. Providing Default Values
    • Example of Default Value:
  • 5. Injecting Complex Types
    • Example of Injecting a List:
  • 6. Injecting Values into Constructor Parameters
    • Example of Constructor Injection:
• Practical Example
  • application.properties:
  • Spring Bean:
  • Running the Application:
• Conclusion

Introduction

In Spring Framework, the @Value annotation is used to inject values directly into fields, methods, or constructor parameters of Spring beans. It allows you to externalize configuration by referencing values from property files, environment variables, or expressions. This annotation is an essential tool for working with dynamic configurations in Spring Boot and Spring applications, enabling developers to keep configuration settings flexible and manageable.

This guide will explain the role of the @Value annotation, how it is used, and provide practical examples to demonstrate its functionality.

Role of the @Value Annotation

1. Injecting Values from Property Files

The most common use of the @Value annotation is to inject values from external configuration files like application.properties or application.yml into Spring beans.

Example: Injecting from application.properties

Now, you can inject these properties into a Spring bean using the @Value annotation.

Example in Java Class:

In this example:

• The @Value annotation is used to inject the values of app.name and app.version from the application.properties file into the appName and appVersion fields.
• When displayInfo() is called, it prints out the app name and version.

2. Injecting Values from Environment Variables

The @Value annotation can also be used to inject environment variables into Spring beans, making it easier to externalize sensitive information (like API keys or database credentials) outside the application code.

Example:

You can inject these values using @Value:

In this case, DB_URL, DB_USERNAME, and DB_PASSWORD are injected from the environment variables, making the application more secure and flexible.

3. Injecting Values from SpEL Expressions (Spring Expression Language)

The @Value annotation also supports SpEL (Spring Expression Language) expressions. This allows you to perform more complex operations, such as calling methods or performing calculations, while injecting values.

Example of SpEL Expression:

Here, the @Value annotation is used with a SpEL expression #{2 * 3}, and the result (6) is injected into the result field.

4. Providing Default Values

You can specify default values when using the @Value annotation in case a property or environment variable is not available. This is especially useful for handling missing or undefined values gracefully.

Example of Default Value:

In this example, if the app.description property is not defined in the application.properties file, the default value "Default App Description" will be injected into the appDescription field.

5. Injecting Complex Types

While the @Value annotation is typically used with simple types (like strings, integers, or booleans), you can also use it to inject more complex types like lists or maps by providing appropriate configuration.

Example of Injecting a List:

In this example, the @Value annotation splits the app.features property into a list of strings, making it easy to work with collections of data.

6. Injecting Values into Constructor Parameters

The @Value annotation can also be used to inject values into constructor parameters, which is a preferred approach when you want to make your class immutable or when constructor injection is required.

Example of Constructor Injection:

Here, the @Value annotation is used in the constructor to inject values into appName and appVersion.

Practical Example

Let's combine some of these techniques in a practical example for a Spring Boot application.

application.properties:

Spring Bean:

Running the Application:

When the application starts, the values from application.properties will be injected into the appName, appVersion, and appDescription fields.

Conclusion

The @Value annotation is a powerful tool in the Spring Framework for injecting externalized configuration into Spring beans. Whether you're retrieving values from property files, environment variables, or using Spring Expression Language (SpEL) for more advanced expressions, the @Value annotation simplifies managing and externalizing configuration in a Spring Boot application. By providing default values and supporting complex types like lists and maps, the @Value annotation enhances the flexibility and scalability of your Spring-based applications.