Why @Value for property injection in Spring Boot? - Purpose & Use Cases

The Big Idea

What if you could change app settings without touching a single line of code?

The Scenario

Imagine you have many settings like database URLs, API keys, or feature flags hardcoded inside your Java classes.

Every time you want to change a setting, you must find the code, edit it, and recompile your app.

The Problem

This manual way is slow and risky because you might forget to update all places or accidentally break something.

It also makes your app less flexible and harder to configure for different environments like testing or production.

The Solution

The @Value annotation lets you inject values from external property files directly into your Spring components.

This means you can change settings without touching the code, just by editing a simple file.

Before vs After

✗ Before

private String apiUrl = "https://old-api.com";

✓ After

@Value("${api.url}")
private String apiUrl;

What It Enables

You can easily manage and change configuration values outside your code, making your app flexible and environment-friendly.

Real Life Example

For example, you can have one API URL for your local machine and a different one for your live server, switching automatically without code changes.

Key Takeaways

Hardcoding settings makes apps rigid and error-prone.

@Value injects external properties into your code cleanly.

This improves flexibility, safety, and ease of configuration.

Practice

1. What is the main purpose of the @Value annotation in Spring Boot?

easy

A. To create database connections

B. To define a new Spring bean

C. To handle HTTP requests

D. To inject values from configuration files into Spring beans

Solution

1. Step 1: Understand the role of @Value

   @Value is used to inject configuration values like those from application.properties into Spring beans.

2. Step 2: Compare with other options

   Defining beans, handling HTTP requests, and database connections are done by other annotations or classes, not @Value.

3. Final Answer:

   To inject values from configuration files into Spring beans -> Option D

4. Quick Check:

   @Value injects config values = A [OK]

Hint: Remember: @Value pulls config values into your code [OK]

Common Mistakes:

• Confusing @Value with @Bean or @Autowired
• Thinking @Value handles HTTP or DB tasks
• Ignoring that @Value reads from properties

2. Which of the following is the correct syntax to inject a property named app.name using @Value?

easy

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

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

C. @Value("app.name") private String appName;

D. @Value(app.name) private String appName;

Solution

1. Step 1: Recall correct syntax for property injection

   The property key must be inside ${} and the whole expression inside quotes: @Value("${property.key}").

2. Step 2: Check each option

   @Value("${app.name}") private String appName; matches the correct syntax. The other options miss either the quotes around the expression, the ${} delimiters, or use quotes around just the property name.

3. Final Answer:

   @Value("${app.name}") private String appName; -> Option B

4. Quick Check:

   Correct syntax uses ${} inside quotes = D [OK]

Hint: Use @Value("${property.key}") with quotes and ${} [OK]

Common Mistakes:

• Omitting quotes around the expression
• Forgetting the ${} around the property key
• Using plain property name without ${}

3. Given the property server.port=8080 in application.properties, what will be the output of this Spring component?

public class ServerConfig {
  @Value("${server.port}")
  private int port;

  public int getPort() {
    return port;
  }
}

// In main method:
ServerConfig config = new ServerConfig();
System.out.println(config.getPort());

medium

A. 0

B. 8080

C. null

D. Compilation error

Solution

1. Step 1: Understand Spring bean lifecycle and injection

   Property injection with @Value happens only when Spring creates and manages the bean. Here, ServerConfig is created manually with new, so injection does not happen.

2. Step 2: Check default value of int field

   Since port is a primitive int and not injected, it defaults to 0.

3. Final Answer:

   0 -> Option A

4. Quick Check:

   Manual new means no injection, int defaults to 0 [OK]

Hint: Only Spring-managed beans get @Value injection [OK]

Common Mistakes:

• Assuming @Value works on manually created objects
• Expecting null for primitive int fields
• Ignoring Spring bean lifecycle

4. What is wrong with this code snippet?

@Value("${missing.property}:defaultValue")
private String value;

When missing.property is not defined in properties, the application fails to start with an error.

medium

A. The field must be public for @Value to work

B. The property key must be defined; default values are not supported

C. The default value syntax is incorrect; colon should be inside quotes

D. The @Value annotation cannot be used on String fields

Solution

1. Step 1: Check default value syntax in @Value

   The default value must be inside the quotes as part of the expression: @Value("${property:default}") is correct.

2. Step 2: Identify the error cause

   If the colon is outside quotes or expression is malformed, Spring cannot parse it and throws an error.

3. Final Answer:

   The default value syntax is incorrect; colon should be inside quotes -> Option C

4. Quick Check:

   Default values must be inside ${} quotes [OK]

Hint: Put default after colon inside quotes in @Value [OK]

Common Mistakes:

• Placing colon outside the quotes
• Assuming default values are not supported
• Making fields public unnecessarily

5. You want to inject a list of strings from a property app.modes=dev,prod,test into a Spring bean using @Value. Which approach correctly converts the property into a List<String>?

hard

A. @Value("#{T(java.util.Arrays).asList('${app.modes}'.split(','))}") private List<String> modes;

B. @Value("${app.modes}") private List<String> modes; // Spring auto-converts comma-separated string

C. @Value("${app.modes}") private String[] modes; // Use array instead of List

D. @Value("${app.modes}") private String modes; // Parse manually later

Solution

1. Step 1: Understand property injection for collections

   Spring does not automatically convert comma-separated strings to List<String> with plain @Value.

2. Step 2: Use SpEL expression for conversion

   @Value("#{T(java.util.Arrays).asList('${app.modes}'.split(','))}") private List<String> modes; uses Spring Expression Language (SpEL) to split the string and convert it to a List<String>, which is the correct approach.

3. Final Answer:

   @Value("#{T(java.util.Arrays).asList('${app.modes}'.split(','))}") private List<String> modes; -> Option A

4. Quick Check:

   Use SpEL split and asList for List injection [OK]

Hint: Use SpEL with split and asList to inject List<String> [OK]

Common Mistakes:

• Expecting automatic conversion from String to List
• Using array when List is required without conversion
• Injecting as String and forgetting to parse