Three simple ways to read properties of spring boot configuration files

Jan 6, 2025

Cowrie

Dev @ Bswen

1. The purpose of this post

In this post, I will demonstrate three simple ways to read properties files into spring boot applications,including the @Value ,@Configuration and @PropertySource annotations.

2. Environments

• springboot
• java 1.8+

3. Way 1: Read from application.properties by @Value annotation

Add these properties to your default configuration file:

src/main/resources/application.properties

info.name=Mike
info.desc=Good boy

Use @Value like this:

src/main/java/com/test/sb1jt/commands/MyCommand.java

package com.test.sb1jt.commands;

import com.test.sb1jt.config.InfoConfig;
import com.test.sb1jt.config.SysConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyCommand implements CommandLineRunner {
    private static Logger logger = LoggerFactory.getLogger(MyCommand.class);

    @Value("${info.name}") //1.Auto configure name property by reading info.name from application.properties
    private String name;

    @Value("${info.desc}") //2.Auto configure desc property by reading info.desc from application.properties
    private String desc;

    @Override
    public void run(String... strings) throws Exception {
        logger.info("MyCommand run");

        logger.info("name is {},desc is {}",name,desc); //3. print the name and desc
    }
}

Run the code ,we get this:

2019-05-23 12:45:58.827  INFO 31595 --- [           main] com.test.sb1jt.commands.MyCommand        : name is Mike,desc is Good boy

What is @Value in Spring Boot?

In Spring Boot, @Value is an annotation used to inject values into fields, methods, or constructor parameters from external property sources such as application.properties, application.yml, or environment variables. This allows Spring to provide dynamic configuration values to your beans at runtime.

4. Way 2: Read from application.properties by @ConfigurationProperties annotation

Instead of @Value annotion, you can use @ConfigurationProperties, which can read some specific prefixed properties from your application.properties to your class properties.

Add these properties to your spring boot application.properties:

src/main/resources/application.properties

info.name=Mike
info.desc=Good boy

Add a class which use @ConfigurationProperties like this:

src/main/java/com/test/sb1jt/config/InfoConfig.java

package com.test.sb1jt.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "info")
public class InfoConfig {
    private String name; // info.name mapped to this property
    private String desc; // info.desc mapped to this property

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

Then print properties like this:

src/main/java/com/test/sb1jt/commands/MyCommand.java

package com.test.sb1jt.commands;

import com.test.sb1jt.config.InfoConfig;
import com.test.sb1jt.config.SysConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import com.test.sb1jt.config.InfoConfig;

@Component
public class MyCommand implements CommandLineRunner {
    private static Logger logger = LoggerFactory.getLogger(MyCommand.class);

    @Autowired
    private InfoConfig infoConfig;

    @Override
    public void run(String... strings) throws Exception {
        logger.info("MyCommand run");

        logger.info("infoconfig name is {},desc is {}",infoConfig.getName(),
                infoConfig.getDesc());
    }
}

Run the code ,we get this:

2019-05-23 12:45:58.827  INFO 31595 --- [           main] com.test.sb1jt.commands.MyCommand        : infoconfig name is Mike,desc is Good boy

What is @ConfigurationProperties in Spring Boot?

In Spring Boot, @ConfigurationProperties is an annotation used to bind a group of related configuration properties to a Java bean. This is a more structured and type-safe way of working with external configuration (such as application.properties or application.yml) compared to @Value, especially when dealing with complex or grouped configurations.

Key Differences Between @Value and @ConfigurationProperties: @Value is used for injecting individual properties, typically one at a time. @ConfigurationProperties is used to bind an entire group of related properties to a POJO (Plain Old Java Object). It allows you to group configuration values into one class, making it easier to manage complex configurations.

5. Way 3: Read from your custom xxx.properties by @ProperySource annotation

By reading previous sections, you can see that by using @Value or @ConfigurationProperties, it’s easy to read properties in springboot’s default application.properties, but what should we do if we want read properties from a custom properties file?

According to this document,Spring provides @PropertySource annotation to read custom file properties.

Create a new file named sysconfig.properties in src/main/resources/ , add these properties to it:

src/main/resources/sysconfig.properties

sysname = BDS
sysdesc = Big data system

Create a new class to use the @PropertySource like this:

package com.test.sb1jt.config;

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

@Component
@PropertySource(value={"sysconfig.properties"}) //read from your custom src/main/resources/sysconfig.properties
public class SysConfig {
    @Value("${sysname}") // mapping from sysname to this property
    private String sysName;

    @Value("${sysdesc}") // mapping from sysdesc to this property
    private String sysDesc;

    public String getSysName() {
        return sysname;
    }

    public void setSysName(String sysName) {
        this.sysName = sysName;
    }

    public String getSysDesc() {
        return sysDesc;
    }

    public void setSysDesc(String sysDesc) {
        this.sysDesc = sysDesc;
    }
}

Print the custom properties like this:

package com.test.sb1jt.commands;

import com.test.sb1jt.config.InfoConfig;
import com.test.sb1jt.config.SysConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyCommand implements CommandLineRunner {
    private static Logger logger = LoggerFactory.getLogger(MyCommand.class);

    @Autowired
    private SysConfig sysConfig; //inject the sysConfig instance

    @Override
    public void run(String... strings) throws Exception {
        logger.info("MyCommand run");

        logger.info("sysconfig sysname is {},sysdesc is {}",
                sysConfig.getSysName(),sysConfig.getSysDesc());
    }
}

Run the code ,we get this:

2019-05-23 12:45:58.827  INFO 31595 --- [           main] com.test.sb1jt.commands.MyCommand        : sysconfig sysname is BDS,sysdesc is Big data system

6. Conclusion

You can use @Value ,@Configuration to read default application.properties or use the @PropertySource in your custom properties file in SpringBoot apps.

Final Words + More Resources

My intention with this article was to help others who might be considering solving such a problem. So I hope that’s been the case here. If you still have any questions, don’t hesitate to ask me by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

• 👨‍💻 Spring Boot properties and configuration
• 👨‍💻 Spring Boot externalized configuration

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Tags:

• springboot

How to resolve IllegalArgumentException Could not resolve placeholder when using @Value in Spring Boot application

How to resolve 502 bad gateway error when using proxy_pass in Nginx and Tomcat?