Demystifying Spring Boot With Spring Debugger

Andrey Belyaev

Spring Boot is a marvel of developer productivity. It hides the plumbing and gets you up and running fast. Components are “miraculously” autowired, properties are “magically” resolved, and database connections materialize seemingly without explicit configuration.

But when something goes wrong, the magic becomes a mystery, and debugging becomes a deep dive into the framework’s internal mechanics.

Regular debuggers handle plain Java classes and objects, lacking framework-specific context. To inspect a property, track a bean, or examine an entity state, you need to dig into the internals of Spring Boot. (Remember how to access the application context from the debugger evaluator? Neither do we.)

The rabbit was always in the hat – you just had to know where to look. IntelliJ IDEA has long allowed you to inspect loaded beans or trace the source of a property value using the debugger, but doing so wasn’t exactly straightforward. Our goal is to change that – to make debugging Spring applications as comfortable and productive as the rest of your development experience in IntelliJ IDEA. The first step was an additional structure view, and now we’re going further. 

Let’s pull back the curtain on the Spring Boot magic and see how the Spring Debugger plugin makes the invisible visible. 

If you prefer watching and listening, have a look at Marco Behler’s talk at Spring I/O 2025.

The bean that wasn’t there

Spring Debugger is built with a focus on real-world tasks, helping you uncover what’s really happening inside your Spring application. 

You’ve written the class. You’ve annotated it as a bean. But it’s not doing anything. 

Maybe it’s not in the right package. Maybe it’s excluded by a conditional. Maybe it’s overridden in a test. 

Spring Debugger exposes the full bean landscape:

• You can see all Spring-managed beans directly in the Project view.
• Grayed-out entries tell you which ones were scanned but not instantiated.
• Using Mockito in tests? All mocked beans are clearly marked in orange.

And it goes deeper. 

While stepping through the code, you can inspect a bean’s metadata, including the scope, profile, context, and even originating factory method. No more guesswork – bean definitions are now first-class citizens in your debugging workflow. 

The property maze

You set a property in application.properties, but your app uses a different value. Why?

Spring Boot’s property resolution is layered: file values, profiles, environment variables, system properties, command-line args, post-processors… It’s a maze. Even professional developers need additional tools to get through.

Spring Debugger flattens the hierarchy:

• It shows the effective runtime value inline in .properties and .yaml files.
• It highlights overridden values and source locations.
• For environment-based or external values, the evaluator reveals the origin clearly.

For values from environment variables or external sources, it still shows where they came from in the debugger evaluator. Since you no longer need to trace values back manually, you save time and reduce the number of misconfigurations.

The missing transaction

You annotated your method with @Transactional, but it is not committing. Even worse, you’re getting a LazyInitializationException. What happened?

Spring Debugger helps you understand what’s going on:

• It shows inline indicators for methods executing inside active transactions.
• It displays full transaction details, including isolation, propagation, and the method that started it all.
• A visual hierarchy for nested transactions helps you understand call chains and propagation effects.
• For JPA, it shows the L1 cache state and updates it in real time.

Now you know whether your method is inside the transaction you expected – and where it actually began. 

The database client that configured itself

Your app connects to a database – but how? From which config? Which JDBC URL is used? In tests, is it using a Testcontainer? Or is it perhaps an in-memory database like H2?

Spring Debugger makes all of this explicit:

• It detects all active DataSource connections automatically.
• It groups them under their corresponding run/debug configurations.
• It integrates with IntelliJ IDEA’s Database tool window for inspection.

No need to manually register database connections or dig through logs. You can see every live DataSource and explore it interactively.

📌 In-memory databases are currently shown, but browsing data is not supported.

Reading beans from thin air

The debugger is paused. You want to trigger a service, add test data, or inspect a Spring bean. Can you do this the normal way? No.

Spring Debugger changes that by letting you:

• Auto-complete all loaded beans in the expression evaluator.
• Invoke any method on any bean on the fly.

The process of bean evaluation is getting better: We can evaluate any configuration property value right in the debugger. All we need to do is select the evaluator on the right side. 

It’s like a REPL for your Spring context. You can poke, prod, simulate, and confirm behavior without restarting the app or adding test code.

For curious developers: How it works internally 

Spring Debugger doesn’t require Spring Boot Actuator or any additional runtime agent. All data is analyzed locally without any network calls, data sharing, or risks of leakage, ensuring full privacy. Under the hood, the plugin uses non-suspending breakpoints set inside the Spring Boot framework libraries. During application startup, after the context is loaded, Spring Debugger gathers information from the debug session, memory heap, and stack trace. This lets it access “raw” internal application data without relying on external libraries.

Thanks to the IntelliJ IDEA Debugger API, we were able to invoke required methods from Spring Boot libraries, build an application runtime model, and display it in the IDE.

The Spring Debugger project also led to an extension of the debugger’s evaluator API, allowing us to add property evaluators alongside the standard Java one. In the future, we may extend this further to evaluate not just properties but also SpEL, SQL, or similar expressions.

Summary

Spring Boot is powerful, but its abstractions can be hard to debug. Spring Debugger turns IntelliJ IDEA into a lens that sees through those layers. It’s designed to keep you productive, improve code quality, and clarify real-world problems, all while offering ultimate comfort in your daily workflow.

• Beans, configs, and contexts – visually decoded.
• Transactions – made traceable.
• Properties – unmasked and source-mapped.
• Databases – auto-detected and accessible.
• Evaluator – context-aware and interactive.

The debugger doesn’t undermine the “magic” of the Spring. It lets you understand and control it. Simply run your app in debug mode and see what’s really happening.

Try it now! Install Spring Debugger and make Spring internals visible. Documentation is available to help you get started. 

We value your feedback!  Feel free to share your thoughts via plugin reviews or in the comments. 

Happy coding!

Subscribe to IntelliJ IDEA Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!