Spring Boot starters are curated sets of dependencies, packaged as dependency descriptors. Instead of finding and declaring many related libraries ourselves, we add a single starter and get everything needed for a given feature, with versions that are known to work together.
In this tutorial we are going to explain different aspects of starters using Maven. The same starters work with Gradle as well. To generate a ready-to-use project with the starters of our choice, we can also use Spring Initializr.
spring-boot-starter-parent
The spring-boot-starter-parent is a special starter that provides useful Maven defaults, such as the default Java version, UTF-8 source encoding, sensible plugin configuration, and dependency management inherited from spring-boot-dependencies. We extend our project POM from this starter. By choosing a specific version of the parent, we implicitly select compatible versions of the Spring modules and the third-party libraries that this Spring Boot release supports.
Spring Boot uses Maven's Dependency Management mechanism to centralize dependency information, so that we can omit version tags for the dependencies it manages. We will see how to find and override those managed versions, and other defaults like the Java version, in the next tutorial.
Using the parent POM is the most convenient approach, but it is optional. We will also see how to get the same dependency management without inheriting from it in an upcoming tutorial.
Official Spring Boot starters are released together with Spring Boot, so they always share its version number. For example, with Spring Boot 4.1.0, spring-boot-starter and every other official starter are also 4.1.0. That is why we can omit the version tag when using the parent POM. The libraries a starter brings in, such as Spring Framework or Logback, have their own versions, which Spring Boot's dependency management selects for us.
Application-specific starter dependencies
We specify the other starters in the <dependencies></dependencies> section of our POM. They provide the dependencies our application actually needs.
For example, let's create a Spring core context application. For that we need to add spring-boot-starter:
pom.xml<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>4.1.1</version>
</parent>
<groupId>com.logicbig.example</groupId>
<artifactId>spring-boot-starter-example</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<java.version>25</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>
</project>
That brings in the following dependencies:
$ mvn dependency:tree
[INFO] Scanning for projects...
[INFO]
[INFO] ----------< com.logicbig.example:spring-boot-starter-example >----------
[INFO] Building spring-boot-starter-example 1.0-SNAPSHOT
[INFO] from pom.xml
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- dependency:2.10:tree (default-cli) @ spring-boot-starter-example ---
[INFO] com.logicbig.example:spring-boot-starter-example:jar:1.0-SNAPSHOT
[INFO] \- org.springframework.boot:spring-boot-starter:jar:1.4.2.RELEASE:compile
[INFO] +- org.springframework.boot:spring-boot:jar:1.4.2.RELEASE:compile
[INFO] | \- org.springframework:spring-context:jar:4.3.4.RELEASE:compile
[INFO] | +- org.springframework:spring-aop:jar:4.3.4.RELEASE:compile
[INFO] | +- org.springframework:spring-beans:jar:4.3.4.RELEASE:compile
[INFO] | \- org.springframework:spring-expression:jar:4.3.4.RELEASE:compile
[INFO] +- org.springframework.boot:spring-boot-autoconfigure:jar:1.4.2.RELEASE:compile
[INFO] +- org.springframework.boot:spring-boot-starter-logging:jar:1.4.2.RELEASE:compile
[INFO] | +- ch.qos.logback:logback-classic:jar:1.1.7:compile
[INFO] | | +- ch.qos.logback:logback-core:jar:1.1.7:compile
[INFO] | | \- org.slf4j:slf4j-api:jar:1.7.21:compile
[INFO] | +- org.slf4j:jcl-over-slf4j:jar:1.7.21:compile
[INFO] | +- org.slf4j:jul-to-slf4j:jar:1.7.21:compile
[INFO] | \- org.slf4j:log4j-over-slf4j:jar:1.7.21:compile
[INFO] +- org.springframework:spring-core:jar:4.3.4.RELEASE:compile
[INFO] \- org.yaml:snakeyaml:jar:1.17:runtime
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.375 s
[INFO] Finished at: 2026-10-12T04:30:46-05:00
[INFO] ------------------------------------------------------------------------
Each Spring Boot release comes with a matching, tested set of Spring modules, so upgrading Spring Boot is the usual way to upgrade the Spring modules as well. To see what changed between releases, check the Release Notes.
After including the parent and the starter, we can start using the Spring core context:
package com.logicbig.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class ApplicationExample {
@Bean
public MyBean myBean() {
return new MyBean();
}
public static void main(String[] args) {
SpringApplication.run(ApplicationExample.class, args)
.getBean(MyBean.class)
.doSomething();
}
private static class MyBean {
public void doSomething() {
System.out.println("Doing something in MyBean");
}
}
}
Output
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v4.1.1)
2026-10-13T03:00:20.875-05:00 INFO 25560 --- [ main] c.logicbig.example.ApplicationExample : Starting ApplicationExample using Java 25 with PID 25560 (D:\LogicBig\example-projects\spring-boot\spring-boot-starter-example\target\classes started by joe2 in D:\LogicBig\example-projects\spring-boot\spring-boot-starter-example)
2026-10-13T03:00:20.877-05:00 INFO 25560 --- [ main] c.logicbig.example.ApplicationExample : No active profile set, falling back to 1 default profile: "default"
2026-10-13T03:00:21.319-05:00 INFO 25560 --- [ main] c.logicbig.example.ApplicationExample : Started ApplicationExample in 0.749 seconds (process running for 1.031)
Doing something in MyBean
In the above example, @SpringBootApplication is a convenience annotation that combines @SpringBootConfiguration (a specialization of @Configuration), @EnableAutoConfiguration and @ComponentScan. We will discuss these in upcoming tutorials.
Spring starter list
Check out the complete list of official starters in the reference documentation. Note that Spring Boot 4 renamed or split many starters into smaller, technology-specific ones (for example, spring-boot-starter-web is now spring-boot-starter-webmvc). See the Spring Boot 4.0 Migration Guide on the project wiki if you are upgrading an older project.
Starters naming convention
All official Spring Boot starters follow the pattern spring-boot-starter-* (for example, spring-boot-starter-webmvc). This prefix is reserved for official Spring Boot artifacts. If we create our own starter, we should use a different naming convention, e.g. mycompany-spring-boot-starter. The same applies to all third-party starters.
What's next?
In the next tutorial, we are going to see how to find the dependency versions managed by Spring Boot, and how to override them and other default properties.
Example ProjectDependencies and Technologies Used: - Spring Boot 4.1.1
Corresponding Spring Version 7.0.9
Version Compatibility: 1.2.0.RELEASE - 4.1.1
- spring-boot-starter (Core starter, including auto-configuration support, logging and YAML)
- JDK 25
- Maven 3.9.11
|
