Java Academy · leksjon

Autokonfigurering og Spring Boot-startere

Forstå hvordan Spring Boot autokonfigurerer beans basert på avhengigheter på classpath-en og betingelsesannotasjoner.

Leksjon 1 av 413 trinn

Autokonfigurering og Spring Boot-startere er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva er autokonfigurasjon i Spring Boot?

Autokonfigurasjon konfigurerer Spring-bønner automatisk basert på det som finnes på klassestien og i miljøet. Dette eliminerer manuell konfigurering av @Bean for vanlige integrasjoner.

Annotasjonen @SpringBootApplication

@SpringBootApplication er en sammensetning av @Configuration, @EnableAutoConfiguration og @ComponentScan. Den aktiverer autokonfigurasjon og komponentskanning.

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

Slik fungerer autokonfigurasjon

Spring Boot skanner META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports (Spring Boot 3) etter en liste over autokonfigurasjonsklasser. Hver klasse tas i bruk basert på betingelser.

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

@ConditionalOnClass og @ConditionalOnMissingBean

Autokonfigurasjonsklasser bruker @Conditional-annotasjoner for bare å tas i bruk når bestemte betingelser er oppfylt – for eksempel når en klasse finnes på klassestien, eller når en bønne ikke allerede er definert.

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

Spring Boot-startere

En starter er et kuratert sett med avhengighetsbeskrivelser. Når spring-boot-starter-web legges til i prosjektet, hentes Spring MVC, Tomcat, Jackson og deres autokonfigurasjoner inn – uten manuell leting etter avhengigheter.

// 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"
}

Vanlige startere

Viktige startere: starter-web (REST + Tomcat), starter-data-jpa (JPA + Hibernate), starter-security, starter-test (JUnit + Mockito), starter-actuator (helse/metrics).

Overstyre autokonfigurasjon

Definer Deres egen @Bean av samme type for å gi den forrang fremfor autokonfigurerte bønner. @ConditionalOnMissingBean sørger for at den autokonfigurerte bønnen bare opprettes hvis Deres mangler.

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

Ekskludere autokonfigurasjon

Ekskluder bestemte autokonfigurasjonsklasser De ikke ønsker – nyttig når en starter tar med noe De vil konfigurere manuelt.

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

Opprette en egen starter

Opprett en startermodul med en autokonfigurasjonsklasse, og registrer den i META-INF/spring/....AutoConfiguration.imports. Andre prosjekter som inkluderer starteren, får automatisk bønnene Deres.

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

Feilsøke autokonfigurasjon

Kjør med flagget --debug, eller angi logging.level.org.springframework.boot.autoconfigure=DEBUG, for å se en "CONDITIONS EVALUATION REPORT" som viser hvilke autokonfigurasjoner som ble tatt i bruk eller utelatt, og hvorfor.

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

Actuator-endepunktet /conditions

Aktiver spring-boot-starter-actuator og eksponer endepunktet /actuator/conditions for å se rapporten over autokonfigurasjonsevalueringen under kjøring, uten omstart.

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

Hurtigsjekk

Hvilken annotasjon sørger for at en bønne bare opprettes hvis ingen bønne av denne typen allerede er definert?

Besvar den i den interaktive leksjonen

Oppsummering

Autokonfigurasjon bruker betingelsesannotasjoner til å koble sammen bønner basert på klassestien og eksisterende bønner. Startere samler avhengigheter og autokonfigurasjon. Overstyr med egne bønner. Ekskluder uønskede konfigurasjoner. Feilsøk med --debug.

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Autokonfigurering og Spring Boot-startere» gratis?

Ja – hele teksten i «Autokonfigurering og Spring Boot-startere» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Autokonfigurering og Spring Boot-startere»?

Forstå hvordan Spring Boot autokonfigurerer beans basert på avhengigheter på classpath-en og betingelsesannotasjoner. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Autokonfigurering og Spring Boot-startere»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Autokonfigurering og Spring Boot-startere
Applikasjonsegenskaper og profiler
Bean-kobling: @Component, @Service, @Repository
Konstruktørinjeksjon og sirkulære avhengigheter

← Tilbake til Java Academy