Toggle dropdown

Related Java Setup Guides

Core Guide: Java, Maven & Gradle Setup & Usage
Specifics: Setting up JavaFX
This Article: Specifics for Setting up a Spring Boot Server

Overview

This guide covers creating a Spring Boot application. Key aspects:

Build Tool Setup (Maven/Gradle): JDK, Maven, and Gradle setup (including JAVA_HOME/M2_HOME) are covered in the Core Java & Build Tools Setup Guide. While this article primarily demonstrates a Maven-based Spring Boot project, Gradle is a well-supported alternative, and the linked guide provides details for both.
IntelliJ IDEA Spring Initializr: For easy project generation.
REST API Endpoint: A simple "Hello World" example.
Static Web Content: Serving HTML/CSS/JS.
Application Configuration: Using application.properties and environment variables.

Part 1: Create a Spring Boot Project

Generate project via CLI (start.spring.io)

Use curl to fetch and unpack a new Spring Boot starter:

curl https://start.spring.io/starter.zip \
  -d dependencies=web,devtools,thymeleaf \
  -d type=maven-project \
  -d language=java \
  -d javaVersion=21 \
  -d groupId=com.example \
  -d artifactId=myspringbootapp \
  -d name=MySpringBootApp \
  -d packageName=com.example.myspringbootapp \
  | tar -xzvf -

Using Spring Initializr in IntelliJ IDEA

In IntelliJ IDEA: File > New > Project… → Spring Initializr
Configure Group com.example, Artifact myspringbootapp, Packaging Jar, Java 21
Add Dependencies: Spring Web, Spring Boot DevTools
Click Create to generate the project

Project structure

src/main/java - Application code (MySpringBootAppApplication.java)
src/main/resources/static - Static assets (HTML, CSS, JS)
src/main/resources/application.properties - Configuration
pom.xml - Maven config and dependency management

Part 2: Application Configuration

application.properties setup

Edit src/main/resources/application.properties to configure your application:

# Server configuration
server.port=8080
server.servlet.context-path=/api

# Logging configuration
logging.level.root=INFO
logging.level.com.example=DEBUG

# Spring devtools
spring.devtools.restart.enabled=true

For different environments, create profile-specific properties:

application-dev.properties
application-prod.properties

Environment variables with .env

For sensitive data like API keys, use environment variables.

Add spring-dotenv dependency to pom.xml:

<dependency>
    <groupId>me.paulschwarz</groupId>
    <artifactId>spring-dotenv</artifactId>
    <version>4.0.0</version>
</dependency>

Create .env.example file:

SERVER_PORT=8080
CUSTOM_API_KEY=your-api-key-here

Create your actual .env file (don't commit to git):

SERVER_PORT=8080
CUSTOM_API_KEY=actual-api-key-value

Reference env variables in application.properties:

server.port=${SERVER_PORT:8080}
api.key=${CUSTOM_API_KEY}

Part 3: Build a Basic REST API

HelloController.java

Create src/main/java/com/example/myspringbootapp/HelloController.java:

package com.example.myspringbootapp;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello(
      @RequestParam(defaultValue = "World") String name
    ) {
        return String.format("Hello, %s!", name);
    }
}

Run and test

Run in IntelliJ: click the green play icon next to main method
CLI:
mvn spring-boot:run

Visit http://localhost:8080/hello and http://localhost:8080/hello?name=Spring or use:

curl http://localhost:8080/hello
curl http://localhost:8080/hello?name=Developer

Part 4: Serve Static Web Content

Static index.html

Create src/main/resources/static/index.html:

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Static Page</title></head>
<body>
  <h1>Welcome to My Static Page!</h1>
</body>
</html>

Restart app and browse to http://localhost:8080/ Spring Boot serves files in static/ automatically.

Part 5: Essential Maven Commands for Spring Boot

Refer to the Core Maven Guide for general Maven commands. Specific to Spring Boot (using the Spring Boot Maven Plugin, typically included):

Spring Boot Maven Plugin Commands

# Run the Spring Boot application (dev mode with hot reload if DevTools is present)
./mvnw spring-boot:run

# Package the application into an executable JAR
./mvnw clean package
# (The spring-boot-maven-plugin's repackage goal runs by default during the package phase)

# Build an OCI image (e.g., Docker image) if configured
./mvnw spring-boot:build-image

The spring-boot:run goal is particularly useful for development. For other standard Maven lifecycle commands like clean, compile, test, install, use them as described in the Core Maven Guide.

Part 6: Development & Hot Reload

Hot reload setup with Spring Boot DevTools

Spring Boot DevTools (spring-boot-devtools dependency) enables automatic restart/hot reload by default when files change. To optimize:

For IntelliJ IDEA:
- In Preferences > Build, Execution, Deployment > Compiler, enable "Build project automatically"
- Enable advanced settings: Registry (Ctrl+Alt+Shift+/) > check "compiler.automake.allow.when.app.running"
For CLI:

mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Dspring.devtools.restart.enabled=true"

To run with specific profile:

./mvnw spring-boot:run -Dspring-boot.run.profiles=dev # For Maven
# For Gradle: ./gradlew bootRun --args='--spring.profiles.active=dev'

Part 7: Key Spring Boot Concepts & Troubleshooting

Spring Boot Auto-configuration

Spring Boot automatically configures your application based on the JAR dependencies you have added. For example, if spring-boot-starter-web is on the classpath, it auto-configures Tomcat and Spring MVC.

Starters

Spring Boot "Starters" are convenient dependency descriptors that you can include in your application. For example, spring-boot-starter-data-jpa for JPA/Hibernate, spring-boot-starter-security for security.

Port Conflict

If port 8080 is in use, change it in application.properties (e.g., server.port=8081) or via command line:

./mvnw spring-boot:run -Dspring-boot.run.arguments="--server.port=8081"

Maven Central Repository

Maven Central (central.sonatype.com) is the primary public repository for Java libraries (dependencies). Spring Boot dependencies are typically fetched from here or other configured repositories (like Spring Milestones/Snapshots).

Part 8: Deployment Options

Package for Production (Executable JAR)

# Using Maven
./mvnw clean package
# This creates an executable JAR in target/your-app-name.jar

# Using Gradle
./gradlew clean bootJar
# This creates an executable JAR in build/libs/your-app-name.jar

Run the JAR: java -jar target/myspringbootapp-0.0.1-SNAPSHOT.jar (adjust filename).

Running with Different Profiles in Production

java -jar target/*.jar --spring.profiles.active=prod

When running in production, set environment variables externally:

export SERVER_PORT=80
export CUSTOM_API_KEY=production-key
java -jar target/*.jar

Docker deployment

Create Dockerfile:

FROM eclipse-temurin:21-jre
WORKDIR /app
COPY target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Build and run:

docker build -t myspringbootapp .
docker run -p 8080:8080 --env-file .env myspringbootapp