Configuration and Autoconfiguration

Spring Boot prefers a Java-based configuration. Although you can use SpringApplication with XML sources, we generally recommend that the main source be a single class annotated with @Configuration. Typically, the class that defines the main method is a good candidate to be the main @Configuration.

Importing additional configuration classes

You don't need to put all @Configuration annotations in one class. You can use the @Import annotation to import additional configuration classes. Additionally, you can use the @ComponentScan annotation to automatically collect all Spring components, including classes with the @Configuration annotation.

Import XML configuration

If you absolutely must use XML-based configuration, we recommend starting with a class marked with the @Configuration annotation. You can then use the @ImportResource annotation to load the XML configuration files.

Auto-configuration

Auto-configuration in Spring Boot attempts to automatically configure your Spring application based on the added jar dependencies. For example, if HSQLDB is in your classpath, but you have not manually configured any beans to connect to the database, then Spring Boot will automatically configure a resident database.

You must explicitly opt-in to auto-configuration by adding the @EnableAutoConfiguration or @SpringBootApplication annotations to one of your classes with the @Configuration annotation.

Gradual replacement of auto-configuration

Auto-configuration works non-aggressively. You can start defining your own configuration at any time to replace certain parts of the auto-configuration. For example, if you add your own DataSource bean, embedded database support is disabled by default.

If you want to know which autoconfiguration is currently being applied and why, run the application with the --debug option. This will enable debug logs for the selected primary logging managers and output a condition report to the console.

Disable certain auto-configuration classes

If you find that there are certain autoconfiguration classes that you don't need, you can use the exclude attribute in the @SpringBootApplication annotation to disable them, as shown in the following example:

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
public class MyApplication {
}

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
@SpringBootApplication(exclude = [DataSourceAutoConfiguration::class])
class MyApplication

If the class is not on the classpath, you can use the excludeName attribute of the annotation and specify the full name instead. If you prefer to use the @EnableAutoConfiguration annotation rather than the @SpringBootApplication annotation, the exclude and excludeName functions will also be available. Finally, you can control the list of autoconfiguration classes that are excluded using the spring.autoconfigure.exclude property.

Spring Beans and Dependency Injection

You can use any of the standard Spring Framework tools to define your beans and their injectable dependencies. We generally recommend using constructor dependency injection to bind dependencies and the @ComponentScan annotation to find beans.

If you structure your code as suggested above (placing the application class in the top package), you can add the @ComponentScan annotation without any arguments, or use the @SpringBootApplication, which implicitly contains it. All components of your application (annotations @Component, @Service, @Repository, @Controller and others) are automatically registered like Spring beans.

The following example shows a bean marked with the @Service annotation that uses constructor dependency injection to obtain the required RiskAssessor bean:

import org.springframework.stereotype.Service;
@Service
public class MyAccountService implements AccountService {
    private final RiskAssessor riskAssessor;
    public MyAccountService(RiskAssessor riskAssessor) {
        this.riskAssessor = riskAssessor;
    }
    // ...
}

import org.springframework.stereotype.Service
@Service
class MyAccountService(private val riskAssessor: RiskAssessor) : AccountService

If a bean has more than one constructor, then you need to mark the one you want to use Spring with the @Autowired annotation:

import java.io.PrintStream;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class MyAccountService implements AccountService {
    private final RiskAssessor riskAssessor;
    private final PrintStream out;
    @Autowired
    public MyAccountService(RiskAssessor riskAssessor) {
        this.riskAssessor = riskAssessor;
        this.out = System.out;
    }
    public MyAccountService(RiskAssessor riskAssessor, PrintStream out) {
        this.riskAssessor = riskAssessor;
        this.out = out;
    }
    // ...
}

import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import java.io.PrintStream
@Service
class MyAccountService : AccountService {
    private val riskAssessor: RiskAssessor
    private val out: PrintStream
    @Autowired
    constructor(riskAssessor: RiskAssessor) {
        this.riskAssessor = riskAssessor
        out = System.out
    }
    constructor(riskAssessor: RiskAssessor, out: PrintStream) {
        this.riskAssessor = riskAssessor
        this.out = out
    }
    // ...
}