Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until tomorrow:


November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until tomorrow:


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.

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

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.

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.

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:

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.

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


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.

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.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until tomorrow:


Generic footer banner
Comments are closed on this article!