Unlock Spring Boot Starters: How Auto‑Configuration Simplifies Your Projects

1. Spring Boot Starter Overview

Before Spring Boot, building a web project with Spring MVC required manually adding dependencies, configuring DispatcherServlet in web.xml, writing springmvc-servlet.xml, and setting up the data source and transaction manager in applicationContext.xml. This caused dependency‑management and configuration‑complexity problems.

Spring Boot solves these issues with starters , which bundle all required dependencies for a specific scenario and let you configure the feature with only a few properties.

2. How Spring Boot Starters Work

When a starter is on the classpath, Spring Boot performs two main tasks:

Automatic import of related components.

Automatic configuration of those components.

These tasks are collectively called auto‑configuration .

2.1 Auto‑Configuration Principle

The entry point is the @SpringBootApplication annotation. Spring Boot reads META-INF/spring.factories to obtain all classes listed under EnableAutoConfiguration. Each listed class is an xxxAutoConfiguration class that registers beans and binds them to xxxProperties objects.

Key classes involved: AutoConfigurationImportSelector – selects which auto‑configuration classes to import. spring.factories – lists all candidate auto‑configuration classes.

Typical auto‑configuration class uses @Configuration, conditional annotations (e.g., @ConditionalOnClass, @ConditionalOnProperty), and @EnableConfigurationProperties to bind configuration properties.

@Configuration
@ConditionalOnClass(CharacterEncodingFilter.class)
@ConditionalOnProperty(prefix="spring.http.encoding", name="enabled", matchIfMissing=true)
@EnableConfigurationProperties(HttpProperties.class)
public class HttpEncodingAutoConfiguration {
    private final HttpProperties.Encoding properties;
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }
    @Bean
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
        return filter;
    }
}

During startup Spring Boot evaluates the conditions; if they match, the configuration class becomes active, registers its beans, and the properties defined in application.yml (or application.properties) override the defaults.

2.2 Using Auto‑Configuration Reports

Setting debug=true in the configuration file makes Spring Boot print a report that lists positive and negative matches, helping you understand which auto‑configuration classes are applied.

3. Creating a Custom Starter

3.1 Naming Convention

Official namespace: spring-boot-starter-* (e.g., spring-boot-starter-web).

Custom namespace: *-spring-boot-starter (e.g., mybatis-spring-boot-starter).

3.2 Module Structure

A starter consists of two parts: xxxAutoConfiguration – the auto‑configuration class that creates and configures beans. xxxProperties – a POJO annotated with @ConfigurationProperties that holds configurable fields.

The starter module only declares dependencies on the auto‑configuration module and any other libraries needed at runtime.

3.3 Developing the Auto‑Configuration Module

3.3.1 Dependencies

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

3.3.2 Implementing xxxAutoConfiguration

Annotate the class with @Configuration, appropriate @Conditional annotations, and @EnableConfigurationProperties(xxxProperties.class). Inject the properties bean and define @Bean methods that create and configure the required components.

3.3.3 Implementing xxxProperties

Define fields for each configurable option, provide getters/setters, and annotate the class with @ConfigurationProperties(prefix="your.prefix").

3.3.4 Registering in spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.xxxAutoConfiguration

3.4 Developing the Starter Module

The starter’s pom.xml adds a dependency on the auto‑configuration module and any runtime libraries. No Java code is needed; the starter merely aggregates the dependencies.

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>xxx-spring-boot-autoconfigure</artifactId>
    </dependency>
    <!-- other runtime dependencies -->
</dependencies>

After building and publishing the two modules to a Maven repository, other projects can include the starter to obtain the auto‑configured functionality with minimal configuration.