1. Overview

In this quick tutorial, 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.

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 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:

private String systemValue;

Default values can be provided for properties that might not be defined. Here, 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. 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 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:

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. 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:

private Integer someBeanValue;

We can manipulate properties to get a List of values, here, 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 that we also provide a default value in case the property isn’t found.

7. Using @Value With Setter Injection

Analogous to the constructor injection, we can also use @Value with setter injection.

Let’s take a look:

public class CollectionProvider {

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

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

    // standard getter

We use the SpEL expression to inject a list of values into the setValues method.

8. Using @Value With Records

Java 14 introduced records to facilitate the creation of an immutable class. The Spring framework supports @Value for record injection since version 6.0.6:

public record PriorityRecord(@Value("${priority:normal}") String priority) {}

Here, we inject the value directly into the record’s constructor.

9. Conclusion

In this article, 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 the GitHub project.

Course – LS (cat=Spring)

Get started with Spring and Spring Boot, through the Learn Spring course:

res – REST with Spring (eBook) (everywhere)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.