Spring Top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:


1. Overview

In this quick article, we're going to have a look at the @Value Spring annotation.

This annotation can be used for injecting values into fields in Spring-managed beans and it can be applied at the field or constructor/method parameter level.

Further reading:

What is a Spring Bean?

A quick and practical explanation of what a Spring Bean is.

Using Spring @Value with Defaults

A quick and practical guide to setting default values when using the @Value annotation in Spring.

2. Setting up the Application

To describe different kinds of usage for this annotation, we need to configure a simple Spring application configuration class.

And naturally, we'll need a properties file to define the values we want to inject with the @Value annotation. And so, we'll first need to define a @PropertySource in our configuration class – with the properties file name.

Let's define the properties file:

value.from.file=Value got from the file

3. Usage Examples

As a basic and mostly useless usage example we can only inject “string value” from the annotation to the field:

@Value("string value")
private String stringValue;

Using the @PropertySource annotation allows us to work with values from properties files with the @Value annotation. In the following example we get “Value got from the file” assigned to the field:

private String valueFromFile;

We can also set the value from system properties with the same syntax. Let's assume that we have defined a system property named systemValue and look at the following sample:

private String systemValue;

Default values can be provided for properties that might not be defined. In this example the value “some default” will be injected:

@Value("${unknown.param:some default}")
private String someDefault;

If the same property is defined as a system property and in the properties file, then the system property would be applied.

Suppose we had a property priority defined as a system property with the value “System property” and defined as something else in the properties file. In the following code the value would be “System property”:

private String prioritySystemProperty;

Sometimes we need to inject a bunch of values. It would be convenient to define them as comma-separated values for the single property in the properties file or as a system property and to inject into an array. In the first section, we defined comma-separated values in the listOfValues of the properties file, so in the following example the array values would be [“A”, “B”, “C”]:

private String[] valuesArray;

4. Advanced Examples with SpEL

We can also use SpEL expressions to get the value. If we have a system property named priority, then its value will be applied to the field in the next example:

private String spelValue;

If we have not defined the system property, then the null value will be assigned. To prevent this, we can provide a default value in the SpEL expression. In the following example, we get “some default” value for the field if the system property is not defined:

@Value("#{systemProperties['unknown'] ?: 'some default'}")
private String spelSomeDefault;

Furthermore, we can use a field value from other beans. Suppose we have a bean named someBean with a field someValue equal to 10. Then 10 will be assigned to the field in this example:

private Integer someBeanValue;

We can manipulate properties to get a List of values. In the following sample, we get a list of string values A, B, and C:

private List<String> valuesList;

5. Using @Value with Maps

We can also use the @Value annotation to inject a Map property.

First, we'll need to define the property in the {key: ‘value' } form in our properties file:

valuesMap={key1: '1', key2: '2', key3: '3'}

Note that the values in the Map must be in single quotes.

Now we can inject this value from the property file as a Map:

private Map<String, Integer> valuesMap;

If we need to get the value of a specific key in the Map, all we have to do is add the key's name in the expression:

private Integer valuesMapKey1;

If we're not sure whether the Map contains a certain key, we should choose a safer expression that will not throw an exception but set the value to null when the key is not found:

private Integer unknownMapKey;

We can also set default values for the properties or keys that might not exist:

@Value("#{${unknownMap : {key1: '1', key2: '2'}}}")
private Map<String, Integer> unknownMap;

@Value("#{${valuesMap}['unknownKey'] ?: 5}")
private Integer unknownMapKeyWithDefaultValue;

Map entries can also be filtered before injection. Let's assume we need to get only those entries whose values are greater than one:

private Map<String, Integer> valuesMapFiltered;

We can also use the @Value annotation to inject all current system properties:

private Map<String, String> systemPropertiesMap;

6. Using @Value with Constructor Injection

When we use the @Value annotation, we're not limited to a field injection. We can also use it together with constructor injection.

Let's see this in practice:

public class PriorityProvider {

    private String priority;

    public PriorityProvider(@Value("${priority:normal}") String priority) {
        this.priority = priority;

    // standard getter

In the above example, we inject a priority directly into our PriorityProvider‘s constructor.

Note, we also provide a default value in case the property isn't found.

7. Using @Value with Setter Injection

Analogously as for the constructor injection, we can also use @Value with setter injection.

Let's take a look at the example:

public class CollectionProvider {

    private List<String> values = new ArrayList<>();

    public void setValues(@Value("#{'${listOfValues}'.split(',')}") List<String> values) {

    // standard getter

In the code above, we use the SpEL expression to inject a list of values into the setValues method.

8. Conclusion

In this quick tutorial, we examined the various possibilities of using the @Value annotation with simple properties defined in the file, with system properties, and with properties calculated with SpEL expressions.

As always the example application is available on GitHub project.

Spring bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

1 Comment
Newest Most Voted
Inline Feedbacks
View all comments
Puneeth Shivalingaiah
Puneeth Shivalingaiah
3 years ago

Good one. Thank You.

Comments are closed on this article!