Log Properties in a Spring Boot Application – Spring Boot应用程序中的日志属性

最后修改: 2022年 10月 27日

1. Overview


Properties are one of the most useful mechanisms provided by Spring Boot. They may be provided from various places such as dedicated properties files, environment variables, etc. Because of that, it’s sometimes useful to find and log specific properties, for example while debugging.

属性是Spring Boot提供的最有用的机制之一。它们可以从不同的地方提供,如专用的属性文件、环境变量等。正因为如此,有时查找和记录特定的属性是很有用的,例如在调试时。

In this short tutorial, we’ll see a few different ways to find and log properties in a Spring Boot application. 

在这个简短的教程中,我们将看到在Spring Boot应用程序中查找和记录属性的几种不同方法。

First, we’ll create a simple test app that we’ll work onThen, we’ll try three different ways to log specific properties.


2. Creating a Test Application


Let’s create a simple app with three custom properties.


We can use Spring Initializr to create a Spring Boot app template. We’ll use Java as the language. We’re free to choose other options such as Java version, project metadata, etc.

我们可以使用Spring Initializr来创建一个Spring Boot应用模板。我们将使用Java作为语言。我们可以自由选择其他选项,如Java版本、项目元数据等。

The next step is to add custom properties to our app. We’ll add those properties to a new application.properties file in src/main/resources:


app.description=${app.name} is a Spring Boot application

3. Logging Properties With Context Refreshed Event


The first way of logging properties in a Spring Boot application is to use Spring Events, especially the org.springframework.context.event.ContextRefreshedEvent class and the corresponding EventListener. We’ll show how to log all available properties and a more detailed version that prints properties only from a specific file.

在Spring Boot应用程序中记录属性的第一种方式是使用Spring Events,特别是org.springframework.context.event.ContextRefreshedEvent类和相应的EventListener。我们将展示如何记录所有可用属性以及仅从特定文件打印属性的更详细版本。

3.1. Logging All Properties


Let’s start with creating a bean and the event listener method:


public class AppContextRefreshedEventPropertiesPrinter {

    public void handleContextRefreshed(ContextRefreshedEvent event) {
        // event handling logic

We annotate the event listener method with the org.springframework.context.event.EventListener annotation. Spring invokes the annotated method when ContextRefreshedEvent occurs.


The next step is to get an instance of org.springframework.core.env.ConfigurableEnvironment interface from the triggered event. The ConfigurableEnvironment interface provides a useful method, getPropertySources(), that we’ll use to get a list of all property sources, such as environment, JVM or property file variables:


ConfigurableEnvironment env = (ConfigurableEnvironment) event.getApplicationContext().getEnvironment();

Now let’s see how we can use it to print all properties, not only from the application.properties file, but also from environment, JVM variables and many more:


    .filter(ps -> ps instanceof MapPropertySource)
    .map(ps -> ((MapPropertySource) ps).getSource().keySet())
    .forEach(key -> LOGGER.info("{}={}", key, env.getProperty(key)));

Firstly, we create a Stream from available property sources. Then, we use its filter() method to iterate over property sources that are instances of the org.springframework.core.env.MapPropertySource class.


As the name suggests, properties in that property source are stored in a map structure. We use this in the next step, in which we’re using the stream’s map() method to get the set of property keys.


Next, we’re using Stream‘s flatMap() method, because we want to iterate over a single property key, not a set of keys. We also want to have unique, not duplicated, properties printed in alphabetical order.


The last step is to log the property key and its value.


When we start the app, we should see a big list of properties fetched from various sources:


app.description=MyApp is a Spring Boot application
ava.runtime.name=OpenJDK Runtime Environment

3.2. Logging Properties Only From the application.properties File


If we want to log properties found in just the application.properties file, we can reuse almost all the code from earlier. We need to change only the lambda function passed to the filter() method:


    .filter(ps -> ps instanceof MapPropertySource && ps.getName().contains("application.properties"))

Now, when we start the app, we should see the following logs:


app.description=MyApp is a Spring Boot application

4. Logging Properties With Environment Interface


Another way to log properties is to use the org.springframework.core.env.Environment interface:

另一种记录属性的方式是使用 org.springframework.core.env.Environment接口。

public class EnvironmentPropertiesPrinter {
    private Environment env;

    public void logApplicationProperties() {
        LOGGER.info("{}={}", "bael.property", env.getProperty("bael.property"));
        LOGGER.info("{}={}", "app.name", env.getProperty("app.name"));
        LOGGER.info("{}={}", "app.description", env.getProperty("app.description"));

The only limitation compared to the context refreshed event approach is that we need to know the property name to get its value. The environment interface doesn’t provide a method to list all properties. On the other hand, it’s definitely a shorter and easier technique.


When we start the app, we should see the same output as earlier:


app.description=MyApp is a Spring Boot application

5. Logging Properties With Spring Actuator


Spring Actuator is a very useful library that brings production-ready features to our application. The /env REST endpoint returns the current environment properties.

Spring Actuator是一个非常有用的库,它为我们的应用程序带来了可用于生产的功能。/env REST端点返回当前环境属性

First, let’s add Spring Actuator library to our project:

首先,让我们把Spring Actuator库添加到我们的项目中。


Next, we need to enable the /env endpoint, because it’s disabled by default. Let’s open application.properties and add the following entries:



Now, all we’ve to do is start the app and go to the /env endpoint. In our case the address is http://localhost:8080/actuator/env. We should see a large JSON containing all environment variables including our properties:


  "activeProfiles": [],
  "propertySources": [
      "name": "Config resource 'class path resource [application.properties]' via location 'optional:classpath:/' (document #0)",
      "properties": {
        "app.name": {
          "value": "MyApp",
          "origin": "class path resource [application.properties] - 10:10"
        "app.description": {
          "value": "MyApp is a Spring Boot application",
          "origin": "class path resource [application.properties] - 11:17"
        "bael.property": {
          "value": "defaultValue",
          "origin": "class path resource [application.properties] - 13:15"

6. Conclusion


In this article, we learned how to log properties in a Spring Boot application.

在这篇文章中,我们学习了如何在Spring Boot应用程序中记录属性。

First, we created a test application with three custom properties. Then, we saw three different ways to retrieve and log desired properties.


As always, the complete source code of the article is available over on GitHub.