Auto-configuration

1. Definíció

A Spring Boot auto-configuration mechanizmus automatikusan konfigurálja az alkalmazás Spring bean-jeit a classpath-on található library-k, a meglévő bean definíciók és a property-k alapján. A @EnableAutoConfiguration annotáció (amely a @SpringBootApplication része) aktiválja ezt a rendszert. Az auto-configuration lényege, hogy a fejlesztőnek ne kelljen kézzel konfigurálnia azt, amit a framework ki tud következtetni — "convention over configuration" elv.

Például ha a classpath-on van a spring-boot-starter-data-jpa és egy H2 driver, a Spring Boot automatikusan létrehoz egy DataSource-t, egy EntityManagerFactory-t és egy TransactionManager-t.

---

2. Alapfogalmak

@EnableAutoConfiguration

A @SpringBootApplication meta-annotáció három dolgot tartalmaz:

@SpringBootConfiguration   // = @Configuration
@EnableAutoConfiguration   // auto-config aktiválás
@ComponentScan             // component scanning
public @interface SpringBootApplication {}

A @EnableAutoConfiguration indítja el az auto-configuration keresést. A Spring Boot 3.x-ben az META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports fájl tartalmazza a regisztrált auto-configuration osztályokat.

Conditional annotációk

Az auto-configuration osztályok @Conditional* annotációkkal vezérlik, mikor aktiválódjanak:

Annotáció	Feltétel
@ConditionalOnClass	Adott osztály a classpath-on van
@ConditionalOnMissingClass	Adott osztály NINCS a classpath-on
@ConditionalOnBean	Adott bean létezik a context-ben
@ConditionalOnMissingBean	Adott bean NEM létezik (felhasználói override)
@ConditionalOnProperty	Property adott értékkel rendelkezik
@ConditionalOnWebApplication	Web alkalmazás context
@ConditionalOnResource	Adott resource elérhető
@ConditionalOnExpression	SpEL kifejezés igaz

A "back off" elv

Az auto-configuration háttérbe lép, ha a fejlesztő saját bean-t definiál. Ez a @ConditionalOnMissingBean annotációval valósul meg:

@AutoConfiguration
@ConditionalOnClass(DataSource.class)
public class DataSourceAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean  // Ha a fejlesztő definiált DataSource-t, ez nem fut
    public DataSource dataSource(DataSourceProperties props) {
        return props.initializeDataSourceBuilder().build();
    }
}

spring.factories vs AutoConfiguration.imports

Verzió	Regisztrációs mechanizmus
Spring Boot 2.x	META-INF/spring.factories (EnableAutoConfiguration kulcs)
Spring Boot 3.x	META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

A Spring Boot 3.x továbbra is támogatja a spring.factories-t visszamenőleges kompatibilitás céljából, de az új megközelítés ajánlott.

---

3. Gyakorlati használat

Auto-configuration kizárás

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

Vagy property-vel:

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

Auto-configuration felülbírálás saját bean-nel

@Configuration
public class MyDataSourceConfig {
    @Bean
    public DataSource dataSource() {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl("jdbc:postgresql://localhost/mydb");
        ds.setUsername("admin");
        return ds;
    }
}
// A DataSourceAutoConfiguration @ConditionalOnMissingBean miatt háttérbe lép

Debug: melyik auto-config aktív?

# application.properties
debug=true

Ez kiírja a Conditions Evaluation Report-ot az induláskor:

• Positive matches: aktív auto-configuration osztályok
• Negative matches: inaktív (feltétel nem teljesült)
• Unconditional classes: feltétel nélküli konfigurációk

Actuator endpoint

management.endpoints.web.exposure.include=conditions

A /actuator/conditions endpoint JSON formátumban adja vissza ugyanezt az információt futásidőben.

---

4. Kód példák

Egyszerű auto-configuration osztály

@AutoConfiguration
@ConditionalOnClass(ObjectMapper.class)
@EnableConfigurationProperties(JsonProperties.class)
public class JsonAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public ObjectMapper objectMapper(JsonProperties props) {
        ObjectMapper mapper = new ObjectMapper();
        if (props.isIndentOutput()) {
            mapper.enable(SerializationFeature.INDENT_OUTPUT);
        }
        return mapper;
    }
}

ConfigurationProperties a property-khez

@ConfigurationProperties(prefix = "app.json")
public class JsonProperties {
    private boolean indentOutput = false;

    public boolean isIndentOutput() { return indentOutput; }
    public void setIndentOutput(boolean v) { this.indentOutput = v; }
}

app.json.indent-output=true

Saját auto-configuration modul (library)

my-library/
├── src/main/java/com/example/
│   └── MyLibraryAutoConfiguration.java
└── src/main/resources/META-INF/spring/
    └── org.springframework.boot.autoconfigure.AutoConfiguration.imports

Az .imports fájl tartalma:

com.example.MyLibraryAutoConfiguration

@AutoConfiguration ordering

@AutoConfiguration(
    after = DataSourceAutoConfiguration.class,
    before = JpaRepositoriesAutoConfiguration.class
)
public class MyAutoConfiguration { ... }

---

5. Trade-offok

Szempont	Előny	Hátrány
Automatikus konfiguráció	Gyors fejlesztés, kevés boilerplate	"Mágia" — nehéz megérteni, mi történik
Convention over configuration	Egységes projekt struktúra	Egyedi igényeknél több override szükséges
@ConditionalOnMissingBean	Felhasználó bármit felülbírálhat	Ha nem ismered, nem tudod, hogyan
debug=true	Teljes átláthatóság	Nagyon verbose output
Saját auto-config modul	Újrahasználható library-k	Extra komplexitás, tesztelés nehezebb

Mikor NE auto-configuration?

• Nagyon egyedi konfiguráció: ha sok override kell, explicit config tisztább
• Performance-kritikus indulás: sok auto-config osztály lassítja a startup-ot
• Library fejlesztés: gondosan tervezd a conditional logikát

---

6. Gyakori hibák

❌ Auto-config override nem működik

// ROSSZ — a @Bean metódus a @SpringBootApplication osztályban van
// A component scan korábban futhat, mint az auto-config
@SpringBootApplication
public class MyApp {
    @Bean
    public DataSource dataSource() { ... } // Lehet, hogy nem bírálja felül!
}

// JÓ — külön @Configuration osztály
@Configuration
public class MyDataSourceConfig {
    @Bean
    public DataSource dataSource() { ... }
}

❌ Exclude elírás

// ROSSZ — nem létező osztály, csendben ignorálja
@SpringBootApplication(exclude = {NonExistentAutoConfiguration.class})

// JÓ — excludeName string-gel, ha a class nincs a classpath-on
@SpringBootApplication(excludeName = "com.example.SomeAutoConfiguration")

❌ @ConditionalOnBean sorrend probléma

// ROSSZ — a @ConditionalOnBean nem garantálja a sorrendet
// Ha a bean-t más auto-config hozza létre, az ordering fontos
@AutoConfiguration
public class MyConfig {
    @Bean
    @ConditionalOnBean(DataSource.class) // DataSource lehet, hogy még nem jött létre!
    public MyRepo repo(DataSource ds) { ... }
}

// JÓ — explicit ordering
@AutoConfiguration(after = DataSourceAutoConfiguration.class)
public class MyConfig { ... }

❌ @ComponentScan a saját auto-config library-ban

// ROSSZ — az auto-config library NE használjon @ComponentScan-t
// Mert az alkalmazás csomagjai is bekerülhetnek
@AutoConfiguration
@ComponentScan("com.example") // Veszélyes!
public class LibraryAutoConfig { ... }

// JÓ — explicit @Bean definíciók
@AutoConfiguration
public class LibraryAutoConfig {
    @Bean
    public MyService myService() { return new MyService(); }
}

---

7. Mélyebb összefüggések

Auto-configuration betöltési folyamat

1. SpringApplication.run() elindul
2. @EnableAutoConfiguration → AutoConfigurationImportSelector aktiválódik
3. Beolvassa az .imports fájlokat (és legacy spring.factories-t)
4. Összegyűjti az összes auto-configuration osztályt
5. Kiszűri a @Conditional* alapján (feltétel kiértékelés)
6. A maradék osztályokat bean definícióként regisztrálja
7. Az @AutoConfiguration(after/before) meghatározza a sorrendet

@Conditional belső működés

Minden @Conditional* annotáció mögött egy Condition interfész implementáció áll:

public interface Condition {
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

A ConditionContext hozzáférést ad:

• BeanDefinitionRegistry — meglévő bean definíciók
• Environment — property-k és profile-ok
• ResourceLoader — classpath erőforrások
• ClassLoader — classpath osztályok ellenőrzése

Auto-configuration vs @Configuration

Szempont	@AutoConfiguration	@Configuration
Betöltés	.imports fájlból	Component scan / @Import
Sorrend	after/before attribútumokkal	Nincs garantált sorrend
Cél	Framework/library default-ok	Alkalmazás-specifikus config
@ConditionalOnMissingBean	Jellemző (back-off)	Ritka

Saját Condition implementáció

public class OnProductionCondition implements Condition {
    @Override
    public boolean matches(ConditionContext ctx, AnnotatedTypeMetadata metadata) {
        String env = ctx.getEnvironment().getProperty("app.env");
        return "production".equals(env);
    }
}

@Configuration
@Conditional(OnProductionCondition.class)
public class ProductionOnlyConfig { ... }

GraalVM Native és auto-configuration

A Spring Boot 3.x native image támogatásánál az auto-configuration compile-time-ban értékelődik ki (AOT processing). Ez gyorsabb indulást eredményez, de a runtime @Conditional kiértékelés nem elérhető.

---

8. Interjúkérdések

1. Hogyan működik a Spring Boot auto-configuration? A @EnableAutoConfiguration aktiválja az AutoConfigurationImportSelector-t, amely beolvassa az .imports fájlokat, összegyűjti az auto-config osztályokat, kiértékeli a @Conditional* annotációkat, és regisztrálja a teljesülő bean definíciókat.

2. Mi a @ConditionalOnMissingBean szerepe? Ha a fejlesztő már definiált egy azonos típusú bean-t, az auto-configuration háttérbe lép (back-off). Ez lehetővé teszi a felülbírálást anélkül, hogy kizárnád az egész auto-config osztályt.

3. Hogyan derítheted ki, mely auto-configuration-ök aktívak? debug=true property → Conditions Evaluation Report a logban. Vagy /actuator/conditions endpoint.

4. Mi a különbség a spring.factories és az .imports fájl között? spring.factories a Spring Boot 2.x megközelítés (kulcs-érték párok). Az .imports fájl a 3.x standard (soronként egy osztály). Mindkettő az auto-config osztályokat regisztrálja.

5. Hogyan írsz saját auto-configuration-t? @AutoConfiguration osztály + @Conditional* annotációk + .imports fájl a META-INF/spring/ alatt. Használj @ConditionalOnMissingBean-t a back-off logikához.

6. Miért nem szabad @ComponentScan-t használni auto-config library-ban? Mert az alkalmazás csomagjait is beszkennelheti, váratlan bean-eket regisztrálva. Auto-config library-ban explicit @Bean definíciókat használj.

7. Mi az auto-configuration ordering és miért fontos? Az @AutoConfiguration(after/before) vezérli a betöltési sorrendet. Fontos, ha egy auto-config bean függ egy másik auto-config bean-től (pl. DataSource szükséges a JPA auto-config-hoz).

---

9. Szószedet

Fogalom	Jelentés
@EnableAutoConfiguration	Auto-config aktiváló annotáció
@AutoConfiguration	Auto-configuration osztályt jelölő annotáció (Boot 3.x)
@ConditionalOnClass	Feltétel: osztály a classpath-on
@ConditionalOnMissingBean	Feltétel: nincs ilyen bean → back-off logika
@ConditionalOnProperty	Feltétel: property értéke
spring.factories	Legacy (2.x) auto-config regisztrációs fájl
AutoConfiguration.imports	Modern (3.x) auto-config regisztrációs fájl
AutoConfigurationImportSelector	Az osztály, ami beolvassa és szűri az auto-config-okat
Conditions Evaluation Report	Debug output az aktív/inaktív auto-config-okról
Back-off	Auto-config háttérbe lépése, ha a fejlesztő definiált bean-t
Convention over configuration	Keretrendszer-szintű alapértelmezések, minimális config
AOT processing	Compile-time auto-config kiértékelés (GraalVM native)

---

10. Gyorsreferencia

Auto-configuration aktiválás:
  @SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan

Regisztráció:
  Boot 3.x:  META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
  Boot 2.x:  META-INF/spring.factories (EnableAutoConfiguration kulcs)

Legfontosabb @Conditional annotációk:
  @ConditionalOnClass(Foo.class)          classpath-on van
  @ConditionalOnMissingBean(Foo.class)    nincs ilyen bean (back-off)
  @ConditionalOnProperty(name="x")        property létezik/értéke
  @ConditionalOnBean(Foo.class)           bean létezik

Back-off minta:
  @Bean
  @ConditionalOnMissingBean
  public Foo foo() { ... }   // fejlesztő felülbírálhatja

Kizárás:
  @SpringBootApplication(exclude = {FooAutoConfiguration.class})
  spring.autoconfigure.exclude=com.example.FooAutoConfiguration

Debug:
  debug=true                              → Conditions Evaluation Report
  /actuator/conditions                    → JSON a futó feltételekről

Ordering:
  @AutoConfiguration(after = A.class, before = B.class)

Tipikus hibák:
  ✗ @Bean override a @SpringBootApplication osztályban
  ✗ @ConditionalOnBean sorrend probléma
  ✗ @ComponentScan auto-config library-ban
  ✗ spring.factories használata Boot 3.x-ben (deprecated)