{"id":404,"date":"2026-09-14T17:50:31","date_gmt":"2026-09-14T09:50:31","guid":{"rendered":"http:\/\/www.tusuamaylocnuoc.com\/blog\/?p=404"},"modified":"2026-09-14T17:50:31","modified_gmt":"2026-09-14T09:50:31","slug":"what-is-the-difference-between-value-and-configurationproperties-in-spring-4f00-75b1a8","status":"publish","type":"post","link":"http:\/\/www.tusuamaylocnuoc.com\/blog\/2026\/09\/14\/what-is-the-difference-between-value-and-configurationproperties-in-spring-4f00-75b1a8\/","title":{"rendered":"What is the difference between @Value and @ConfigurationProperties in Spring?"},"content":{"rendered":"

Hey there! As a Spring vendor, I often get asked about the differences between @Value<\/code> and @ConfigurationProperties<\/code> in Spring. These two annotations might seem similar at first glance, but they have some key distinctions that can make a big difference in how you manage your application’s configuration. So, let’s dive in and explore what sets them apart. Spring<\/a><\/p>\n

<\/p>\n

Basics of @Value<\/h3>\n

First up, let’s talk about @Value<\/code>. This is a simple yet powerful annotation that’s been around in Spring for a while. You can use it to inject values into your Spring beans from properties files, environment variables, or even SpEL (Spring Expression Language) expressions.<\/p>\n

Here’s a quick example. Say you have a application.properties<\/code> file with a property like this:<\/p>\n

app.name=My Awesome Spring App\n<\/code><\/pre>\n
And you want to inject this value into a bean. You can do it like this:<\/p>\n
import org.springframework.beans.factory.annotation.Value;\nimport org.springframework.stereotype.Component;\n\n@Component\npublic class MyAppConfig {\n    @Value("${app.name}")\n    private String appName;\n\n    public String getAppName() {\n        return appName;\n    }\n}\n<\/code><\/pre>\n
In this example, the @Value<\/code> annotation is used to inject the value of the app.name<\/code> property into the appName<\/code> field of the MyAppConfig<\/code> bean. It’s a straightforward way to get a single property value into your bean.<\/p>\n
One cool thing about @Value<\/code> is that you can use SpEL expressions. For instance, if you want to default a value if the property is not set, you can do something like this:<\/p>\n
@Value("${app.description:No description available}")\nprivate String appDescription;\n<\/code><\/pre>\n
Here, if the app.description<\/code> property is not defined in the properties file, the appDescription<\/code> field will be set to "No description available".<\/p>\n
Basics of @ConfigurationProperties<\/h3>\n
Now, let’s move on to @ConfigurationProperties<\/code>. This annotation is a bit more advanced and is designed to bind a group of related properties to a single bean. It’s great for managing complex configurations.<\/p>\n
Let’s say you have a set of properties for a database connection in your application.properties<\/code> file:<\/p>\n
db.url=jdbc:mysql:\/\/localhost:3306\/mydb\ndb.username=root\ndb.password=secret\n<\/code><\/pre>\n
You can create a bean to hold these properties like this:<\/p>\n
import org.springframework.boot.context.properties.ConfigurationProperties;\nimport org.springframework.stereotype.Component;\n\n@Component\n@ConfigurationProperties(prefix = "db")\npublic class DatabaseConfig {\n    private String url;\n    private String username;\n    private String password;\n\n    \/\/ Getters and setters\n    public String getUrl() {\n        return url;\n    }\n\n    public void setUrl(String url) {\n        this.url = url;\n    }\n\n    public String getUsername() {\n        return username;\n    }\n\n    public void setUsername(String username) {\n        this.username = username;\n    }\n\n    public String getPassword() {\n        return password;\n    }\n\n    public void setPassword(String password) {\n        this.password = password;\n    }\n}\n<\/code><\/pre>\n
The @ConfigurationProperties<\/code> annotation with the prefix<\/code> attribute tells Spring to bind all properties starting with db<\/code> to the fields of the DatabaseConfig<\/code> bean. Notice that you need to have getters and setters for the fields for this to work.<\/p>\n
Key Differences<\/h3>\n
1. Scope and Purpose<\/h4>\n
The main difference between @Value<\/code> and @ConfigurationProperties<\/code> lies in their scope and purpose. @Value<\/code> is mainly used for injecting single property values. It’s great for getting a specific value into a bean, like a simple configuration parameter or a constant.<\/p>\n
On the other hand, @ConfigurationProperties<\/code> is designed for handling groups of related properties. It allows you to organize your configuration into logical units, which can make your code more modular and easier to manage, especially for large applications with complex configurations.<\/p>\n
2. Type Safety<\/h4>\n
@ConfigurationProperties<\/code> provides better type safety compared to @Value<\/code>. When you use @ConfigurationProperties<\/code>, Spring will automatically convert the property values to the appropriate types based on the field types in your bean. For example, if you have an int<\/code> field in your @ConfigurationProperties<\/code> bean, Spring will try to convert the property value to an integer.<\/p>\n
With @Value<\/code>, you are more responsible for handling type conversions yourself. You can use SpEL functions for some conversions, but it can be a bit more error-prone.<\/p>\n
3. Property Naming<\/h4>\n
@ConfigurationProperties<\/code> is more flexible when it comes to property naming. It supports different naming conventions, such as camelCase, kebab-case, and snake_case. For example, the properties db.url<\/code>, db-username<\/code>, and db_password<\/code> can all be mapped to the appropriate fields in a @ConfigurationProperties<\/code> bean.<\/p>\n
@Value<\/code> uses the exact property name as you specify in the annotation. So, you need to be more precise with the naming when using @Value<\/code>.<\/p>\n
4. Configuration Binding<\/h4>\n
With @ConfigurationProperties<\/code>, Spring automatically binds all the properties that match the prefix to the bean. You don’t have to specify each property individually. This makes it easier to manage a large number of related properties.<\/p>\n
In contrast, @Value<\/code> requires you to explicitly specify each property you want to inject. This can be cumbersome if you have a lot of properties to deal with.<\/p>\n
Use Cases<\/h3>\n
When to Use @Value<\/h4>\n