@Value for property injection in Spring Boot - Step-by-Step Execution

Concept Flow - @Value for property injection

Start Spring Boot App

↓

Read application.properties

↓

Find @Value annotation

↓

Inject property value into field

↓

Use injected value in component

↓

App runs with configured values

Spring Boot reads properties, finds @Value annotations, injects values into fields, then uses them in the app.

Execution Sample

Spring Boot

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

@Component
public class MyComponent {
  @Value("${app.message}")
  private String message;

  public String getMessage() {
    return message;
  }
}

This code injects the 'app.message' property value into the 'message' field of MyComponent.

Execution Table

Step	Action	Property Read	Field Value	Result
1	Start Spring Boot app	-	-	App initializing
2	Load application.properties	app.message=Hello Spring	-	Properties loaded
3	Find @Value on 'message' field	-	-	Prepare to inject
4	Inject 'app.message' value	Hello Spring	message = 'Hello Spring'	Field set
5	Call getMessage()	-	message = 'Hello Spring'	Returns 'Hello Spring'
6	App runs using injected value	-	message = 'Hello Spring'	App uses property value
7	End	-	-	Injection complete

💡 Injection done after reading property and setting field; app uses injected value.

Variable Tracker

Variable	Start	After Injection	Final
message	null	'Hello Spring'	'Hello Spring'

Key Moments - 3 Insights

Why is the 'message' field null before injection?

Before Spring injects the property value (see step 4 in execution_table), the field is null because it has not been set yet.

What happens if the property 'app.message' is missing?

Spring will fail to inject the value at step 4, causing an error unless a default value is provided in @Value or the property is defined.

Can @Value inject values into static fields?

No, @Value cannot inject into static fields because Spring injects instance fields during component creation (see step 4).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'message' after step 4?

A 'Hello Spring'

B null

C "${app.message}"

D Empty string

💡 Hint

Check the 'Field Value' column at step 4 in execution_table.

At which step does Spring read the property from application.properties?

A Step 1

B Step 4

C Step 2

D Step 5

💡 Hint

Look at the 'Property Read' column in execution_table.

If the property 'app.message' is missing, what will happen at step 4?

A Field 'message' is set to null

B Spring throws an error

C Field 'message' is set to empty string

D Spring ignores the field

💡 Hint

Refer to key_moments about missing property behavior.

Concept Snapshot

@Value("${property.name}") injects property values into fields.
Spring reads properties on startup.
Injection happens during component creation.
Fields must be non-static.
Missing properties cause errors unless defaults are set.

Full Transcript

When a Spring Boot app starts, it reads properties from application.properties. It looks for fields annotated with @Value and injects the matching property value into those fields. For example, if a field has @Value("${app.message}"), Spring finds the 'app.message' property and sets the field to that value. Before injection, the field is null. After injection, it holds the property value. If the property is missing, Spring throws an error unless a default is provided. This process happens during component creation, so static fields cannot be injected.