tessl/maven-org-springframework-boot--spring-boot-autoconfigure

Spring Boot AutoConfigure provides auto-configuration capabilities that automatically configure Spring applications based on jar dependencies present on the classpath

—

Pending

Overview

Eval results

Files

Configuration Basics

Name: tessl/maven-org-springframework-boot--spring-boot-autoconfigure
Author: tessl

Learn essential configuration concepts for Spring Boot AutoConfigure.

Configuration Sources

Spring Boot loads configuration from multiple sources (in order of precedence):

Command line arguments
Java System properties
OS environment variables
application.properties or application.yml
Default values

Application Properties

Location

Place in src/main/resources/application.properties:

# Server configuration
server.port=8080
server.servlet.context-path=/api

# Application name
spring.application.name=my-application

# Logging
logging.level.root=INFO
logging.level.com.example=DEBUG

YAML Format

Alternatively, use application.yml:

server:
  port: 8080
  servlet:
    context-path: /api

spring:
  application:
    name: my-application

logging:
  level:
    root: INFO
    com.example: DEBUG

Profile-Specific Configuration

Define Profiles

# application-dev.properties
server.port=8080
debug=true

# application-prod.properties
server.port=80
debug=false

Activate Profile

java -jar app.jar --spring.profiles.active=prod

Or in properties:

spring.profiles.active=dev

Configuration Properties Classes

Create Type-Safe Configuration

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private int timeout;
    private List<String> servers;
    
    // Getters and setters
}

Use in Properties File

app.name=My Application
app.timeout=30
app.servers[0]=server1.example.com
app.servers[1]=server2.example.com

Inject and Use

@Service
public class MyService {
    private final AppProperties properties;
    
    public MyService(AppProperties properties) {
        this.properties = properties;
    }
    
    public void doSomething() {
        String name = properties.getName();
        // Use configuration
    }
}

Excluding Auto-Configurations

By Class

@SpringBootApplication(exclude = {
    DataSourceAutoConfiguration.class,
    HibernateJpaAutoConfiguration.class
})
public class Application {
    // ...
}

By Name

@SpringBootApplication(excludeName = {
    "org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration"
})
public class Application {
    // ...
}

Via Properties

spring.autoconfigure.exclude=\
  org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
  org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

Conditional Configuration

Enable Features with Properties

@Configuration
@ConditionalOnProperty(
    prefix = "app.feature",
    name = "enabled",
    havingValue = "true"
)
public class FeatureConfiguration {
    @Bean
    public FeatureService featureService() {
        return new FeatureService();
    }
}

app.feature.enabled=true

Multiple Conditions

@Configuration
@ConditionalOnClass(DataSource.class)
@ConditionalOnProperty("app.database.enabled")
public class DatabaseConfiguration {
    // Configuration
}

Environment-Specific Beans

@Configuration
public class EnvironmentConfiguration {
    
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .build();
    }
    
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(env.getProperty("db.url"));
        return ds;
    }
}

Externalized Configuration

Environment Variables

export SERVER_PORT=8080
export SPRING_DATASOURCE_URL=jdbc:mysql://localhost/db

Maps to:

server.port=8080
spring.datasource.url=jdbc:mysql://localhost/db

Command Line

java -jar app.jar --server.port=8080 --spring.profiles.active=prod

Configuration Validation

Add Validation

import jakarta.validation.constraints.*;

@ConfigurationProperties(prefix = "app")
@Validated
public class AppProperties {
    
    @NotNull
    @Size(min = 1, max = 100)
    private String name;
    
    @Min(1)
    @Max(3600)
    private int timeout;
    
    @Email
    private String adminEmail;
    
    // Getters and setters
}

Enable Validation

Add dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

Common Configuration Patterns

Database Configuration

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=user
spring.datasource.password=pass
spring.jpa.hibernate.ddl-auto=update

Logging Configuration

logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.com.example=DEBUG
logging.file.name=app.log

Server Configuration

server.port=8080
server.compression.enabled=true
server.http2.enabled=true
server.ssl.enabled=false

Caching Configuration

spring.cache.type=caffeine
spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s

Best Practices

Use Type-Safe Configuration: Prefer @ConfigurationProperties over @Value
Validate Configuration: Add validation constraints
Document Properties: Add JavaDoc to configuration classes
Use Profiles: Separate dev/test/prod configurations
Externalize Secrets: Never commit passwords to version control
Provide Defaults: Set sensible defaults in code

Next Steps

Custom Auto-Configurations - Create your own
Advanced Conditions - Complex conditional logic
Configuration Reference - Complete API reference

tessl/maven-org-springframework-boot--spring-boot-autoconfigure