Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

When we’re injecting runtime properties into our Spring applications, we may define bean classes for groups of custom properties.

IntelliJ provides help and auto-complete for the built-in properties beans. However, it needs a little help to provide these for custom properties.

In this short tutorial, we’ll look at how to expose these properties to IntelliJ to make the development process easier.

2. Custom Properties

Let’s have a look at the on-screen help IntelliJ can provide us regarding our application’s properties:

IntelliJCannotResolveCustomPropertyAutoCompletion

Here, the properties url and timeout-in-milliseconds are custom properties. We can see a description, type, and an optional default value.

But, if a property is unknown, IntelliJ will show us a warning:

IntelliJCannotResolveCustomProperty-2

This is because, without metadata, IntelliJ cannot help us.

Now let’s take a look at what we have to do to fix this.

3. Dependencies

First, we need to add the spring-boot-configuration-processor dependency to our pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

The spring-boot-configuration-processor is invoked each time we build our project. It will create the metadata files in target/classes/META-INF/. 

The dependency is marked as optional, which means that it is not inherited when somebody uses our project as a dependency.

Next, we’ll see where the spring-boot-configuration-processor gets the information used to create the metadata.

4. Configuration Metadata with @ConfigurationProperties

We define our properties in a class annotated with @ConfigurationProperties:

@Configuration
@ConfigurationProperties(prefix = "com.baeldung")
public class CustomProperties {

    /**
     * The url to connect to.
     */
    String url;

    /**
     * The time to wait for the connection.
     */
    private int timeoutInMilliSeconds = 1000;

    // Getters and Setters

}

Here, the class contains the property names, their types, and any defaults provided in the initializer list. Also, the Javadoc provides descriptions of each property.

During a build, the annotation processor searches for all classes that are annotated with @ConfigurationProperties. It generates custom property metadata for each instance variable of the class.

5. Configuration Metadata File

5.1. Format of the Metadata File

The metadata file that describes the custom properties drives the contextual help in IntelliJ, for example:

{
  "groups": [
    {
      "name": "com.baeldung",
      "type": "com.baeldung.configuration.processor.CustomProperties",
      "sourceType": "com.baeldung.configuration.processor.CustomProperties"
    }
  ],
  "properties": [
    {
      "name": "com.baeldung.url",
      "type": "java.lang.String",
      "description": "The url to connect to.",
      "sourceType": "com.baeldung.configuration.processor.CustomProperties"
    },
    {
      "name": "com.baeldung.timeout-in-milli-seconds",
      "type": "java.lang.Integer",
      "description": "The time to wait for the connection.",
      "sourceType": "com.baeldung.configuration.processor.CustomProperties",
      "defaultValue": 1000
    }
  ],
  "hints": []
}

As the annotation processor generates this file for us from our code, there’s no need to look at or edit this file directly.

5.2. Metadata Without a ConfigurationProperties Bean

If we have existing properties that are not introduced by a @ConfigurationProperties, but still want their metadata file, then IntelliJ can help.

Let’s take a closer look at the warning message from before:

IntelliJCannotResolveCustomProperty-2-1

Here we see a Define configuration key option, which we can use to create an additional-spring-configuration-metadata.json file. The created file will look like:

{
  "properties": [
    {
      "name": "com.baeldung.timeoutInMilliSeconds",
      "type": "java.lang.String",
      "description": "Description for com.baeldung.timeoutInMilliSeconds."
    }
  ]
}

As there’s no information about the property from anywhere else, we’ll have to manually edit the metadata inside it. The default type is always String.

Let’s put some extra information into the file:

{
  "properties": [
    {
      "name": "com.baeldung.timeout-in-milli-seconds",
      "type": "java.lang.Integer",
      "description": "The time to wait for the connection.",
      "sourceType": "com.baeldung.configuration.processor.CustomProperties",
      "defaultValue": 1000
    }
  ]
}

Note that we’ll need to rebuild the project to see the new property come up in auto-complete.

Also, we should note that the option to generate this metadata file is also available via IntelliJ’s Alt+ENTER shortcut over an unknown property.

6. Conclusion

In this article, we looked at how IntelliJ uses the configuration property metadata to provide help with our properties files.

We saw how to use Spring’s annotation processor to generate the metadata from custom classes. Then, we saw how to use a shortcut in IntelliJ to create a metadata file to edit manually.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW