Custom Starters & Auto-Configuration Development

Spring Boot’s strength comes from starters and auto-configuration, which allow developers to plug in functionality automatically without manual wiring. Creating custom starters enables reusable, modular, and shareable components for applications or libraries.

Custom starters and auto-configuration help you:

• Simplify project setup across multiple applications
• Enforce consistent conventions and defaults
• Reduce boilerplate across microservices
• Package internal libraries with ready-to-use configuration

What Is a Spring Boot Starter?

A starter is a convenience dependency that bundles:

• Libraries required for a feature
• Auto-configuration classes to automatically set up beans
• Optional default properties

Examples:

Starters do not contain application logic; they only include dependencies and auto-configuration classes. They make projects plug-and-play.

What Is Auto-Configuration?

Auto-configuration automatically creates and registers beans in the Spring context based on classpath, application properties, and conditions.

Example:

@Configuration
@ConditionalOnClass(DataSource.class)
publicclassDataSourceAutoConfiguration {

@Bean
@ConditionalOnMissingBean
public DataSourcedataSource() {
returnnewHikariDataSource();
    }
}

Mechanism:

1. SpringFactoriesLoader reads metadata (spring.factories in Boot ≤2.x or AutoConfiguration.imports in Boot 3.x).
2. Auto-configuration classes are evaluated conditionally.
3. Beans are registered in the BeanDefinitionRegistry.

Auto-configuration allows apps to be “production-ready” with minimal setup.

Why Create Custom Starters?

• Reusable Modules: Share beans and configurations across projects.
• Plug-and-Play: Users get automatic configuration by including your starter.
• Encapsulation: Hide complex wiring behind a simple dependency.
• Standardization: Enforce consistent configuration across multiple apps.

Anatomy of a Custom Starter

A custom starter typically contains:

1. Starter Module – Contains pom.xml or Gradle dependencies:

<dependency>
<groupId>com.example</groupId>
<artifactId>my-library</artifactId>
<version>1.0.0</version>
</dependency>

2. Auto-Configuration Module – Contains @Configuration classes with conditional bean registration:

@Configuration
@ConditionalOnClass(MyService.class)
@EnableConfigurationProperties(MyServiceProperties.class)
publicclassMyServiceAutoConfiguration {

@Bean
@ConditionalOnMissingBean
public MyServicemyService(MyServiceProperties props) {
returnnewMyService(props.getUrl());
    }
}

3. Register Auto-Configuration

• Boot ≤2.x → META-INF/spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\\
com.example.autoconfig.MyServiceAutoConfiguration

• Spring Boot ≥3.x: META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

com.example.autoconfig.MyServiceAutoConfiguration

4. Optional Properties - Allows external configuration:

@ConfigurationProperties(prefix="my.service")
publicclassMyServiceProperties {
privateStringurl="<https://default.com>";
public StringgetUrl() {return url; }
publicvoidsetUrl(String url) {this.url = url; }
}

Step-by-Step Development Workflow

1. Create Library Code – Example: MyService class with configurable properties.
2. Create Auto-Configuration – Use @Configuration + conditional annotations.
3. Expose Properties – Use @ConfigurationProperties for external configuration.
4. Register Auto-Configuration – Add entry in spring.factories or AutoConfiguration.imports.
5. Package as Starter – Maven/Gradle module with minimal dependencies.
6. Test Starter – Verify auto-configuration works in a sample Spring Boot app.

Example Test App:

@SpringBootApplication
publicclassTestApplication {
publicstaticvoidmain(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }

@Autowired
private MyService myService;

@PostConstruct
publicvoidtest() {
        System.out.println(myService.getUrl());
    }
}

Expected output if overridden:

<https://custom-app.com>

Conditional Auto-Configuration

Spring Boot uses conditional annotations to make auto-configuration safe and opt-in:

Conditional checks ensure your starter is non-intrusive.

Best Practices for Custom Starters

• Use Conditional Annotations – prevent overriding user beans.
• Externalize Configuration – support application.properties or application.yml.
• Minimal Dependencies – avoid bringing unnecessary libraries into user projects.
• Provide Sensible Defaults – users should get a working starter out-of-the-box.
• Document Clearly – usage, properties, and examples.
• Test Thoroughly – verify auto-configuration, property binding, and conditional loading.
• Follow Spring Boot Conventions – ensure compatibility with Boot’s auto-configuration rules.

Benefits of Custom Starters

• Reusability: Share functionality across multiple projects or teams.
• Reduced Boilerplate: Automatic configuration eliminates repetitive setup.
• Consistency: Standardized defaults and best practices.
• Scalability: Easier maintenance in microservice ecosystems.
• Plug-and-Play: Users only need to include the starter dependency.

Integration with Spring Boot Internals

1. SpringApplication.run() triggers auto-configuration loading.
2. SpringFactoriesLoader reads starter metadata.
3. AutoConfigurationImportSelector imports auto-config classes.
4. Conditional evaluation ensures only valid beans are registered.
5. Beans are added to the ApplicationContext without manual wiring.

Flow Diagram Conceptually:

Project includes starter
      ↓
SpringApplication.run()
      ↓
SpringFactoriesLoader reads metadata
      ↓
AutoConfigurationImportSelector selects classes
      ↓
Conditional checks applied
      ↓
BeanDefinitions registered
      ↓
Beans instantiated (whenrequired)

Example Usage of a Custom Starter

application.properties:

my.service.url=https://api.example.com

Spring Boot App:

@SpringBootApplication
publicclassApp {
publicstaticvoidmain(String[] args) {
        SpringApplication.run(App.class, args);
    }

@Autowired
private MyService myService;

@PostConstruct
publicvoidcallService() {
        myService.call();
    }
}

Starter handles all wiring, configuration, and conditions automatically—no @Bean required in the app.

Key Takeaways

• Custom starters leverage Spring Boot auto-configuration and conditional bean registration
• They enable plug-and-play functionality and reusable modules
• Starters encapsulate dependencies, auto-configuration, and configuration properties
• Conditional annotations ensure non-intrusive integration
• Essential for building modular, maintainable, and production-ready Spring Boot applications

Conclusion

Custom starters and auto-configuration are powerful tools in Spring Boot. They enable:

• Faster project setup
• Reusable and modular libraries
• Consistent defaults across projects
• Reduced boilerplate in microservices
• Production-ready plug-and-play modules