Mastering SpEL: Using @Value and Expression Language in Spring

7 min readSep 11, 2023

Introduction

Spring is one of the most popular frameworks in the Java ecosystem. One of its powerful features is the Spring Expression Language (SpEL). SpEL is an expression language that supports querying and manipulating objects at runtime. Whether you’re new to Spring or have been using it for a while, understanding SpEL and its integration can be invaluable. In this post, we will delve deep into SpEL and demonstrate how to use the @Value annotation and Expression Language in the Spring framework.

Introduction to SpEL

The Spring Expression Language, popularly known as SpEL, is a core component of the Spring framework, introduced in Spring 3.0. At its heart, SpEL is a powerful expression language designed specifically for querying and manipulating an object graph at runtime. However, its strength lies not just in its ability to manage object graphs, but also in its seamless integration with the broader Spring ecosystem.

For those familiar with other expression languages such as OGNL (Object-Graph Navigation Language) or even JavaScript’s way of dealing with object properties, SpEL’s syntax might look familiar. But, it comes with its own unique features tailored for Spring’s environment.

What sets SpEL apart?

Dynamic Nature: Unlike static languages where the structure is determined at compile time, SpEL is dynamic. It evaluates expressions in real-time, reacting to the current state of the application.
Integration with Spring Components: Whether it’s fetching a value from application properties, accessing beans, or even making decisions within Spring Security, SpEL can be found almost everywhere in the Spring ecosystem.
Safe Navigation: SpEL provides safe navigation to avoid null pointers. For instance, if you’ve ever been afraid of a NullPointerException, you can use SpEL's safe navigation operator to gracefully handle potential null values.
Extensible: Just as Spring is known for its extensibility, SpEL can be extended to add custom functions or new types of property accessors, making it adaptable to specific project needs.

Here’s a taste of how a simple SpEL expression might look:

"Hello " + world.name

In this expression, if the object world has a property name with a value "Spring", the entire expression would evaluate to "Hello Spring". This is a basic example, but as we journey through this article, you'll see how SpEL can be employed to handle far more complex operations efficiently.

Basic SpEL Syntax

Understanding the foundational syntax of SpEL is crucial before diving deeper into its more advanced features. The SpEL syntax is designed to be concise yet powerful, providing expressive ways to access and manipulate data. Let’s break down some of the essential elements:

Literals

These are static values within SpEL expressions.

Strings: Enclosed in single or double quotes. E.g., 'Hello' or "World".
Numbers: Represented as-is. E.g., 10, 3.142, or 0x7F (hexadecimal).
Booleans: Use true or false.

Properties Access

This is akin to reading an object’s property in many object-oriented languages.

Dot Notation: Used to access properties of an object. E.g., person.name would fetch the name property of the person object.

Array, List, and Map Access

SpEL provides a concise way to access elements within arrays, lists, and maps.

Array and List: Use square brackets with an index. E.g., array[0] gets the first element of the array, while list[1] accesses the second element of a list.
Map: Also accessed using square brackets but with the key. E.g., map['username'] would fetch the value associated with the key 'username'.

Method Invocation

SpEL allows for method calls directly within expressions.

E.g., person.getName() would invoke the getName() method on the person object.

Operators

Operators are symbols that perform specific operations on one or more operands.

Relational: Such as == (equals), != (not equals), < (less than), > (greater than), <= (less than or equal to), and >= (greater than or equal to).
Logical: Including and, or, and not.
Mathematical: Covering basic operations like +, -, *, /, % (modulus), and ^ (exponentiation).
Safe Navigation Operator (?.): Returns null instead of throwing an exception if the property or object is null. E.g., person?.name would be null if person is null, preventing a NullPointerException.

Type Identifier (`T`)

Used to reference Java classes, especially when calling static methods or accessing static fields.

E.g., T(java.lang.Math).PI would fetch the value of the PI constant from Java's Math class.

Constructor Invocation

SpEL also supports the creation of new objects using the new keyword.

E.g., new String('Hello World') creates a new string instance.

This fundamental syntax provides the backbone of all the operations you’ll perform using SpEL. By understanding these foundational elements, you are better equipped to harness the full power of SpEL, whether it’s for simple property fetches or complex runtime evaluations. As we delve further, you’ll see how these basics can be woven together to create dynamic, flexible, and powerful expressions tailored to your application’s needs.

Using @Value with SpEL

The @Value annotation is a staple in the world of Spring, allowing developers to inject values from various sources into Spring-managed beans. When combined with SpEL, @Value becomes an even more potent tool, providing dynamic injection based on real-time evaluations. Here's a closer look:

Injecting Simple Property Values

At its most basic, @Value is employed to inject static values or properties from a properties file.

@Value("${app.name}")
private String appName;

In the example above, if you have a property named app.name=SpringMaster in your properties file, the appName field would be injected with the value "SpringMaster".

Dynamic Property Injection using SpEL

SpEL’s dynamic nature becomes evident when integrated with @Value.

@Value("#{systemProperties['user.home']}")
private String userHome;

This example demonstrates the injection of the system property ‘user.home’ into the userHome field. With SpEL, you're not restricted to just the Spring environment's properties; you can pull from system properties, environment variables, and other accessible data sources.

Complex Expressions with @Value

One of the strengths of SpEL is its ability to deal with more intricate expressions, allowing for deeper logic and access patterns.

@Value("#{appConfig.features[0]}")
private String firstFeature;

Here, imagine you have a bean named appConfig with a features property, which is a list. This expression would extract the first feature from that list and inject it into the firstFeature field.

Conditional Expressions

SpEL can also evaluate conditional expressions, providing the flexibility to set values based on certain conditions.

@Value("#{appConfig.featureFlag ? 'Feature is Enabled' : 'Feature is Disabled'}")
private String featureStatusMessage;

In this example, if the featureFlag property in the appConfig bean is true, the featureStatusMessage field will be set to "Feature is Enabled". Otherwise, it will be set to "Feature is Disabled".

Default Values Using the Elvis Operator

The Elvis operator (?:) is particularly handy for providing default values.

@Value("#{appConfig.optionalFeatureName ?: 'DefaultFeature'}")
private String featureName;

If optionalFeatureName is null or not set, the featureName field will be injected with the value "DefaultFeature".

Integrating SpEL with @Value exemplifies the Spring framework's goal of flexibility and adaptability. By leveraging this combination, developers can achieve dynamic property injection, adapting the behavior and configuration of beans based on real-time conditions and configurations. The dynamic nature of SpEL combined with the declarative power of @Value provides a robust mechanism to cater to the varied and evolving needs of modern applications.

Advanced Usage and Tips

As with any powerful tool, the depth of SpEL’s capabilities extends far beyond the basics. While the foundational syntax and the use of @Value with SpEL cover many everyday use cases, the advanced features of SpEL unlock even greater potential. Let's explore some of these nuanced capabilities and best practices:

Ternary Operator

SpEL supports the ternary operator, which can be especially useful for conditional checks within expressions.

@Value("#{appConfig.featureThreshold > 100 ? 'High' : 'Low'}")
private String featureIntensity;

This would check if featureThreshold is greater than 100, setting featureIntensity to "High" or "Low" accordingly.

Regular Expressions

You can integrate regex for pattern matching within SpEL expressions.

@Value("#{appConfig.featureName matches '^[A-Z].*'}")
private boolean startsWithCapitalLetter;

Here, the startsWithCapitalLetter will be true if featureName starts with a capital letter.

Collection Projections

Projections are a way to transform collections. It’s akin to mapping functions in functional programming.

@Value("#{appConfig.features.?[active == true]}")
private List<String> activeFeatures;

This would filter all the active features from the features list in appConfig.

Static Class References

Beyond the earlier mentioned type references for constants, SpEL can invoke static methods.

@Value("#{T(java.lang.Math).max(appConfig.minValue, 100)}")
private int maxFeatureValue;

This takes the maximum value between appConfig.minValue and 100.

Expression Templates

Sometimes, you might want to combine static text with evaluated expressions. SpEL uses #{} for its expressions but you can combine them with ${} (property placeholders) for such templates.

@Value("Features of the application: ${app.name} are #{appConfig.features}")
private String appFeatureSummary;

Defining Variables within Expressions

SpEL allows for the definition of local variables within the expression, providing even greater flexibility.

@Value("#{systemProperties['user.region'] == 'US' ? (currency=T(java.util.Currency).getInstance('USD')) : currency}")
private Currency appCurrency;

Avoid Overcomplication

A vital tip to remember is that while SpEL is powerful, it’s crucial not to overcomplicate configurations. If an expression becomes too complex, it might be better to move that logic to Java code for clarity.

Performance Considerations

Dynamic evaluations come with a cost. Repeated evaluations of complex SpEL expressions can impact performance. Cache results where possible, especially if the underlying data doesn’t change frequently.

Embracing these advanced aspects of SpEL ensures developers can handle even the most complex scenarios with ease. However, always remember the balance: use SpEL’s power wisely and maintain readability. When used judiciously, SpEL’s advanced features can make your Spring application more adaptable and efficient.

Conclusion

SpEL offers a powerful way to manipulate and query objects at runtime in the Spring framework. The @Value annotation provides an easy and concise way to integrate SpEL into your Spring applications, allowing for dynamic value injection based on expressions. Whether it's accessing properties, invoking methods, or integrating with other parts of your application, SpEL has you covered. By mastering the use of @Value and SpEL, you can make your Spring applications more flexible and dynamic.