Spring Boot Environment
last modified July 6, 2020
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.
<?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.
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.
<?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.
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.