Java Academy · Lektion

Automatische Konfiguration und Spring-Boot-Starter

Verstehen Sie, wie Spring Boot Beans anhand von Classpath-Abhängigkeiten und Bedingungsannotationen automatisch konfiguriert.

Automatische Konfiguration und Spring-Boot-Starter ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist die Autokonfiguration von Spring Boot?

Die Autokonfiguration konfiguriert Spring-Beans automatisch anhand dessen, was im Klassenpfad und in der Umgebung vorhanden ist. Für gängige Integrationen entfällt dadurch die manuelle Einrichtung mit @Bean.

Die Annotation @SpringBootApplication

@SpringBootApplication ist eine Kombination aus @Configuration, @EnableAutoConfiguration und @ComponentScan. Sie aktiviert die Autokonfiguration und das Scannen von Komponenten.

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

So funktioniert die Autokonfiguration

Spring Boot durchsucht META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports (Spring Boot 3) nach einer Liste von Autokonfigurationsklassen. Jede Klasse wird bedingt angewendet.

// Spring Boot 3 imports file:
// org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
// org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration

@ConditionalOnClass und @ConditionalOnMissingBean

Autokonfigurationsklassen verwenden @Conditional-Annotationen, damit sie nur angewendet werden, wenn bestimmte Bedingungen erfüllt sind – etwa wenn sich eine Klasse im Klassenpfad befindet oder noch keine Bean definiert wurde.

@AutoConfiguration
@ConditionalOnClass(DataSource.class)
@ConditionalOnMissingBean(DataSource.class)
public class DataSourceAutoConfiguration {
    @Bean
    public DataSource dataSource(DataSourceProperties props) {
        return DataSourceBuilder.create().build();
    }
}

Spring-Boot-Starters

Ein Starter ist eine kuratierte Sammlung von Abhängigkeitsbeschreibungen. Wenn Sie spring-boot-starter-web zu Ihrem Projekt hinzufügen, werden Spring MVC, Tomcat, Jackson und deren Autokonfigurationen eingebunden – ohne dass Sie Abhängigkeiten manuell zusammensuchen müssen.

// build.gradle:
dependencies {
    implementation "org.springframework.boot:spring-boot-starter-web"
    implementation "org.springframework.boot:spring-boot-starter-data-jpa"
    implementation "org.springframework.boot:spring-boot-starter-validation"
}

Häufig verwendete Starter

Wichtige Starter: starter-web (REST + Tomcat), starter-data-jpa (JPA + Hibernate), starter-security, starter-test (JUnit + Mockito), starter-actuator (Statusüberwachung/Metriken).

Autokonfiguration überschreiben

Definieren Sie eine eigene @Bean desselben Typs, damit sie Vorrang vor der autokonfigurierten Bean erhält. @ConditionalOnMissingBean stellt sicher, dass die autokonfigurierte Bean nur erstellt wird, wenn Ihre Bean fehlt.

// Override auto-configured ObjectMapper:
@Configuration
public class JacksonConfig {
    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper()
            .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
            .registerModule(new JavaTimeModule());
    }
}

Autokonfiguration ausschließen

Schließen Sie bestimmte Autokonfigurationsklassen aus, die Sie nicht benötigen – beispielsweise wenn ein Starter etwas einbindet, das Sie manuell konfigurieren möchten.

@SpringBootApplication(exclude = {
    DataSourceAutoConfiguration.class,
    SecurityAutoConfiguration.class
})
public class MyApp { ... }

Einen eigenen Starter erstellen

Erstellen Sie ein Starter-Modul mit einer Autokonfigurationsklasse und registrieren Sie diese in META-INF/spring/....AutoConfiguration.imports. Andere Projekte, die Ihren Starter einbinden, erhalten Ihre Beans automatisch.

// my-starter/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports:
// com.example.MyLibraryAutoConfiguration

Autokonfiguration debuggen

Starten Sie die Anwendung mit dem Flag --debug oder setzen Sie logging.level.org.springframework.boot.autoconfigure=DEBUG, um einen „CONDITIONS EVALUATION REPORT“ mit den angewendeten oder ausgeschlossenen Autokonfigurationen und den jeweiligen Gründen anzuzeigen.

java -jar myapp.jar --debug
# Or in application.properties:
# logging.level.org.springframework.boot.autoconfigure=DEBUG

Actuator-Endpunkt /conditions

Aktivieren Sie spring-boot-starter-actuator und machen Sie den Endpunkt /actuator/conditions verfügbar, um den Bericht zur Autokonfigurationsauswertung zur Laufzeit ohne Neustart anzuzeigen.

# application.properties:
management.endpoints.web.exposure.include=conditions
# Then:
curl http://localhost:8080/actuator/conditions

Kurze Überprüfung

Welche Annotation bewirkt, dass eine Bean nur erstellt wird, wenn noch keine Bean dieses Typs definiert ist?

Zusammenfassung

Die Autokonfiguration verwendet bedingte Annotationen, um Beans anhand des Klassenpfads und vorhandener Beans zu verknüpfen. Starter bündeln Abhängigkeiten und Autokonfiguration. Überschreiben Sie die Konfiguration mit eigenen Beans und schließen Sie unerwünschte Konfigurationen aus. Debuggen Sie mit --debug.

Häufig gestellte Fragen

Ist die Lektion „Automatische Konfiguration und Spring-Boot-Starter“ kostenlos?

Ja — der vollständige Text von „Automatische Konfiguration und Spring-Boot-Starter“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Automatische Konfiguration und Spring-Boot-Starter“?

Verstehen Sie, wie Spring Boot Beans anhand von Classpath-Abhängigkeiten und Bedingungsannotationen automatisch konfiguriert. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Automatische Konfiguration und Spring-Boot-Starter“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Automatische Konfiguration und Spring-Boot-Starter
Anwendungseigenschaften und Profile
Bean-Verdrahtung: @Component, @Service, @Repository
Konstruktor-Injektion und zirkuläre Abhängigkeiten

← Zurück zu Java Academy