Read environment variable in SpringBoot

You can do it with the @Value annotation:

@Value("${bar}")
private String myVariable;

You can also use colon to give a default value if not found:

@Value("${bar:default_value}")
private String myVariable;

Here are three "placeholder" syntaxes that work for accessing a system environment variable named MY_SECRET:

@Value("${MY_SECRET:aDefaultValue}")
private String s1;

@Value("#{environment.MY_SECRET}")
private String s2;

@Value("${myApp.mySecretIndirect:aDefaultValue}") // via application property
private String s3;

In the third case, the placeholder references an application property that has been initialized from the system environment in a properties file:

myApp.mySecretIndirect=${MY_SECRET:aDefaultValue}

For @Value to work, it must be used inside a live @Component (or similar). There are extra gochas if you want this to work during unit testing -- see my answer to Why is my Spring @Autowired field null?

Alternatively, you can use the org.springframework.core.env.Environment interface to access environment variables (NOTE: this works only in initialized Spring components):

import org.springframework.core.env.Environment;

@Autowired
private Environment env;

//...

System.out.println(env.getProperty("bar"));

Read more...

There are multiple answers to read the environment in code using @Value hence I am not providing that. Below is the example of using environment variable in application.yml file to provide some external values based on different env.

my-service:
  api-base: ${API_BASE:}
  env: ${ENVIRONMENT:prod}

In the above example, the property configuration will use the evironment variables which could be provided externally during application launch, and they will be replaced in here. It also supports the default value if the env var is not provided, as seen for env

Below is my docker-compose.yaml snippet which is providing these variables.

services:
  my-service:
    environment:
        API_BASE: http://example.com/api/v1
        ENVIRONMENT: ci

Yes, you can. However, most answer didn't mention, the ordering is very important, please check this https://docs.spring.io/spring-boot/docs/1.5.6.RELEASE/reference/html/boot-features-external-config.html

Your OS environment variables will overwrite the value come from Application properties packaged inside your jar (application.properties and YAML variants)., so basically, your environment variables has higher priority.

In rare cases, if you want to access environment parameters in spring main methods ( which is static ) you can must let Spring application build then use the ApplicationContext to access environment . Something like

public static void main(String[] args) {
            
    ApplicationContext applicationContext = new SpringApplicationBuilder(MyApp.class).run(args);
    Environment environment = applicationContext.getEnvironment();
    System.out.println(environment.getProperty("spring.application.name"));
    System.out.println(environment.getProperty("foo.bar"));
            
}

If you are using springboot, simply place the application.properties or application.yml file in src/main/resources/ or src/main/resources/config/ directory. No need to configure anything else, all beans can directly reference properties using @Value.

Here's the simplest example:

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

@Component
public class MyComponent {

    @Value("${my.property}")
    private String myProperty;

    public void printProperty() {
        System.out.println("Property value: " + myProperty);
    }
}

In your application.properties file, add:

my.property=Hello,Harry!

This way, when MyComponent is loaded, myProperty will be injected with the value from the application.properties file.

A way to read properties in Spring Boot is by using the @Value annotation for individual properties or by binding them to a configuration class using @ConfigurationProperties. This allows for easy injection of property values from application.properties or application.yml into your components, services, or beans.

@Value("${creds}")
private String creds;

in application.properties file define

creds=32432432432

it will pick value 324324324

You can place your environment variable in an application.yml/application.properties file and then you can fetch the value using the @Value annotation. But in order to use @Value annotation your class should be a bean and should be annotated with @Component annnotation. You can also provide a default value for the variable.

@Component
@NoArgsConstructor
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class MyClass {
 
@Value("${something.variable:<default-value>}")
private String myEnvVariable;

}
    

You can use it with the @Value annotation for the @Components and @service class.

Sometimes it won't work if it is a normal class.

Example:

@Component
public class Testclass{
    @Value("${MY_SECRET:aDefaultValue}")
    private String test1;

    @Value("#{environment.MY_SECRET}")
    private String test2;

    @Value("${myApp.mySecretIndirect:aDefaultValue}")
    private String test3;

    //to get the properties list which are in "," separated
    @Value("${my.list.of.strings}")
    private List<String> myList;
}

First, you have to define the relevant field information in the properties configuration file, and then use @ value to obtain and use example:

@Value("${abc}")
private String abc;