Spring Boot Starters

A Spring Boot starter is a single dependency that brings in everything a feature needs. A developer adds one line to the project file and receives a tested group of libraries that already work together. Starters keep project files short, clean, and free from version conflicts.

Older Java projects demanded careful shopping. A web application required a web framework, a JSON library, a logging library, and a server. Each library carried its own version number, and one wrong match produced confusing errors. Starters replace that shopping trip with ready-made bundles.

The Combo Meal Idea

Picture a restaurant menu. Ordering a burger, fries, and a drink one by one takes time and risks a mismatch. A combo meal delivers all three in a single order. A starter works like a combo meal for code: one order brings a complete set.

 Without a starter              With a starter

 [ Web framework ]              +-----------------------------+
 [ JSON library  ]              |  spring-boot-starter-web    |
 [ Logging       ]    ====>     |  (framework + JSON +        |
 [ Embedded server ]            |   logging + server)         |
 4 orders, 4 versions           +-----------------------------+
                                1 order, 0 version worries

Naming Pattern

Official starters follow the pattern spring-boot-starter-name. The name after the last hyphen describes the feature, such as web, data-jpa, or security. Third-party teams reverse the pattern and write name-spring-boot-starter, which keeps the official prefix reserved for the Spring team.

Popular Starters

Starter	What It Provides	Typical Use
spring-boot-starter-web	Spring MVC, JSON support, embedded Tomcat	REST APIs and web apps
spring-boot-starter-data-jpa	Spring Data JPA, Hibernate	Database access
spring-boot-starter-security	Spring Security	Login and access control
spring-boot-starter-validation	Bean Validation with Hibernate Validator	Input checks
spring-boot-starter-actuator	Health and metrics endpoints	Monitoring
spring-boot-starter-test	JUnit, Mockito, Spring Test	Automated tests

Adding a Starter

Maven projects list starters inside the dependencies block of pom.xml. The example below creates a web application with database support.

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

Gradle users write the same idea in one short line per starter.

implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

Neither example contains a version number. The build tool finds the correct version on its own.

How Version Management Works

Every Spring Boot project inherits from spring-boot-starter-parent, or imports the Spring Boot bill of materials (BOM). The BOM works like a price list that records one approved version for hundreds of libraries. When a starter asks for Jackson or Hibernate, the BOM supplies the exact version that the Spring Boot team tested.

 pom.xml
   |
   +--> spring-boot-starter-parent
            |
            +--> BOM: approved versions
                    |
                    +--> Jackson 2.x  | Hibernate 6.x | Tomcat 10.x ...

Overriding a Version

Some projects need a different version of a single library. A property in the pom.xml file overrides the BOM value. Use this option rarely, because each override moves the project away from the tested combination.

<properties>
    <java.version>17</java.version>
</properties>

Looking Inside a Starter

A starter contains no code of its own. Its pom file lists other dependencies, and those dependencies carry the real libraries. The command below prints the complete tree for a Maven project.

mvn dependency:tree

The tree for spring-boot-starter-web shows Spring MVC, Jackson for JSON, the Tomcat server, and Logback for logging. Reading the tree teaches a developer exactly what runs inside the application.

Excluding a Dependency

Spring Boot picks Tomcat as the default server. A team that prefers Jetty removes Tomcat from the web starter and adds the Jetty starter in its place.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

Starters and Auto Configuration

Starters and auto configuration form a team. The starter places libraries on the classpath. Auto configuration notices those libraries and sets up beans automatically. Add spring-boot-starter-data-jpa, and Spring Boot prepares a data source, an entity manager, and a transaction manager without a single line of setup code.

 Starter added  -->  Jars on classpath  -->  Auto configuration reacts  -->  Beans ready

Best Practices

• Add only the starters the project needs. Unused starters slow startup and enlarge the final jar file.
• Skip version numbers for any library that the BOM manages.
• Run the dependency tree command when an unexpected library appears.
• Keep the test starter in the test scope so that testing libraries stay out of production builds.
• Choose a starter before searching for individual libraries. A starter usually exists for common needs.

Mastering starters gives every developer faster project creation, cleaner build files, and fewer version surprises.