IntelliJ IDEA Spring Boot Run Configuration vs Maven/Gradle Plugin: Decision Guide

Decision and Constraints

State the decision: use IntelliJ IDEA's built‑in Spring Boot Run/Debug configuration when you need fast startup, integrated breakpoint debugging, and class hot‑swap during development. Constraints: you must be using IDEA Ultimate edition, have a compatible JDK, and the project must already contain a Spring Boot starter. The IDE consumes more memory than a plain command‑line launch, and the launch settings are not automatically reused in CI pipelines.

Comparison of Options

Aspect	IDEA Run Configuration	External Maven/Gradle Plugin
Startup speed	Instant (IDE internal launcher)	Depends on Maven/Gradle lifecycle; slightly slower
Debugging	Breakpoints, step‑through, hot‑swap via IDE debugger	Breakpoints only after attaching a remote debugger (default port 5005)
Hot swap	Automatic for method‑body changes while debugging	Not automatic; requires manual reattach or restart
CI reproducibility	Launch parameters must be mirrored in CI to avoid "works in IDE" issues	Identical command used locally and in CI
Resource usage	IDEA process + JVM	Only JVM (plus Maven/Gradle daemon)

Trade‑offs

Choosing the IDEA configuration gives you the quickest feedback loop and the most seamless debugging experience, but you must keep the launch configuration (JVM args, active profiles, etc.) in sync with what your CI uses. The external plugin approach guarantees that the exact same command runs everywhere, yet you lose the IDE’s hot‑swap convenience and need to attach a debugger manually if you want breakpoints.

Concrete Implementation – Setting Up the IDEA Configuration

1. Open Run → Edit Configurations.
2. Click the + button, select Spring Boot.
3. Fill in:
• Name: e.g., MyApp‑Dev
• Main class: the @SpringBootApplication class.
• JRE: choose a JDK 11 or newer that matches your build.
• VM options: any props you need, e.g., -Dspring.profiles.active=dev.
• Enable alternative JRE for debugging (optional).
4. Click Apply then OK.
5. Press the Debug button (bug icon) to start the app in debug mode.

While the application is running, make a small change to the body of a method (for example, add a log statement). IDEA will show a notification like Hot swapped method com.example.MyService.doWork(). The change takes effect immediately without a restart.

Validation – Comparing with External Launch

1. Open a terminal in the project root.
2. Run the Maven wrapper: ./mvnw spring-boot:run (or Gradle: ./gradlew bootRun).
3. In IDEA, choose Run → Attach to Process or Run → Debug… and set the host to localhost and port 5005 (the default debug port used by the plugin).
4. Set a breakpoint in the same method you changed earlier.
5. When the breakpoint hits, you can step through code, but note that editing the method body while attached will not trigger a hot swap; you will need to restart the application or relaunch the plugin to see the change.

Limitations and Practical Checks

• Hot swap only works for changes inside method bodies. Adding, removing, or changing method signatures or fields requires a full restart regardless of launch method.
• If you change VM options or active profiles in the IDEA configuration, repeat the same changes in your CI script to avoid divergence.
• To verify that your IDEA launch matches the external build, compare the console output: the lines printed by Spring Boot (e.g., Started MyApplication in X.XXX seconds) should be similar in timing and active profiles.
• You can also check the effective classpath by running mvn dependency:tree (or Gradle equivalent) and ensuring no extra IDE‑specific libraries are added.

By following the steps above you can decide which launch method fits your workflow and validate that the chosen option behaves as expected.