If you are getting started with Spring Boot, or “Spring” in general, start by reading this section. It answers the basic “what?”, “how?” and “why?” questions. It includes an introduction to Spring Boot, along with installation instructions. We then walk you through building your first Spring Boot application, discussing some core principles as we go.
1. Introducing Spring Boot
Spring Boot helps you to create stand-alone, production-grade Spring-based applications that you can run. We take an opinionated view of the Spring platform and third-party libraries, so that you can get started with minimum fuss. Most Spring Boot applications need very little Spring configuration.
You can use Spring Boot to create Java applications that can be started by using java -jar
or more traditional war deployments.
Our primary goals are:
-
Provide a radically faster and widely accessible getting-started experience for all Spring development.
-
Be opinionated out of the box but get out of the way quickly as requirements start to diverge from the defaults.
-
Provide a range of non-functional features that are common to large classes of projects (such as embedded servers, security, metrics, health checks, and externalized configuration).
-
Absolutely no code generation (when not targeting native image) and no requirement for XML configuration.
2. System Requirements
Spring Boot 3.2.6 requires Java 17 and is compatible up to and including Java 22. Spring Framework 6.1.8 or above is also required.
Explicit build support is provided for the following build tools:
Build Tool | Version |
---|---|
Maven |
3.6.3 or later |
Gradle |
7.x (7.5 or later) and 8.x |
2.1. Servlet Containers
Spring Boot supports the following embedded servlet containers:
Name | Servlet Version |
---|---|
Tomcat 10.1 |
6.0 |
Jetty 12.0 |
6.0 |
Undertow 2.3 |
6.0 |
You can also deploy Spring Boot applications to any servlet 5.0+ compatible container.
2.2. GraalVM Native Images
Spring Boot applications can be converted into a Native Image using GraalVM 22.3 or above.
Images can be created using the native build tools Gradle/Maven plugins or native-image
tool provided by GraalVM.
You can also create native images using the native-image Paketo buildpack.
The following versions are supported:
Name | Version |
---|---|
GraalVM Community |
22.3 |
Native Build Tools |
0.9.28 |
3. Installing Spring Boot
Spring Boot can be used with “classic” Java development tools or installed as a command line tool. Either way, you need Java SDK v17 or higher. Before you begin, you should check your current Java installation by using the following command:
$ java -version
If you are new to Java development or if you want to experiment with Spring Boot, you might want to try the Spring Boot CLI (Command Line Interface) first. Otherwise, read on for “classic” installation instructions.
3.1. Installation Instructions for the Java Developer
You can use Spring Boot in the same way as any standard Java library.
To do so, include the appropriate spring-boot-*.jar
files on your classpath.
Spring Boot does not require any special tools integration, so you can use any IDE or text editor.
Also, there is nothing special about a Spring Boot application, so you can run and debug a Spring Boot application as you would any other Java program.
Although you could copy Spring Boot jars, we generally recommend that you use a build tool that supports dependency management (such as Maven or Gradle).
3.1.1. Maven Installation
Spring Boot is compatible with Apache Maven 3.6.3 or later. If you do not already have Maven installed, you can follow the instructions at maven.apache.org.
On many operating systems, Maven can be installed with a package manager.
If you use OSX Homebrew, try brew install maven .
Ubuntu users can run sudo apt-get install maven .
Windows users with Chocolatey can run choco install maven from an elevated (administrator) prompt.
|
Spring Boot dependencies use the org.springframework.boot
group id.
Typically, your Maven POM file inherits from the spring-boot-starter-parent
project and declares dependencies to one or more “Starters”.
Spring Boot also provides an optional Maven plugin to create executable jars.
More details on getting started with Spring Boot and Maven can be found in the Getting Started section of the Maven plugin’s reference guide.
3.1.2. Gradle Installation
Spring Boot is compatible with Gradle 7.x (7.5 or later) and 8.x. If you do not already have Gradle installed, you can follow the instructions at gradle.org.
Spring Boot dependencies can be declared by using the org.springframework.boot
group
.
Typically, your project declares dependencies to one or more “Starters”.
Spring Boot provides a useful Gradle plugin that can be used to simplify dependency declarations and to create executable jars.
More details on getting started with Spring Boot and Gradle can be found in the Getting Started section of the Gradle plugin’s reference guide.
3.2. Installing the Spring Boot CLI
The Spring Boot CLI (Command Line Interface) is a command line tool that you can use to quickly prototype with Spring.
You do not need to use the CLI to work with Spring Boot, but it is a quick way to get a Spring application off the ground without an IDE.
3.2.1. Manual Installation
You can download the Spring CLI distribution from one of the following locations:
Once downloaded, follow the INSTALL.txt instructions from the unpacked archive.
In summary, there is a spring
script (spring.bat
for Windows) in a bin/
directory in the .zip
file.
Alternatively, you can use java -jar
with the .jar
file (the script helps you to be sure that the classpath is set correctly).
3.2.2. Installation with SDKMAN!
SDKMAN! (The Software Development Kit Manager) can be used for managing multiple versions of various binary SDKs, including Groovy and the Spring Boot CLI. Get SDKMAN! from sdkman.io and install Spring Boot by using the following commands:
$ sdk install springboot
$ spring --version
Spring CLI v3.2.6
If you develop features for the CLI and want access to the version you built, use the following commands:
$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-3.2.6-bin/spring-3.2.6/
$ sdk default springboot dev
$ spring --version
Spring CLI v3.2.6
The preceding instructions install a local instance of spring
called the dev
instance.
It points at your target build location, so every time you rebuild Spring Boot, spring
is up-to-date.
You can see it by running the following command:
$ sdk ls springboot
================================================================================
Available Springboot Versions
================================================================================
> + dev
* 3.2.6
================================================================================
+ - local version
* - installed
> - currently in use
================================================================================
3.2.3. OSX Homebrew Installation
If you are on a Mac and use Homebrew, you can install the Spring Boot CLI by using the following commands:
$ brew tap spring-io/tap
$ brew install spring-boot
Homebrew installs spring
to /usr/local/bin
.
If you do not see the formula, your installation of brew might be out-of-date.
In that case, run brew update and try again.
|
3.2.4. MacPorts Installation
If you are on a Mac and use MacPorts, you can install the Spring Boot CLI by using the following command:
$ sudo port install spring-boot-cli
3.2.5. Command-line Completion
The Spring Boot CLI includes scripts that provide command completion for the BASH and zsh shells.
You can source
the script (also named spring
) in any shell or put it in your personal or system-wide bash completion initialization.
On a Debian system, the system-wide scripts are in <installation location>/shell-completion/bash
and all scripts in that directory are executed when a new shell starts.
For example, to run the script manually if you have installed by using SDKMAN!, use the following commands:
$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
grab help jar run test version
If you install the Spring Boot CLI by using Homebrew or MacPorts, the command-line completion scripts are automatically registered with your shell. |
3.2.6. Windows Scoop Installation
If you are on a Windows and use Scoop, you can install the Spring Boot CLI by using the following commands:
> scoop bucket add extras > scoop install springboot
Scoop installs spring
to ~/scoop/apps/springboot/current/bin
.
If you do not see the app manifest, your installation of scoop might be out-of-date.
In that case, run scoop update and try again.
|
4. Developing Your First Spring Boot Application
This section describes how to develop a small “Hello World!” web application that highlights some of Spring Boot’s key features. You can choose between Maven or Gradle as the build system.
The spring.io website contains many “Getting Started” guides that use Spring Boot. If you need to solve a specific problem, check there first. You can shortcut the steps below by going to start.spring.io and choosing the "Web" starter from the dependencies searcher. Doing so generates a new project structure so that you can start coding right away. Check the start.spring.io user guide for more details. |
4.1. Prerequisites
Before we begin, open a terminal and run the following commands to ensure that you have a valid version of Java installed:
$ java -version
openjdk version "17.0.4.1" 2022-08-12 LTS
OpenJDK Runtime Environment (build 17.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM (build 17.0.4.1+1-LTS, mixed mode, sharing)
This sample needs to be created in its own directory. Subsequent instructions assume that you have created a suitable directory and that it is your current directory. |
4.1.1. Maven
If you want to use Maven, ensure that you have Maven installed:
$ mvn -v
Apache Maven 3.8.5 (3599d3414f046de2324203b78ddcf9b5e4388aa0)
Maven home: usr/Users/developer/tools/maven/3.8.5
Java version: 17.0.4.1, vendor: BellSoft, runtime: /Users/developer/sdkman/candidates/java/17.0.4.1-librca
4.1.2. Gradle
If you want to use Gradle, ensure that you have Gradle installed:
$ gradle --version
------------------------------------------------------------
Gradle 8.1.1
------------------------------------------------------------
Build time: 2023-04-21 12:31:26 UTC
Revision: 1cf537a851c635c364a4214885f8b9798051175b
Kotlin: 1.8.10
Groovy: 3.0.15
Ant: Apache Ant(TM) version 1.10.11 compiled on July 10 2021
JVM: 17.0.7 (BellSoft 17.0.7+7-LTS)
OS: Linux 6.2.12-200.fc37.aarch64 aarch64
4.2. Setting up the project with Maven
We need to start by creating a Maven pom.xml
file.
The pom.xml
is the recipe that is used to build your project.
Open your favorite text editor and add the following:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.6</version>
</parent>
<!-- Additional lines to be added here... -->
</project>
The preceding listing should give you a working build.
You can test it by running mvn package
(for now, you can ignore the “jar will be empty - no content was marked for inclusion!” warning).
At this point, you could import the project into an IDE (most modern Java IDEs include built-in support for Maven). For simplicity, we continue to use a plain text editor for this example. |
4.3. Setting up the project with Gradle
We need to start by creating a Gradle build.gradle
file.
The build.gradle
is the build script that is used to build your project.
Open your favorite text editor and add the following:
plugins {
id 'java'
id 'org.springframework.boot' version '3.2.6'
}
apply plugin: 'io.spring.dependency-management'
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'
repositories {
mavenCentral()
}
dependencies {
}
The preceding listing should give you a working build.
You can test it by running gradle classes
.
At this point, you could import the project into an IDE (most modern Java IDEs include built-in support for Gradle). For simplicity, we continue to use a plain text editor for this example. |
4.4. Adding Classpath Dependencies
Spring Boot provides a number of “Starters” that let you add jars to your classpath. “Starters” provide dependencies that you are likely to need when developing a specific type of application.
4.4.1. Maven
Most Spring Boot applications use the spring-boot-starter-parent
in the parent
section of the POM.
The spring-boot-starter-parent
is a special starter that provides useful Maven defaults.
It also provides a dependency-management
section so that you can omit version
tags for “blessed” dependencies.
Since we are developing a web application, we add a spring-boot-starter-web
dependency.
Before that, we can look at what we currently have by running the following command:
$ mvn dependency:tree
[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT
The mvn dependency:tree
command prints a tree representation of your project dependencies.
You can see that spring-boot-starter-parent
provides no dependencies by itself.
To add the necessary dependencies, edit your pom.xml
and add the spring-boot-starter-web
dependency immediately below the parent
section:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
If you run mvn dependency:tree
again, you see that there are now a number of additional dependencies, including the Tomcat web server and Spring Boot itself.
4.4.2. Gradle
Most Spring Boot applications use the org.springframework.boot
Gradle plugin.
This plugin provides useful defaults and Gradle tasks.
The io.spring.dependency-management
Gradle plugin provides dependency management so that you can omit version
tags for “blessed” dependencies.
Since we are developing a web application, we add a spring-boot-starter-web
dependency.
Before that, we can look at what we currently have by running the following command:
$ gradle dependencies
> Task :dependencies
------------------------------------------------------------
Root project 'myproject'
------------------------------------------------------------
The gradle dependencies
command prints a tree representation of your project dependencies.
Right now, the project has no dependencies.
To add the necessary dependencies, edit your build.gradle
and add the spring-boot-starter-web
dependency in the dependencies
section:
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
}
If you run gradle dependencies
again, you see that there are now a number of additional dependencies, including the Tomcat web server and Spring Boot itself.
4.5. Writing the Code
To finish our application, we need to create a single Java file.
By default, Maven and Gradle compile sources from src/main/java
, so you need to create that directory structure and then add a file named src/main/java/MyApplication.java
to contain the following code:
package com.example;
@RestController
@SpringBootApplication
public class MyApplication {
@RequestMapping("/")
String home() {
return "Hello World!";
}
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
@RestController
@SpringBootApplication
class MyApplication {
@RequestMapping("/")
fun home() = "Hello World!"
}
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}
Although there is not much code here, quite a lot is going on. We step through the important parts in the next few sections.
4.5.1. The @RestController and @RequestMapping Annotations
The first annotation on our MyApplication
class is @RestController
.
This is known as a stereotype annotation.
It provides hints for people reading the code and for Spring that the class plays a specific role.
In this case, our class is a web @Controller
, so Spring considers it when handling incoming web requests.
The @RequestMapping
annotation provides “routing” information.
It tells Spring that any HTTP request with the /
path should be mapped to the home
method.
The @RestController
annotation tells Spring to render the resulting string directly back to the caller.
The @RestController and @RequestMapping annotations are Spring MVC annotations (they are not specific to Spring Boot).
See the MVC section in the Spring Reference Documentation for more details.
|
4.5.2. The @SpringBootApplication Annotation
The second class-level annotation is @SpringBootApplication
.
This annotation is known as a meta-annotation, it combines @SpringBootConfiguration
, @EnableAutoConfiguration
and @ComponentScan
.
Of those, the annotation we’re most interested in here is @EnableAutoConfiguration
.
@EnableAutoConfiguration
tells Spring Boot to “guess” how you want to configure Spring, based on the jar dependencies that you have added.
Since spring-boot-starter-web
added Tomcat and Spring MVC, the auto-configuration assumes that you are developing a web application and sets up Spring accordingly.
4.5.3. The “main” Method
The final part of our application is the main
method.
This is a standard method that follows the Java convention for an application entry point.
Our main method delegates to Spring Boot’s SpringApplication
class by calling run
.
SpringApplication
bootstraps our application, starting Spring, which, in turn, starts the auto-configured Tomcat web server.
We need to pass MyApplication.class
as an argument to the run
method to tell SpringApplication
which is the primary Spring component.
The args
array is also passed through to expose any command-line arguments.
4.6. Running the Example
4.6.1. Maven
At this point, your application should work.
Since you used the spring-boot-starter-parent
POM, you have a useful run
goal that you can use to start the application.
Type mvn spring-boot:run
from the root project directory to start the application.
You should see output similar to the following:
$ mvn spring-boot:run
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.2.6)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)
If you open a web browser to localhost:8080
, you should see the following output:
Hello World!
To gracefully exit the application, press ctrl-c
.
4.6.2. Gradle
At this point, your application should work.
Since you used the org.springframework.boot
Gradle plugin, you have a useful bootRun
goal that you can use to start the application.
Type gradle bootRun
from the root project directory to start the application.
You should see output similar to the following:
$ gradle bootRun
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.2.6)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)
If you open a web browser to localhost:8080
, you should see the following output:
Hello World!
To gracefully exit the application, press ctrl-c
.
4.7. Creating an Executable Jar
We finish our example by creating a completely self-contained executable jar file that we could run in production. Executable jars (sometimes called “uber jars” or “fat jars”) are archives containing your compiled classes along with all of the jar dependencies that your code needs to run.
4.7.1. Maven
To create an executable jar, we need to add the spring-boot-maven-plugin
to our pom.xml
.
To do so, insert the following lines just below the dependencies
section:
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
The spring-boot-starter-parent POM includes <executions> configuration to bind the repackage goal.
If you do not use the parent POM, you need to declare this configuration yourself.
See the plugin documentation for details.
|
Save your pom.xml
and run mvn package
from the command line, as follows:
$ mvn package
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:3.2.6:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
If you look in the target
directory, you should see myproject-0.0.1-SNAPSHOT.jar
.
The file should be around 18 MB in size.
If you want to peek inside, you can use jar tvf
, as follows:
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
You should also see a much smaller file named myproject-0.0.1-SNAPSHOT.jar.original
in the target
directory.
This is the original jar file that Maven created before it was repackaged by Spring Boot.
To run that application, use the java -jar
command, as follows:
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.2.6)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)
As before, to exit the application, press ctrl-c
.
4.7.2. Gradle
To create an executable jar, we need to run gradle bootJar
from the command line, as follows:
$ gradle bootJar
BUILD SUCCESSFUL in 639ms
3 actionable tasks: 3 executed
If you look in the build/libs
directory, you should see myproject-0.0.1-SNAPSHOT.jar
.
The file should be around 18 MB in size.
If you want to peek inside, you can use jar tvf
, as follows:
$ jar tvf build/libs/myproject-0.0.1-SNAPSHOT.jar
To run that application, use the java -jar
command, as follows:
$ java -jar build/libs/myproject-0.0.1-SNAPSHOT.jar
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.2.6)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)
As before, to exit the application, press ctrl-c
.
5. What to Read Next
Hopefully, this section provided some of the Spring Boot basics and got you on your way to writing your own applications. If you are a task-oriented type of developer, you might want to jump over to spring.io and follow some of the getting started guides that solve specific “How do I do that with Spring?” problems. We also have Spring Boot-specific “How-to” reference documentation.
Otherwise, the next logical step is to read using.html. If you are really impatient, you could also jump ahead and read about Spring Boot features.