Woche 3, Tag 1 — Spring-Boot-Mental-Model und @SpringBootApplication im Detail

Ziel

Heute verstehst du, was Spring Boot wirklich macht.

Die Kernfragen:

Was ist Spring Boot?
Welches Problem löst Spring Boot?
Was ist der Unterschied zwischen Spring Framework und Spring Boot?
Was macht @SpringBootApplication?
Welche Annotationen stecken in @SpringBootApplication?
Was ist @Configuration?
Was ist @EnableAutoConfiguration?
Was ist @ComponentScan?
Was passiert, wenn SpringApplication.run(...) aufgerufen wird?
Welche typischen Prüfungsfallen gibt es?

1. Kurz-Wiederholung aus Woche 2

In Woche 2 hast du gelernt:

@Configuration markiert eine Klasse als Quelle von Bean-Definitionen.
@Bean markiert eine Methode, deren Rückgabewert zu einer Spring Bean wird.
Externe Konfiguration hält Umgebungswerte außerhalb des Java-Codes.
Profile steuern, welche Beans und Konfiguration aktiv sind.
Singleton ist der Standard-Bean-Scope.
Bean Lifecycle umfasst Erzeugung, Dependency Injection, Initialisierung, Post-Processing und Zerstörung.
BeanPostProcessor kann Beans mit Proxies wrappen.

Merksatz:

Spring erzeugt Beans, konfiguriert sie, scoped sie, initialisiert sie und kann sie mit Proxies wrappen.

Jetzt startest du mit Spring Boot.

2. Was ist Spring Boot?

Spring Boot ist ein Projekt, das auf dem Spring Framework aufbaut.

Es hilft dir, Spring-Anwendungen schneller und mit weniger manueller Konfiguration zu erstellen.

Einfache Definition:

Spring Boot macht Spring-Anwendungen einfacher zu konfigurieren, zu starten, auszuführen und zu deployen.

Spring Boot gibt dir:

starter dependencies
auto-configuration
embedded server
externalized configuration
production-ready features
Actuator
opinionated defaults
easy application startup

3. Welches Problem löst Spring Boot?

Vor Spring Boot brauchten Spring-Anwendungen oft viel manuelle Konfiguration.

Für eine Web-App musst du vielleicht konfigurieren:

DispatcherServlet
Tomcat
Jackson JSON converter
Spring MVC setup
DataSource
TransactionManager
JPA EntityManagerFactory
Security filters
Logging
Properties
Profiles

Spring Boot sagt:

Basierend auf dem, was im Classpath und in der Konfiguration liegt, kann ich viele Dinge automatisch einrichten.

Das spart Zeit und reduziert Boilerplate.

4. Spring Framework vs. Spring Boot

Spring Framework

Spring Framework liefert die Kernfeatures:

IoC container
Dependency Injection
AOP
Spring MVC
transactions
data access support
bean lifecycle
resource handling
validation support

Spring Boot

Spring Boot baut auf Spring Framework auf und ergänzt:

auto-configuration
starter dependencies
embedded web server
easy application startup
external configuration defaults
production-ready Actuator
opinionated setup

Merksatz:

Spring Framework ist das Fundament. Spring Boot macht Spring einfacher zu konfigurieren und auszuführen.

5. React-/Next.js-Vergleich

Mit deinem React-Hintergrund:

React allein liefert Component-Logik.

Next.js ergänzt:

routing
server rendering
build conventions
project structure
API routes
deployment-friendly defaults

Ähnliche Idee:

Spring Framework liefert Backend-Kernfeatures.

Spring Boot ergänzt:

startup conventions
auto-configuration
embedded server
starter dependencies
production defaults

Merksatz:

Spring Boot ist zu Spring, was Next.js zu React ist: eine starke Schicht mit Conventions und Production-Setup.

Das ist technisch nicht perfekt — aber ein hilfreiches Mental Model.

6. Eine minimale Spring-Boot-App

@SpringBootApplication
public class KlarsyncApplication {

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

Dieser kleine Code startet eine vollständige Spring-Boot-Anwendung.

Er kann:

create ApplicationContext
scan components
apply auto-configuration
load external config
start embedded Tomcat if web app
create beans
inject dependencies
run lifecycle callbacks

7. Was ist `@SpringBootApplication`?

@SpringBootApplication ist die Hauptannotation, die den Einstiegspunkt einer Spring-Boot-Anwendung markiert.

Sie kombiniert drei wichtige Annotationen:

@Configuration
@EnableAutoConfiguration
@ComponentScan

Merksatz für die Prüfung:

@SpringBootApplication ist eine Convenience-Annotation, die @Configuration, @EnableAutoConfiguration und @ComponentScan kombiniert.

8. Die drei Annotationen in `@SpringBootApplication`

@SpringBootApplication

ist ungefähr dasselbe wie:

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class KlarsyncApplication {
}

Bedeutung:

@Configuration          -> diese Klasse kann Beans definieren
@EnableAutoConfiguration -> Spring Boot konfiguriert Beans automatisch
@ComponentScan          -> Spring scannt deine Packages nach Components

9. Teil 1 — `@Configuration`

@Configuration bedeutet:

Diese Klasse kann Spring Bean-Definitionen enthalten.

Beispiel:

@Configuration
public class AppConfig {

    @Bean
    public Clock clock() {
        return Clock.systemUTC();
    }
}

In der Main-App-Klasse:

@SpringBootApplication
public class KlarsyncApplication {
}

Weil @SpringBootApplication @Configuration enthält, ist die Main-Klasse selbst auch eine Configuration-Klasse.

10. Kann ich `@Bean` in die Main Class packen?

Ja.

Beispiel:

@SpringBootApplication
public class KlarsyncApplication {

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

    @Bean
    public Clock clock() {
        return Clock.systemUTC();
    }
}

Das funktioniert.

In größeren Anwendungen ist es aber sauberer, separate Configuration-Klassen zu nutzen:

@Configuration
public class TimeConfig {

    @Bean
    public Clock clock() {
        return Clock.systemUTC();
    }
}

Merksatz:

Die Main Spring-Boot-Klasse ist auch eine Configuration-Klasse — halte sie aber schlank.

11. Teil 2 — `@ComponentScan`

@ComponentScan sagt Spring, Packages nach Components zu scannen.

Es findet Klassen mit:

@Component
@Service
@Repository
@Controller
@RestController
@Configuration

Beispiel:

@Service
public class TaskService {
}

Spring entdeckt sie per Component Scanning und registriert sie als Bean.

12. Standard Component Scanning in Spring Boot

Spring Boot startet Component Scanning im Package der Klasse mit @SpringBootApplication.

Beispiel:

package de.klarsync;

@SpringBootApplication
public class KlarsyncApplication {
}

Spring scannt:

de.klarsync
de.klarsync.task
de.klarsync.user
de.klarsync.client
de.klarsync.config
de.klarsync.security

Best Practice:

Pack die Main Spring-Boot-Klasse ins Root Package.

13. Schlechte Package-Struktur

Schlecht:

de.klarsync.app
└── KlarsyncApplication.java

de.klarsync.task
└── TaskService.java

Main-Klasse:

package de.klarsync.app;

@SpringBootApplication
public class KlarsyncApplication {
}

Spring scannt:


de.klarsync.app

Aber nicht automatisch:


de.klarsync.task

Also wird TaskService vielleicht keine Bean.

14. Teil 3 — `@EnableAutoConfiguration`

Das ist der „Spring-Boot-igste“ Teil.

@EnableAutoConfiguration sagt Spring Boot:

Konfiguriere die Anwendung automatisch basierend auf Classpath, Properties und vorhandenen Beans.

Beispiel:

Wenn Spring Boot sieht:


spring-boot-starter-web

im Classpath, kann es auto-konfigurieren:

embedded Tomcat
DispatcherServlet
Spring MVC
Jackson JSON conversion
error handling
web-related beans

Wenn Spring Boot sieht:


spring-boot-starter-data-jpa

kann es auto-konfigurieren:

DataSource
EntityManagerFactory
TransactionManager
Spring Data JPA repositories
Hibernate integration

15. Was ist Auto-Configuration?

Auto-Configuration bedeutet:

Spring Boot erzeugt automatisch Konfiguration und Beans basierend auf dem, was es in der Anwendung findet.

Es schaut auf:

classpath dependencies
existing beans
application properties
active profiles
web application type
conditions

Beispiel:

Wenn Jackson im Classpath liegt, konfiguriert Spring Boot JSON-Support.

Wenn Tomcat im Classpath liegt, startet Spring Boot einen embedded Webserver.

Wenn kein eigenes ObjectMapper existiert, kann Boot eines bereitstellen.

16. Auto-Configuration ist conditional

Spring Boot erzeugt nicht blind alles.

Es nutzt Conditions.

Häufige Conditions:

@ConditionalOnClass
@ConditionalOnMissingBean
@ConditionalOnBean
@ConditionalOnProperty
@ConditionalOnWebApplication

Beispiel-Idee:

@Bean
@ConditionalOnMissingBean
public ObjectMapper objectMapper() {
    return new ObjectMapper();
}

Bedeutung:


Create ObjectMapper only if the user has not already defined one.

Merksatz:

Auto-Configuration ist automatisch — aber conditional.

17. Wichtige Prüfungsfalle: Auto-Configuration

Spring-Boot-Auto-Configuration tritt in vielen Fällen zurück, wenn du eine eigene Bean definierst.

Beispiel:

Spring Boot kann ein ObjectMapper auto-konfigurieren.

Wenn du aber definierst:

@Bean
public ObjectMapper objectMapper() {
    return new ObjectMapper().findAndRegisterModules();
}

erzeugt die Auto-Configuration vielleicht kein Default-ObjectMapper mehr.

Warum?

Wegen Conditions wie:

@ConditionalOnMissingBean

Merksatz:

Deine eigene Bean kann Boots Default ersetzen, wenn Auto-Configuration zurücktritt.

18. Was sind Starter Dependencies?

Spring-Boot-Starter sind Dependency-Bundles.

Beispiel:

implementation("org.springframework.boot:spring-boot-starter-web")

Dieser Starter bringt Dependencies für Web-Apps, zum Beispiel:

Spring MVC
embedded Tomcat
Jackson
validation-related support depending on setup
logging

Weiteres Beispiel:

implementation("org.springframework.boot:spring-boot-starter-data-jpa")

Das bringt Dependencies für:

Spring Data JPA
Hibernate
JPA support
transaction support

19. Starter vs. Auto-Configuration

Diese Unterscheidung ist sehr wichtig.

Konzept	Bedeutung
Starter	Bringt Dependencies
Auto-configuration	Konfiguriert Beans basierend auf Dependencies

Beispiel:

spring-boot-starter-web puts Spring MVC and Tomcat on the classpath.
Auto-configuration sees them and configures a web app.

Merksatz:

Starters bringen Libraries. Auto-Configuration konfiguriert sie.

20. Embedded Server

Spring-Boot-Web-Apps laufen meist mit einem embedded Server.

Beispiel:

java -jar app.jar

Dann startet die App Tomcat intern.

Du musst keine WAR-Datei auf einem externen Tomcat deployen.

Spring Boot kann embedded nutzen:

Tomcat
Jetty
Undertow

Tomcat ist mit dem Web-Starter der übliche Default.

21. Traditionelles Spring MVC vs. Spring-Boot-Web-App

Traditioneller Stil:

Build WAR
Install external Tomcat
Deploy WAR to Tomcat
Configure servlet container

Spring-Boot-Stil:

Build executable JAR
Run java -jar app.jar
Embedded Tomcat starts automatically

Merksatz:

Spring-Boot-Anwendungen werden üblicherweise als executable JARs mit embedded Servern gepackt.

22. Was macht `SpringApplication.run(...)`?

Beispiel:

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

Vereinfachter Ablauf:

Create SpringApplication
Determine application type
Load environment and properties
Create ApplicationContext
Register configuration sources
Apply auto-configuration
Run component scanning
Register BeanDefinitions
Create singleton beans
Inject dependencies
Run lifecycle callbacks
Start embedded web server if needed
Run CommandLineRunner / ApplicationRunner
Application is ready

23. Wichtiger Startup-Flow

Kurzversion für die Prüfung:

SpringApplication.run creates and refreshes the ApplicationContext.
During startup, Spring loads configuration, scans components, applies auto-configuration, creates beans, injects dependencies, and starts the embedded web server if it is a web application.

Merksatz:

SpringApplication.run startet die Spring-Boot-Anwendung, indem es den ApplicationContext erzeugt und refreshed.

24. Was ist Application Type?

Spring Boot kann den Application Type erkennen.

Häufige Typen:

none
servlet web application
reactive web application

Wenn Spring MVC vorhanden ist:


servlet web app

Wenn Spring WebFlux vorhanden ist:


reactive web app

Wenn kein Web-Stack vorhanden ist:


non-web app

Für normale Spring-Boot-REST-APIs mit spring-boot-starter-web ist es eine servlet web application.

25. Was passiert mit `spring-boot-starter-web`?

Wenn du hinzufügst:

implementation("org.springframework.boot:spring-boot-starter-web")

erkennt Spring Boot Web-Dependencies und konfiguriert:

Servlet web application
embedded Tomcat
DispatcherServlet
Spring MVC
JSON serialization with Jackson
default error handling
HTTP message converters

Dann kannst du schreiben:

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    @GetMapping
    public List<String> tasks() {
        return List.of("Task 1", "Task 2");
    }
}

und es funktioniert mit wenig manuellem Setup.

26. Was passiert ohne `spring-boot-starter-web`?

Wenn du keine Web-Dependencies einbindest, dann ist:

@RestController

nicht sinnvoll — es gibt vielleicht keinen Webserver oder keine MVC-Infrastruktur.

Spring Boot startet vielleicht als non-web application.

Beispiel-Use-Cases:

batch job
CLI app
worker service
scheduled job
message consumer

Spring Boot ist nicht nur für Web-Apps.

27. Spring Boot ist opinionated

Spring Boot liefert opinionated Defaults.

Bedeutung:

Spring Boot wählt sinnvolle Defaults, damit du nicht alles manuell konfigurieren musst.

Beispiele:

default embedded Tomcat for web apps
default JSON handling with Jackson
default logging setup
default application.yml support
default error page / error response
default Actuator conventions

Du kannst diese Defaults aber bei Bedarf überschreiben.

Merksatz:

Spring Boot gibt Defaults — du kannst sie aber anpassen.

28. Spring Boot ersetzt Spring nicht

Wichtig:

Spring Boot ist kein Ersatz für Spring Framework.

Spring Boot nutzt Spring Framework.

Beispiel:

@Service
public class TaskService {
}

Das ist Spring-Framework-Component-Model.

@SpringBootApplication

Das ist Spring-Boot-Convenience.

@Transactional

Das ist Spring-Transaction-Support.

Spring Boot macht Konfiguration einfacher — die Kernkonzepte bleiben Spring.

29. Ist Spring Boot Magie?

Nein.

Spring Boot fühlt sich wie Magie an, weil viel automatisch passiert.

Aber es basiert auf:

classpath detection
conditional configuration
bean definitions
external properties
Spring IoC container
auto-configuration classes
starter dependencies

Merksatz:

Spring Boot ist keine Magie. Es ist conditional configuration.

30. Wie siehst du, was Boot konfiguriert hat?

Nützliche Tools:

startup logs
debug=true
Actuator /actuator/conditions
Actuator /actuator/beans
Actuator /actuator/configprops

In application.yml:

debug: true

oder per Command Line:

java -jar app.jar --debug

Das kann Auto-Configuration-Condition-Reports anzeigen.

31. Auto-Configuration Report

Der Auto-Configuration Report hilft zu beantworten:

Which auto-configurations matched?
Which did not match?
Why did they match?
Why did they not match?

Beispiel:

DataSourceAutoConfiguration matched because DataSource classes were found.
WebMvcAutoConfiguration matched because this is a servlet web application.
SomeSecurityAutoConfiguration did not match because required class was missing.

Sehr nützlich zum Debuggen.

32. Echte Frage: Warum hat Spring Boot diese Bean erzeugt?

Mögliche Gründe:

A starter dependency brought a class onto the classpath.
An auto-configuration class matched.
A property enabled the feature.
No custom bean existed, so @ConditionalOnMissingBean allowed default creation.

Beispiel:

I added spring-boot-starter-web.
Spring Boot found Spring MVC and Tomcat.
Web auto-configuration matched.
Spring Boot created web infrastructure beans.

33. Echte Frage: Warum hat Spring Boot diese Bean nicht erzeugt?

Mögliche Gründe:

Required class is missing from classpath.
Required property is false or missing.
A required bean is missing.
A user-defined bean already exists.
Application is not a web application.
Active profile does not match.
Auto-configuration was excluded.

Das siehst du meist im Condition Report.

34. Auto-Configuration ausschließen

Manchmal willst du eine bestimmte Auto-Configuration deaktivieren.

Beispiel:

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

Das sagt Spring Boot:


Do not apply DataSourceAutoConfiguration.

Nützlich, wenn Spring Boot eine Datenbank konfigurieren will, du aber keine brauchst.

35. Auto-Configuration Exclude in Properties

Du siehst auch:

spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

Für die Zertifizierung: kenn das Konzept:

Auto-Configuration kann bei Bedarf ausgeschlossen werden.

36. Typischer Bug: DataSource-Fehler

Problem:

Du fügst den JPA-Starter hinzu:

implementation("org.springframework.boot:spring-boot-starter-data-jpa")

konfigurierst aber keine Datenbank.

Spring Boot versucht, DataSource zu auto-konfigurieren.

Dann schlägt die App fehl:


Failed to configure a DataSource

Warum?

Weil der JPA-Starter database-bezogene Klassen auf den Classpath legt.

Spring Boot denkt:


This app probably needs a database.

Fix:

configure datasource
add embedded database for tests
remove JPA starter if not needed
exclude DataSourceAutoConfiguration if truly no database

37. Typischer Bug: Web-App startet nicht

Problem:

Du schreibst:

@RestController
public class TaskController {
}

aber die App stellt keine HTTP-Endpunkte bereit.

Möglicher Grund:


spring-boot-starter-web is missing

Ohne den Web-Starter startet Boot vielleicht keinen embedded Tomcat und konfiguriert kein Spring MVC.

Fix:

implementation("org.springframework.boot:spring-boot-starter-web")

38. Typischer Bug: Meine eigene Bean wird ignoriert

Problem:

Du definierst eine eigene Bean, aber Boot scheint eine andere zu nutzen.

Mögliche Gründe:

wrong bean type
wrong bean name
multiple beans exist
@Primary missing
@Qualifier missing
auto-configured bean still active
custom configuration class not scanned
profile does not match

Debuggen mit:

/actuator/beans
/actuator/conditions
startup logs

39. Prüfungsfrage: `@SpringBootApplication`

Frage:

Was enthält @SpringBootApplication?

Antwort:

Es enthält:

@Configuration
@EnableAutoConfiguration
@ComponentScan

40. Prüfungsfrage: Spring vs. Spring Boot

Frage:

Was ist der Unterschied zwischen Spring Framework und Spring Boot?

Antwort:

Spring Framework liefert die Kernfeatures wie IoC, Dependency Injection, AOP, MVC, Transactions und Data-Access-Support. Spring Boot baut auf Spring Framework auf und ergänzt auto-configuration, starter dependencies, embedded server support, externalized configuration conventions und production-ready features.

41. Prüfungsfrage: Auto-Configuration

Frage:

Was ist auto-configuration?

Antwort:

Auto-configuration ist Spring Boots Mechanismus, Beans automatisch basierend auf Classpath-Dependencies, vorhandenen Beans, Properties, Conditions und dem Application Type zu konfigurieren.

42. Prüfungsfrage: Starters

Frage:

Was ist ein Spring-Boot-Starter?

Antwort:

Ein Starter ist ein Dependency-Bundle, das häufig genutzte Dependencies für ein Feature zusammenfasst — zum Beispiel Web, JPA, Security oder Testing.

43. Prüfungsfrage: Starter vs. Auto-Configuration

Frage:

Was ist der Unterschied zwischen Starters und auto-configuration?

Antwort:

Starters bringen Dependencies auf den Classpath. Auto-configuration sieht diese Dependencies und konfiguriert Spring Beans basierend auf Conditions.

44. Prüfungsfrage: Embedded Server

Frage:

Was bedeutet embedded server in Spring Boot?

Antwort:

Embedded server heißt: Der Webserver — zum Beispiel Tomcat — läuft innerhalb der Spring-Boot-Anwendung. Die App kann als executable JAR mit java -jar gestartet werden, ohne auf einen externen Server zu deployen.

45. Prüfungsfrage: `@EnableAutoConfiguration`

Frage:

Was macht @EnableAutoConfiguration?

Antwort:

Es aktiviert Spring Boots auto-configuration-Mechanismus, der versucht, die Anwendung automatisch basierend auf Classpath, Properties, vorhandenen Beans und Conditions zu konfigurieren.

46. Prüfungsfrage: `SpringApplication.run`

Frage:

Was macht SpringApplication.run(...)?

Antwort:

Es startet die Spring-Boot-Anwendung, indem es den ApplicationContext erzeugt und refreshed, Konfiguration lädt, auto-configuration anwendet, Components scannt, Beans erzeugt, Dependencies injiziert, Lifecycle Callbacks ausführt und den embedded Server startet, wenn es eine Web-Anwendung ist.

47. Prüfungsfrage: Auto-Configuration Back Off

Frage:

Was bedeutet es, dass auto-configuration „backs off“?

Antwort:

Spring Boot erzeugt sein Default-Bean nicht, wenn du bereits ein passendes Bean definiert hast. Das wird oft über @ConditionalOnMissingBean gesteuert.

48. Prüfungsfrage: Auto-Configuration ausschließen

Frage:

Wie kann ich eine Auto-Configuration-Klasse ausschließen?

Antwort:

Eine Möglichkeit:

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

Eine andere: die Property spring.autoconfigure.exclude.

49. Interview-Antwort

Frage:

What is Spring Boot?

Gute Antwort:

Spring Boot ist ein Projekt auf dem Spring Framework, das es einfacher macht, Spring-Anwendungen zu erstellen, zu konfigurieren, auszuführen und zu deployen. Es liefert starter dependencies, auto-configuration, embedded server support, externalized configuration und production-ready features wie Actuator. Es reduziert manuelle Konfiguration — nutzt aber weiterhin Spring-Kernkonzepte wie IoC, Dependency Injection und Beans.

50. Interview-Antwort

Frage:

What does @SpringBootApplication do?

Gute Antwort:

@SpringBootApplication ist eine Convenience-Annotation, die @Configuration, @EnableAutoConfiguration und @ComponentScan kombiniert. @Configuration erlaubt der Klasse, Beans zu definieren. @EnableAutoConfiguration aktiviert Spring Boot, Beans automatisch basierend auf Classpath und Properties zu konfigurieren. @ComponentScan sagt Spring, das aktuelle Package und Subpackages nach Components wie Services, Repositories, Controllers und Configuration-Klassen zu scannen.

51. Interview-Antwort

Frage:

What is auto-configuration in Spring Boot?

Gute Antwort:

Auto-configuration ist Spring Boots Mechanismus, die Anwendung automatisch basierend auf dem zu konfigurieren, was es findet. Es prüft Classpath-Dependencies, vorhandene Beans, application properties, aktive Profile und Conditions. Wenn zum Beispiel spring-boot-starter-web im Classpath liegt, kann Spring Boot embedded Tomcat, Spring MVC, DispatcherServlet und JSON message converters konfigurieren. Auto-configuration ist conditional und kann zurücktreten, wenn du ein eigenes Bean definierst.

52. Interview-Antwort

Frage:

What is the difference between a starter and auto-configuration?

Gute Antwort:

Ein Starter ist ein Dependency-Bundle. Er bringt die nötigen Libraries für ein Feature — zum Beispiel Web oder JPA — auf den Classpath. Auto-configuration ist der Mechanismus, der diese Libraries anschaut und Spring Beans automatisch konfiguriert. Kurz: Starters bringen Dependencies, auto-configuration konfiguriert sie.

53. Interview-Antwort

Frage:

Why is Spring Boot not "magic"?

Gute Antwort:

Spring Boot wirkt wie Magie, weil vieles ohne manuelle Konfiguration funktioniert — aber es basiert auf klaren Mechanismen. Es nutzt starter dependencies, Classpath-Erkennung, conditional auto-configuration, externe Properties und den Spring IoC Container. Auto-Configuration-Klassen erzeugen Beans nur, wenn ihre Conditions matchen. Tools wie Debug-Logs und Actuator Condition Reports zeigen, warum eine Konfiguration gematcht hat oder nicht.

54. Kurze Code-Übung

Erstelle diese minimale App:

@SpringBootApplication
public class DemoApplication {

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

    @Bean
    public Clock clock() {
        return Clock.systemUTC();
    }
}

Erstelle einen Service:

@Service
public class TimeService {

    private final Clock clock;

    public TimeService(Clock clock) {
        this.clock = clock;
    }

    public Instant now() {
        return Instant.now(clock);
    }
}

Fragen:

Warum ist Clock eine Bean?
Warum kann TimeService Clock injizieren?
Welche Annotation in @SpringBootApplication erlaubt die @Bean-Methode?
Welche Annotation in @SpringBootApplication findet TimeService?

Antworten:

Weil die clock()-Methode mit @Bean annotiert ist.
Weil Spring Clock im ApplicationContext registriert.
@Configuration.
@ComponentScan.

55. Kurze Bug-Übung

Problem:

package de.klarsync.app;

@SpringBootApplication
public class KlarsyncApplication {
}

package de.klarsync.task;

@Service
public class TaskService {
}

Frage:

Warum wird TaskService vielleicht nicht gefunden?

Antwort:

Spring Boot scannt ab dem Package der Klasse mit @SpringBootApplication — hier de.klarsync.app. Das Package de.klarsync.task ist kein Subpackage von de.klarsync.app, also liegt es außerhalb des Standard-Scan-Pfads.

Bester Fix:


Move KlarsyncApplication to package de.klarsync.

56. Kurze Bug-Übung 2

Problem:

Du fügst hinzu:

implementation("org.springframework.boot:spring-boot-starter-data-jpa")

konfigurierst aber keine Datenbank.

Die App schlägt mit einem DataSource-Fehler fehl.

Frage:

Warum?

Antwort:

Der JPA-Starter bringt Database- und JPA-Klassen auf den Classpath. Spring Boots DataSource-Auto-Configuration sieht sie und versucht, eine DataSource zu konfigurieren. Weil keine Datenbank-Konfiguration vorliegt, schlägt der Start fehl.

Mögliche Fixes:

configure datasource
add embedded database for tests
remove JPA starter if not needed
exclude DataSourceAutoConfiguration if truly no database is needed

Übungsfragen

Frage 1

Was ist Spring Boot?

Antwort:

Spring Boot ist ein Projekt auf dem Spring Framework, das Spring-Anwendungen einfacher zu konfigurieren, auszuführen und zu deployen macht.

Frage 2

Welches Problem löst Spring Boot?

Antwort:

Spring Boot löst das Problem zu vieler manueller Konfiguration. Es liefert auto-configuration, starter dependencies, embedded Server, externalized configuration und production-ready Defaults.

Frage 3

Was ist der Unterschied zwischen Spring Framework und Spring Boot?

Antwort:

Spring Framework liefert die Kernfeatures wie IoC, Dependency Injection, AOP, MVC, Transactions und Data-Access-Support. Spring Boot baut darauf auf und ergänzt auto-configuration, Starters, embedded server support und einfacheren Application Startup.

Frage 4

Was enthält @SpringBootApplication?

Antwort:

@SpringBootApplication enthält:

@Configuration
@EnableAutoConfiguration
@ComponentScan

Frage 5

Was macht @Configuration in @SpringBootApplication?

Antwort:

@Configuration bedeutet: Die Main-Application-Klasse kann als Quelle von Bean-Definitionen dienen.

Frage 6

Was macht @ComponentScan in @SpringBootApplication?

Antwort:

@ComponentScan sagt Spring, das Package der Main-Klasse und ihre Subpackages nach Components wie Services, Repositories, Controllers und Configuration-Klassen zu scannen.

Frage 7

Was macht @EnableAutoConfiguration?

Antwort:

@EnableAutoConfiguration aktiviert Spring Boots auto-configuration-Mechanismus.

Frage 8

Wo scannt Spring Boot standardmäßig Components?

Antwort:

Spring Boot scannt ab dem Package der Klasse mit @SpringBootApplication und deren Subpackages.

Frage 9

Warum soll die Main Spring-Boot-Klasse im Root Package liegen?

Antwort:

Die Main-Klasse soll im Root Package liegen, damit Spring alle App-Subpackages automatisch scannen kann.

Frage 10

Was ist auto-configuration?

Antwort:

Auto-configuration ist Spring Boots Mechanismus, Beans automatisch basierend auf Classpath-Dependencies, vorhandenen Beans, Properties, Conditions und Application Type zu konfigurieren.

Frage 11

Was bedeutet es, dass auto-configuration conditional ist?

Antwort:

Spring Boot erzeugt Beans nur, wenn bestimmte Conditions matchen — zum Beispiel eine Klasse vorhanden ist, eine Property aktiv ist oder ein Bean fehlt.

Frage 12

Wofür wird @ConditionalOnMissingBean genutzt?

Antwort:

@ConditionalOnMissingBean erzeugt ein Bean nur, wenn du noch kein passendes Bean definiert hast.

Frage 13

Was bedeutet es, dass auto-configuration zurücktritt?

Antwort:

Auto-configuration tritt zurück, wenn es sein Default-Bean nicht erzeugt, weil du bereits ein passendes Bean definiert hast.

Frage 14

Was ist ein Spring-Boot-Starter?

Antwort:

Ein Spring-Boot-Starter ist ein Dependency-Bundle, das häufige Dependencies für ein Feature wie Web, JPA, Security oder Testing zusammenfasst.

Frage 15

Was ist der Unterschied zwischen einem Starter und auto-configuration?

Antwort:

Ein Starter bringt Dependencies auf den Classpath. Auto-configuration konfiguriert Beans basierend auf diesen Dependencies und weiteren Conditions.

Frage 16

Was bedeutet embedded Tomcat?

Antwort:

Embedded Tomcat heißt: Tomcat läuft innerhalb der Spring-Boot-Anwendung. Du kannst die App als executable JAR mit java -jar starten.

Frage 17

Was macht SpringApplication.run(...)?

Antwort:

SpringApplication.run(...) startet die Spring-Boot-Anwendung, indem es den ApplicationContext erzeugt und refreshed, Konfiguration lädt, auto-configuration anwendet, Components scannt, Beans erzeugt, Dependencies injiziert, Lifecycle Callbacks ausführt und bei Bedarf den embedded Server startet.

Frage 18

Was passiert, wenn du spring-boot-starter-web hinzufügst?

Antwort:

Spring Boot erkennt Web-Dependencies und konfiguriert eine servlet web application, embedded Tomcat, DispatcherServlet, Spring MVC, JSON-Support und Web-Infrastruktur.

Frage 19

Was passiert, wenn du den JPA-Starter aber keine Datenbank-Konfiguration hinzufügst?

Antwort:

Spring Boot versucht vielleicht, eine DataSource zu auto-konfigurieren. Ohne Datenbank-Konfiguration oder embedded Database kann die Anwendung beim Start fehlschlagen.

Frage 20

Wie debuggst du Auto-Configuration-Entscheidungen?

Antwort:

Du kannst Startup-Logs, debug=true, --debug, Actuator /actuator/conditions, /actuator/beans und /actuator/configprops nutzen.

Merksätze zum Mitnehmen

Spring Boot macht Spring einfacher zu konfigurieren, auszuführen und zu deployen.
Spring Framework ist das Fundament. Spring Boot ergänzt Convenience und Production-Setup.
@SpringBootApplication enthält @Configuration, @EnableAutoConfiguration und @ComponentScan.
@Configuration erlaubt Bean-Definitionen.
@ComponentScan findet deine App-Components.
@EnableAutoConfiguration aktiviert Spring-Boot-Auto-Configuration.
Auto-configuration ist automatisch — aber conditional.
Starters bringen Dependencies.
Auto-configuration konfiguriert Beans basierend auf diesen Dependencies.
Embedded Tomcat lässt die App als executable JAR laufen.
SpringApplication.run erzeugt und refreshed den ApplicationContext.
Spring Boot ist keine Magie — es ist conditional configuration.
Auto-configuration kann zurücktreten, wenn du ein eigenes Bean definierst.
Nutze Debug-Logs oder Actuator Conditions, um auto-configuration zu verstehen.

Ziel​

1. Kurz-Wiederholung aus Woche 2​

2. Was ist Spring Boot?​

3. Welches Problem löst Spring Boot?​

4. Spring Framework vs. Spring Boot​

Spring Framework​

Spring Boot​

5. React-/Next.js-Vergleich​

6. Eine minimale Spring-Boot-App​

7. Was ist @SpringBootApplication?​

8. Die drei Annotationen in @SpringBootApplication​

9. Teil 1 — @Configuration​

10. Kann ich @Bean in die Main Class packen?​

11. Teil 2 — @ComponentScan​

12. Standard Component Scanning in Spring Boot​

13. Schlechte Package-Struktur​

14. Teil 3 — @EnableAutoConfiguration​

15. Was ist Auto-Configuration?​

16. Auto-Configuration ist conditional​

17. Wichtige Prüfungsfalle: Auto-Configuration​

18. Was sind Starter Dependencies?​

19. Starter vs. Auto-Configuration​

20. Embedded Server​

21. Traditionelles Spring MVC vs. Spring-Boot-Web-App​

22. Was macht SpringApplication.run(...)?​

23. Wichtiger Startup-Flow​

24. Was ist Application Type?​

25. Was passiert mit spring-boot-starter-web?​

26. Was passiert ohne spring-boot-starter-web?​

27. Spring Boot ist opinionated​

28. Spring Boot ersetzt Spring nicht​

29. Ist Spring Boot Magie?​

30. Wie siehst du, was Boot konfiguriert hat?​

31. Auto-Configuration Report​

32. Echte Frage: Warum hat Spring Boot diese Bean erzeugt?​

33. Echte Frage: Warum hat Spring Boot diese Bean nicht erzeugt?​

34. Auto-Configuration ausschließen​

35. Auto-Configuration Exclude in Properties​

36. Typischer Bug: DataSource-Fehler​

37. Typischer Bug: Web-App startet nicht​

38. Typischer Bug: Meine eigene Bean wird ignoriert​

39. Prüfungsfrage: @SpringBootApplication​

40. Prüfungsfrage: Spring vs. Spring Boot​

41. Prüfungsfrage: Auto-Configuration​

42. Prüfungsfrage: Starters​

43. Prüfungsfrage: Starter vs. Auto-Configuration​

44. Prüfungsfrage: Embedded Server​

45. Prüfungsfrage: @EnableAutoConfiguration​

46. Prüfungsfrage: SpringApplication.run​

47. Prüfungsfrage: Auto-Configuration Back Off​

48. Prüfungsfrage: Auto-Configuration ausschließen​

49. Interview-Antwort​

50. Interview-Antwort​

51. Interview-Antwort​

52. Interview-Antwort​

53. Interview-Antwort​

54. Kurze Code-Übung​

55. Kurze Bug-Übung​

56. Kurze Bug-Übung 2​

Übungsfragen​

Frage 1​

Frage 2​

Frage 3​

Frage 4​

Frage 5​

Frage 6​

Frage 7​

Frage 8​

Frage 9​

Frage 10​

Frage 11​

Frage 12​

Frage 13​

Frage 14​

Frage 15​

Frage 16​

Frage 17​

Frage 18​

Frage 19​

Frage 20​

Ziel

1. Kurz-Wiederholung aus Woche 2

2. Was ist Spring Boot?

3. Welches Problem löst Spring Boot?

4. Spring Framework vs. Spring Boot

Spring Framework

Spring Boot

5. React-/Next.js-Vergleich

6. Eine minimale Spring-Boot-App

7. Was ist `@SpringBootApplication`?

8. Die drei Annotationen in `@SpringBootApplication`

9. Teil 1 — `@Configuration`

10. Kann ich `@Bean` in die Main Class packen?

11. Teil 2 — `@ComponentScan`

12. Standard Component Scanning in Spring Boot

13. Schlechte Package-Struktur

14. Teil 3 — `@EnableAutoConfiguration`

15. Was ist Auto-Configuration?

16. Auto-Configuration ist conditional

17. Wichtige Prüfungsfalle: Auto-Configuration

18. Was sind Starter Dependencies?

19. Starter vs. Auto-Configuration

20. Embedded Server

21. Traditionelles Spring MVC vs. Spring-Boot-Web-App

22. Was macht `SpringApplication.run(...)`?

23. Wichtiger Startup-Flow

24. Was ist Application Type?

25. Was passiert mit `spring-boot-starter-web`?

26. Was passiert ohne `spring-boot-starter-web`?

27. Spring Boot ist opinionated

28. Spring Boot ersetzt Spring nicht

29. Ist Spring Boot Magie?

30. Wie siehst du, was Boot konfiguriert hat?

31. Auto-Configuration Report

32. Echte Frage: Warum hat Spring Boot diese Bean erzeugt?

33. Echte Frage: Warum hat Spring Boot diese Bean nicht erzeugt?

34. Auto-Configuration ausschließen

35. Auto-Configuration Exclude in Properties

36. Typischer Bug: DataSource-Fehler

37. Typischer Bug: Web-App startet nicht

38. Typischer Bug: Meine eigene Bean wird ignoriert

39. Prüfungsfrage: `@SpringBootApplication`

40. Prüfungsfrage: Spring vs. Spring Boot

41. Prüfungsfrage: Auto-Configuration

42. Prüfungsfrage: Starters

43. Prüfungsfrage: Starter vs. Auto-Configuration

44. Prüfungsfrage: Embedded Server

45. Prüfungsfrage: `@EnableAutoConfiguration`

46. Prüfungsfrage: `SpringApplication.run`

47. Prüfungsfrage: Auto-Configuration Back Off

48. Prüfungsfrage: Auto-Configuration ausschließen

49. Interview-Antwort

50. Interview-Antwort

51. Interview-Antwort

52. Interview-Antwort

53. Interview-Antwort

54. Kurze Code-Übung

55. Kurze Bug-Übung

56. Kurze Bug-Übung 2

Übungsfragen

Frage 1

Frage 2

Frage 3

Frage 4

Frage 5

Frage 6

Frage 7

Frage 8

Frage 9

Frage 10

Frage 11

Frage 12

Frage 13

Frage 14

Frage 15

Frage 16

Frage 17

Frage 18

Frage 19

Frage 20