Sunday, August 27, 2023

What is @Value Annotation in Spring? Example Tutorial and difference between $ and #

Hello guys if you want to learn about @Value Annotation in Spring Framework like how to use it or when to use it then you have come to the right place. Earlier, I have talked about @Value annotation when I shared 10 essential Spring Framework annotations and in this article, we are going to take an in-depth look at a Spring @Value annotation. We start our understanding with the term and then, move on to find the difference between $ and #. The @Value annotation is essential to the Spring Framework's ability to inject values into Spring beans from outside sources. Developers can externalize configuration with this annotation, which increases the flexibility and configurability of their work. 

If you have no idea about what is @Value annotation and never used it before then don't worry, the @Value annotation will be thoroughly discussed in this article, along with its use and a comprehensive example of retrieving values from an external resource.

What is @Value Annotation in Spring?

One of the Spring Framework's powerful attributes is the @Value annotation. It makes it possible to inject values into beans from a variety of external sources, including system properties, environment variables, and property files

This annotation encourages the separation of configuration from code and makes it easier for your application to access configuration variables. 

How to use @Value Annotation in Spring and difference between $ and #

How to use @Value annotation?

Before we jump into the example program, let’s find understand how can we use @Value annotation. To use @Value, we need to take following steps given below:

Step1: Add the @Value annotation
In your Spring bean class, annotate a field, setter function, or constructor parameter with @Value. Spring is instructed to inject a value into that field or parameter using this annotation.

Step2: Define the value expression
These expressions are capable of retrieving data from environment variables, system variables, property files, and even SpEL-synthesized methods.

Example: Accessing values from external file/resource

To demonstrate how the @Value annotation may be used to obtain values from an external resource, such as a property file, let's go through a complete example.

1) First, make a property file.

Create a property file called first, then add it to your Spring application's classpath. Include the key-value pair shown below in the file: Awesome App

2) Define the Bean

Next, make the MyBean Spring bean class a managed bean by Spring by annotating it with @Component. The value from the property file will be injected by adding a private field and annotating it with @Value.


public class MyBean {


    private String appName;

    // Getter and Setter for appName


3) Accessing the value

Now that the value has been injected from the property file, it can be accessed in your application's appName field.


public class MyApp {


    private MyBean myBean;

    public void printAppName() {

        System.out.println("Application Name: " + myBean.getAppName());



Difference between $ and # in context of @Value annotation

The dollar sign ($) and the hash symbol (#) have different meanings and functions when used in conjunction with the @Value annotation. Let's examine how they differ from one another:

1) Dollar sign ($)
The @Value annotation uses the dollar sign to evaluate straightforward value expressions. It immediately retrieves the value from the source that is given, like a property file. The dollar sign expression has the following salient features:

Syntax: $ (expression)

From property files or other property sources, it retrieves the value associated with the given key.

Direct value substitution.

It doesn't support calling methods or performing complicated operations.


The value of the key is retrieved from a property file using the syntax @Value("$").

2) Hash Symbol (#)
The @Value annotation uses the hash symbol for more complex expressions written in the Spring Expression Language (SpEL). Dynamic evaluations, accessing beans, calling methods, and more are all possible with SpEL. Here are some of the hash symbol expression's salient features:

Syntax: #{expression}

• The Spring Expression Language (SpEL) is used to evaluate the expression.

• Numerous operations are supported by it, including as mathematical computations, logical operations, method calls, and bean access.

• Complex expressions and dynamic evaluations are both supported.

• It can call methods, access system properties, environment variables, or obtain values from property files.


@Value("#myBean.someMethod()") uses SpEL to call the myBean bean's someMethod() method.

In conclusion, the hash symbol expression (#) is used for more sophisticated and dynamic evaluations using SpEL, allowing for complex expressions, method invocations, and accessing various elements of the Spring application context. The dollar sign expression ($) is used for straightforward value injection, primarily retrieving values from property files.

Let’s take another example to understand it. 

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

import org.springframework.stereotype.Component;


public class ValueExpressionDemo {

    // $ expression: Simple value injection


    private String simpleValue;

    // # expression: SpEL evaluation

    @Value("#{T(java.lang.Math).random() * 100}")

    private double calculatedValue;

    // Getter and Setter methods

    public String getSimpleValue() {

        return simpleValue;


    public void setSimpleValue(String simpleValue) {

        this.simpleValue = simpleValue;


    public double getCalculatedValue() {

        return calculatedValue;


    public void setCalculatedValue(double calculatedValue) {

        this.calculatedValue = calculatedValue;



In the above example, we have a ValueExpressionDemo class with two fields annotated with @Value: 

1. $ Expression Example: The simpleValue field demonstrates the usage of the $ expression. It retrieves the value of the key from a property file using the $ expression.

2. # Expression Example: The calculatedValue field showcases the usage of the # expression. It utilizes the Spring Expression Language (SpEL) within the @Value annotation to evaluate the expression T(java.lang.Math).random() * 100, which generates a random number between 0 and 100.

By combining these two different expression types, we can inject simple values from property files using $ expressions, as well as perform complex evaluations and operations using # expressions with SpEL.

Remember to provide appropriate values in the associated property file for the key to ensure successful value injection.

Example # 02

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

import org.springframework.stereotype.Component;


public class ValueAnnotationDemo {

    // Simple value injection from property file


    private String myProperty;

    // Injecting a default value if the property is not found

    @Value("${ Value}")

    private String defaultValue;

    // Injecting values from system properties


    private String javaHome;

    // Injecting values from environment variables


    private String path;

    // Injecting values using SpEL expression


    private String dynamicValue;

    // Injecting values from a nested property


    private String nestedValue;

    // Injecting values as an array


    private String[] arrayValues;

    // Injecting values as a list


    private List<String> listValues;

    // Getter and Setter methods for each field

    public String getMyProperty() {

        return myProperty;


    public void setMyProperty(String myProperty) {

        this.myProperty = myProperty;


    public String getDefaultValue() {

        return defaultValue;


    public void setDefaultValue(String defaultValue) {

        this.defaultValue = defaultValue;


    public String getJavaHome() {

        return javaHome;


    public void setJavaHome(String javaHome) {

        this.javaHome = javaHome;


    public String getPath() {

        return path;


    public void setPath(String path) {

        this.path = path;


    public String getDynamicValue() {

        return dynamicValue;


    public void setDynamicValue(String dynamicValue) {

        this.dynamicValue = dynamicValue;


    public String getNestedValue() {

        return nestedValue;


    public void setNestedValue(String nestedValue) {

        this.nestedValue = nestedValue;


    public String[] getArrayValues() {

        return arrayValues;


    public void setArrayValues(String[] arrayValues) {

        this.arrayValues = arrayValues;


    public List<String> getListValues() {

        return listValues;


    public void setListValues(List<String> listValues) {

        this.listValues = listValues;



We show several approaches to use the @Value annotation in Spring in the programme above:

1. simple property file value injection: The value of the key from a property file is entered into the myProperty field.

2. Injection of default values: If the given default value is not discovered, the key value from a property file is used to fill the defaultValue field.

3. Value injection from system properties: The value of the java.home system property is entered into the javaHome field.

4. The path field is filled with the value of the PATH environment variable thanks to value injection from environment variables.

5. Using a SpEL expression for value injection: By calling the someMethod() method of a bean with the name myBean, the dynamicValue field is filled with values.

6. Value injection from a nested property: The value of the nestedValue key, which is a nested property in a property file, is filled into the nestedValue field.

7. arrayValues field is filled with the array's values during value injection.values using a property file's key. The values are handled like a string array.

8. List of value injections The values of the list are entered into the listValues field.values using a property file's key. A comma is used to separate the values, which are then stored as a list of strings.

Developers can populate the @Value annotation in Spring beans based on their unique requirements and external configurations by utilizing these several ways.

Here is file, World! Value

# Array values
array.values=Value 1,Value 2,Value 3

# List values
list.values=Value A,Value B,Value C

That's all about what is @Value annotation in Spring Framework and how to use it. Hope this article give you a comprehensive knowledge of the @Value annotation in Spring and its numerous use cases. You can quickly inject values from outside sources, including property files, system properties, environment variables, and more, by using this annotation.

Simple value injection, default values, system properties, environment variables, and SpEL expressions were some of the methods we looked into for populating the @Value annotation. Additionally, we talked about the difference between $ and # expressions, where $ is used for straightforward value injection while # allows for more sophisticated analyses using SpEL.

The usage of the @Value annotation in Spring has hopefully been made clearer by this post, and I hope it gives you the confidence to use it in your own projects.

Other Java and Spring articles you may like
  • 5 Spring Boot Features Every Java Developer Should Know (features)
  • 7 Courses to learn Microservices for Java developers (courses)
  • 3 Best Practices Java Programmers can learn from Spring (best practices)
  • 10 Things Java Developer should learn(goals)
  • 10 Spring Core Annotations Java Developers should learn (annotations)
  • Spring Boot Integration test example (integration test example)
  • 5 courses to learn Spring Boot and Spring Cloud( courses)
  • 10 Tools Java Developers use in their day-to-day life (tools)
  • Spring Boot + ThyMyleaf project example (thymyleaf example)
  • 15 Spring Boot Interview Questions for Java Programmers (questions)
  • Top 5 Free Courses to learn Spring and Spring Boot (courses)
  • 10 Tips to become a better Java developer (tips)
  • 3 ways to change Tomcat port in Spring Boot (tutorial)
  • 5 Course to Master Spring Boot online(courses)
  • How to post JSON data using Postman? (postman json example)
  • 10 Spring MVC annotations Java developers should learn (annotations)
  • How to test Spring boot application in Java? (spring boot testing example)
  • 10 Advanced Spring Courses for Experienced Programmers (courses)

Thanks for reading this article so far. If you like this Spring Framework @value annotation tutorial. , then please share it with your friends and colleagues. If you have any questions or feedback, then please drop a note.

No comments:

Post a Comment