Choosing How to Run a Spring Boot Application in IntelliJ IDEA

Decision and Constraints

When developing a Spring Boot application in IntelliJ IDEA you can start the program in three ways:

• IntelliJ’s built‑in Spring Boot Run Configuration (Ultimate Edition)
• Maven plugin spring-boot:run or Gradle task bootRun
• Executing the packaged .jar with java -jar

Constraints to consider:

• Availability of live reload and debugging
• Need for command‑line reproducibility in CI
• Desire to run the exact artifact that will be deployed
• Edition of IntelliJ (Ultimate vs Community)

Comparison Table

Option	Startup Speed	Live Reload / Hot‑Swap	Debugging Integration	CI‑Friendly	Production Parity
IntelliJ Run Configuration	Fast (IDE process)	Yes (IDE hot‑swap agent)	Full (breakpoints, step‑through)	No (requires IDE)	Medium (uses IDE classpath)
Maven spring-boot:run	Moderate (Maven lifecycle)	Limited (depends on forked JVM)	Possible via remote debug	Yes	High (uses same plugins)
Gradle bootRun	Moderate	Limited	Possible via remote debug	Yes	High
Packaged .jar	Slowest (full start)	No (requires restart)	Possible via remote debug	Yes	Highest (exact artifact)

Trade‑offs

If you need instant feedback while editing code, the IDE configuration gives the quickest loop and lets you set breakpoints without leaving the editor. This works only in IntelliJ Ultimate; Community Edition users must fall back to the main class or external tools.

When you want a repeatable command that can be run on a build server, the Maven or Gradle plugins are preferable. They honor the same resource filtering and profile activation as the IDE, but attaching a debugger requires launching the JVM with -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 and then connecting remotely.

Running the .jar mimics the production environment most closely. It is useful for final validation, but any code change forces a rebuild and restart, which slows iterative development.

Concrete Implementation and Validation

Create a minimal controller to verify that the chosen launch method executes your code.

@RestController public class HelloController { @GetMapping("/hello") public String hello() { return "Hello from Spring Boot"; } }

Place the file under src/main/java/com/example/demo/HelloController.java (adjust the package to match your project).

Using the IntelliJ Run Configuration

1. Open the Run menu and select Edit Configurations….
2. Click the + button, choose Spring Boot, and ensure the Main class points to your application’s @SpringBootApplication class.
3. Select Debug' instead of Run to start the process with the IDE’s hot‑swap agent.
4. Once the application is listening on http://localhost:8080, open a browser or run curl http://localhost:8080/hello.
5. In the IDE’s debugger view you should see the thread suspended at the breakpoint you set inside the hello() method. After resuming, the request returns the expected string.

Using Maven

1. From a terminal in the project root run:

mvn spring-boot:run -Dspring-boot.run.jvmArguments="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"

2. Attach a remote debugger from IntelliJ (Run → Attach to Process or Run → Debug… with a Remote configuration pointing to localhost:5005).
3. Set a breakpoint in HelloController#hello() and repeat the curl request; the debugger should halt.

Using Gradle

1. Execute:

./gradlew bootRun --jvm-args="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"

2. Follow the same remote‑debug steps as for Maven.

Running the Packaged Jar

1. Build the artifact:

mvn clean package   # or ./gradlew clean build

2. Start it with debugging enabled:

java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -jar target/demo-0.0.1-SNAPSHOT.jar

3. Attach the remote debugger and verify the breakpoint as described above.

If the breakpoint is hit and the response is returned after resuming, you have confirmed that the launch method correctly executes your code.

Limitations and Practical Checks

• The IDE configuration does not work in IntelliJ Community Edition; you must use the main class or external plugins.
• If your project uses AspectJ or other bytecode‑enhancing agents, the IDE’s hot‑swap agent may be disabled, falling back to a restart‑based reload.
• Always verify that the IDE’s project view reflects the latest Maven/Gradle dependencies (Maven → Reimport or Gradle → Refresh) to avoid ClassNotFoundException at startup.
• To check that live reload is active, edit a string in a controller, save the file, and refresh the browser; the change should appear without a full restart when using the IDE configuration.