How can I inject a property value into a Spring Bean which was configured using annotations?

java

spring-configuration

property-injection

spel-expressions

byAnton Shumikhin·Dec 22, 2024

Inject values into a Spring-managed bean by using the @Value with property placeholders. Add @Component to your class, and apply @Value("${property.key}") directly onto the target field.

@Component
public class MyBean {
    
    @Value("${my.property}")
    private String propertyValue;
    // This property has more injections than a sick man in a hospital! 😄
}

Be sure my.property exists in your properties file, or specify a PropertySource to externalize the configuration.

@Configuration
@PropertySource("classpath:custom.properties")
public class AppConfig {
    //Properties party happening here! 🎉
}

Remember to double-check if your naming matches in both your annotation and properties file to avoid any misconfiguration.

Got XML-phobia? Inject properties in Java configuration

For non-XML configuration, instantiate a PropertySourcesPlaceholderConfigurer directly in a @Configuration class to parse the properties file:

@Bean
public static PropertySourcesPlaceholderConfigurer propertyConfigInDev() {
    // Spring's favorite: Brewing Java, not XML! ☕
    return new PropertySourcesPlaceholderConfigurer();
}

Injecting properties: No longer a black magic 👀

Say 'bye-bye' to XML configurations:

@Component
public class MyService {

    @Value("#{beanName.someProperty}")
    // Hiring Harry Potter to sneak this property in our bean!
    private String someBeanProperty;
}

Spicing things up with SpEL expressions 🔥

The SpEL (Spring Expression Language) provides you with the flexibility for more dynamic expressions:

@Value("#{T(java.lang.Math).random() * 100}")
// Let's inject a dash of randomness here!
private double randomValue;

Because life is easier with IntelliJ IDEA! 💻

By offering direct navigation to property definitions, IntelliJ becomes a lifesaver for developers.

Knowledge is power 💡: Get hands-on Spring's official docs

Stay updated with the latest best practices for property injection- straight from the horse's mouth!

Common headaches and how to ease them 💊

Even though @Value makes things simpler, some issues can still stunt the process:

Misnamed Properties – Unnoticeable typos can wreak havoc. Scrutinize your property keys and placeholders!
Profiles Gone Wrong – In case of using Spring profiles, ensure you're referring to the correct profile properties.
The Missing Property Source – Remember to declare @PropertySource or define a PropertySourcePlaceholderConfigurer, otherwise Spring will be left gawking at nowhere for properties.

What's hotter in Modern Spring 🔥

Spring 3 has brought changes that are as welcomed as a long-awaited Spring season:

No more code bloat – With @Value, say 'good riddance' to repetitive getters and setters cluttering your beans.
More organized properties – The Environment abstraction unifies property management across various profiles and sources.

Property Injection like a Pro 💪

Immutable is beautiful – Construction injection adds immutability and makes unit testing a breeze.
Environment vs. @Value – For dynamic property resolution and type-safety, consider using the Environment API.
Shoo away Magic Strings! – Offload your property keys to constants to ward off typographical mistakes and chaos at times of key changes.