Ebooks

Spring Boot Environment

Spring Boot Environment shows how to read environment variables in Spring Boot. A Spring Boot application can be deployed in a variety of environments and reading environment variables can be helpful in such cases.

Spring is a popular Java application framework and Spring Boot is a next step of evolution of Spring which helps create stand-alone, production-grade Spring based applications with minimal effort.

Environment is an interface representing the environment in which the current application is running. It can be use to get profiles and properties of the application environment.

$ echo %JAVA_HOME%
C:\Users\Jano\AppData\Local\Programs\Java\openjdk-11\

In this sample case, we have a JAVA_HOME environment variable defined.

pom.xml
src
├── main
│   ├── java
│   │   └── com
│   │       └── zetcode
│   │           └── Application.java
│   └── resources
│       ├── application.properties
│       └── logback.xml 
└── test
    └── java

This is the project structure of the Spring Boot application.

pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zetcode</groupId>
    <artifactId>springbootenvironment</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
    </parent>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

This is the Maven build file. The spring-boot-starter is the core starter that includes auto-configuration support, logging, and YAML. The application is packaged into a JAR file.

resources/application.properties
spring.main.banner-mode=off
spring.output.ansi.enabled=ALWAYS
logging.pattern.console=%clr(%d{yy-MM-dd E HH:mm:ss.SSS}){blue} %clr(%-5p) %clr(%logger{0}){blue} %clr(%m){faint}%n

app.name=MyApp

The application.properties file contains application configuration settings. Spring has some built-in application properties and we can create our custom ones. The spring.main.banner-mode property is a Spring built-in property; we turn off the Spring's banner. The next two lines set up logging with colour support. The app.name is our custom property that contains the application name.

resources/logback.xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml" />
    <logger name="org.springframework" level="ERROR"/>
    <logger name="com.zetcode" level="INFO"/>
</configuration>

The application logging is configured in the logback.xml file. We set the level of logging levels. We don't want our output to be cluttered with unnecessary messages. The spring-boot-starter dependency enables logback for logging.

com/zetcode/Application.java
package com.zetcode;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.env.Environment;

@SpringBootApplication
public class Application implements CommandLineRunner {

    private static final Logger logger = LoggerFactory.getLogger(Application.class);

    @Autowired
    private Environment env;

    @Override
    public void run(String... args) throws Exception {

        logger.info("{}", env.getProperty("JAVA_HOME"));
        logger.info("{}", env.getProperty("app.name"));
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

In the Application, we create a bean, call its method and set up the Spring Boot application. The CommandLineRunner interface indicates that a bean should run when it is contained within a SpringApplication. It can be used to create command line applications in Spring Boot.

@SpringBootApplication
public class Application implements CommandLineRunner {

The @SpringBootApplication annotation enables auto-configuration and component scanning.

@Autowired
private Environment env;

We inject the Environment in order to obtain the properties.

logger.info("{}", env.getProperty("JAVA_HOME"));

Here, we retrieve the JAVA_HOME environment variable.

logger.info("{}", env.getProperty("app.name"));

Environment can be used to get the properties from the application.properties file as well: get the app.name property.

$ mvn -q spring-boot:run
...
19-05-23 Thu 18:03:51.558 INFO  Application C:\Users\Jano\AppData\Local\Programs\Java\openjdk-11\
19-05-23 Thu 18:03:51.560 INFO  Application MyApp

We run the application. The -q Maven option turns off Maven messages.

In this tutorial, we have used Spring Environment to read environment variable. You might also be interested in the related tutorials: SpringApplicationBuilder tutorial, Serving static content in Spring Boot, Spring Boot DataSourceBuilder tutorial, Java tutorial, or list all Spring Boot tutorials.