Spring Boot Starters

Starters are curated dependency descriptors that pull in everything typically needed for a given kind of functionality, with versions that are already tested to work together. Instead of manually choosing compatible versions of Spring MVC, Jackson, an embedded servlet container, and validation libraries, you add one starter and Spring Boot's dependency management resolves a known-good set for you.

This matters because version mismatches between related libraries are one of the most common sources of hard-to-diagnose runtime errors in Java projects. Starters exist specifically to eliminate that class of problem.

Commonly Used Starters

Each starter is named after the capability it adds, following the pattern spring-boot-starter-*.

• spring-boot-starter-webmvc — builds RESTful/MVC web applications using Spring MVC, with an embedded Tomcat server and Jackson for JSON (called spring-boot-starter-web before Spring Boot 4).
• spring-boot-starter-restclient / spring-boot-starter-webclient — HTTP clients for calling other services (separate starters since Spring Boot 4).
• spring-boot-starter-data-jpa — Spring Data JPA on top of Hibernate, for working with relational databases through repository interfaces.
• spring-boot-starter-security — Spring Security, adding authentication and authorization with sensible defaults (e.g. every endpoint requires login unless configured otherwise).
• spring-boot-starter-validation — Bean Validation (Jakarta Validation) support for @Valid-based request validation.
• spring-boot-starter-test — JUnit 5, Mockito, AssertJ, and Spring Test, all pre-wired for testing (included by default in generated projects).

How Starters Affect the Classpath

Adding a starter to your pom.xml or build.gradle changes what is on the classpath, and that in turn changes what auto-configuration activates. For example, spring-boot-starter-data-jpa brings in Hibernate and the JPA API, which makes classes like EntityManager and DataSource available — and that presence is exactly what Spring Boot's auto-configuration checks for before wiring up a JPA-based persistence layer automatically.

What Changed in Spring Boot 4

Spring Boot 3 shipped one large spring-boot-autoconfigure jar containing the auto-configuration for every supported technology. Spring Boot 4 splits it into small modules, one per technology, and each starter brings in only the module it needs. Applications get a smaller classpath and fewer surprise configurations. Two practical consequences:

• Some starters were renamed. spring-boot-starter-web still exists in 4.x but is deprecated in favour of spring-boot-starter-webmvc.
• Every technology starter has a matching test starter, such as spring-boot-starter-webmvc-test or spring-boot-starter-data-jpa-test, which brings in the test slices for that technology.
• When upgrading a large Boot 3 application, spring-boot-starter-classic and spring-boot-starter-test-classic bring back the full set of auto-configuration modules. They are a stepping stone for migration; move to the specific starters afterwards.

Seeing What a Starter Brings In

A starter is just a POM with dependencies, so you can inspect it. mvn dependency:tree (or gradle dependencies) prints every library and its version. Use it when you need to know which Tomcat, Hibernate or Jackson version you are actually running, or when two libraries pull in conflicting versions of the same dependency. The versions come from the spring-boot-dependencies BOM, which is why you normally write no <version> for anything Spring Boot manages.

Choosing Starters for a Typical Project

• REST API with a SQL database: webmvc, data-jpa, validation, the JDBC driver (such as org.postgresql:postgresql), and actuator for health checks.
• Add login or JWT: security, or security-oauth2-resource-server for an API that accepts tokens.
• Calling other services: restclient for blocking calls, webclient for reactive ones.
• Only what you use: every extra starter adds startup work, attack surface and auto-configuration to understand, so remove the ones a project no longer needs.

Examples

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webmvc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

(No console output — this changes the resolved dependency tree; run "mvn dependency:tree" to confirm Tomcat, Jackson, Hibernate, and HikariCP are now present.)

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.1</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webmvc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
</dependencies>

$ mvn dependency:tree -Dscope=compile

+- org.springframework.boot:spring-boot-starter-webmvc:jar:4.1.1:compile
|  |  +- org.springframework.boot:spring-boot-starter-logging:jar:4.1.1:compile
|  |  |  +- ch.qos.logback:logback-classic:jar:1.5.38:compile
|  |     \- tools.jackson.core:jackson-databind:jar:3.1.5:compile
|  |  |  +- org.apache.tomcat.embed:tomcat-embed-core:jar:11.0.24:compile
|     \- org.springframework:spring-webmvc:jar:7.0.9:compile
+- org.springframework.boot:spring-boot-starter-actuator:jar:4.1.1:compile
|     \- io.micrometer:micrometer-core:jar:1.17.1:compile
+- org.springframework.boot:spring-boot-starter-validation:jar:4.1.1:compile
|     \- org.hibernate.validator:hibernate-validator:jar:9.1.3.Final:compile
\- org.springframework.boot:spring-boot-starter-data-jpa:jar:4.1.1:compile
   |  \- com.zaxxer:HikariCP:jar:7.0.2:compile
   |  |  +- org.hibernate.orm:hibernate-core:jar:7.4.5.Final:compile

(No versions were written in the POM; the parent's BOM chose all of them.)

Exercise

Using the lesson's Declaring starters in a Maven pom.xml example, create a small implementation or design sketch that demonstrates Starters bundle compatible sets of dependencies for a specific concern (web, data, security, testing).. Add a test case or scenario that would catch Following a Spring Boot 3 tutorial in a Boot 4 project and adding spring-boot-starter-web. It still works but is deprecated; use spring-boot-starter-webmvc., and describe the expected result.

Quick quiz

Interview questions