Woche 1, Tag 2 — ApplicationContext und BeanFactory

Ziel

Heute vertiefst du dein Verständnis des Spring-Containers.

Die Kernfragen:

1. Was ist ApplicationContext?
2. Was ist BeanFactory?
3. Was ist der Unterschied zwischen ApplicationContext und BeanFactory?
4. Was ist eine BeanDefinition?
5. Was passiert, wenn Spring Beans erzeugt?
6. Warum ist ApplicationContext für die Prüfung wichtig?

---

1. Das große Bild

Am Tag 1 hast du gelernt: Spring erzeugt und verwaltet Objekte.

Diese verwalteten Objekte heißen Beans.

Jetzt die nächste Frage:

Wo speichert und verwaltet Spring diese Beans?

Die Antwort:

Im Spring-Container.

Der wichtigste Spring-Container ist:

ApplicationContext

---

2. Was ist ApplicationContext?

ApplicationContext ist der zentrale Spring-Container.

Er ist zuständig für:

• Beans erzeugen
• Abhängigkeiten verdrahten
• Bean-Lifecycle verwalten
• Konfiguration lesen
• Properties auflösen
• Profile unterstützen
• Events publizieren
• Internationalisierung
• AOP-Integration
• Zugriff auf Beans

Kurzdefinition:

ApplicationContext ist der Hauptcontainer, der Spring Beans erzeugt, konfiguriert, verdrahtet und verwaltet.

Prüfungsdefinition:

ApplicationContext ist eine zentrale Schnittstelle in Spring, die den IoC-Container repräsentiert und Bean-Management plus Enterprise-Features wie Events, Resources, Messages und Environment-Zugriff bietet.

---

3. Einfaches Mental Model

Stell dir ApplicationContext als intelligentes Objektregister vor.

Er kennt alle Spring Beans.

Beispiel:

ApplicationContext
------------------------------------------------
Bean-Name               Bean-Objekt
------------------------------------------------
orderService            OrderService
orderRepository         OrderRepository
emailService            EmailService
paymentController       PaymentController

Wenn Spring OrderService erzeugt, sieht er: OrderService braucht OrderRepository.

Also injiziert er die passende Bean.

OrderService braucht OrderRepository
ApplicationContext hat OrderRepository
ApplicationContext injiziert OrderRepository in OrderService

---

4. Beispiel ohne Spring

Ohne Spring erzeugst du Objekte manuell:

OrderRepository orderRepository = new OrderRepository();
OrderService orderService = new OrderService(orderRepository);

Dein Code ist dann verantwortlich für:

• Objekterzeugung
• Dependency Wiring
• Konfiguration
• Lifecycle

---

5. Beispiel mit Spring

Mit Spring schreibst du:

@Repository
public class OrderRepository {
}

@Service
public class OrderService {

    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
}

Spring erzeugt die Objekte und verbindet sie.

Der ApplicationContext verwaltet sie.

---

6. Beans manuell abrufen

Normalerweise holst du Beans nicht manuell aus dem Container.

Zum Lernen ist es aber hilfreich.

Beispiel:

ApplicationContext context =
        SpringApplication.run(MyApplication.class, args);

OrderService orderService = context.getBean(OrderService.class);

Damit fragst du den Container:

Gib mir bitte die OrderService-Bean.

Spring liefert die verwaltete Bean.

---

7. Typische Prüfungsfalle

Dieses Objekt wird von Spring verwaltet:

OrderService orderService = context.getBean(OrderService.class);

Dieses Objekt wird nicht von Spring verwaltet:

OrderService orderService = new OrderService(new OrderRepository());

Warum?

Das erste Objekt kommt aus dem Spring-Container.

Das zweite erzeugst du manuell mit new.

Merksatz:

Objekte aus dem ApplicationContext sind Spring-verwaltete Beans. Objekte mit new erzeugt sind normale Java-Objekte.

---

8. Was ist BeanFactory?

BeanFactory ist die grundlegende Container-Schnittstelle in Spring.

Sie bietet die Basis-Fähigkeiten:

• Beans erzeugen
• Beans konfigurieren
• Abhängigkeiten verdrahten
• Beans abrufen

Kurzdefinition:

BeanFactory ist der grundlegende IoC-Container in Spring.

Beispiel:

BeanFactory factory = ...;
OrderService orderService = factory.getBean(OrderService.class);

In modernen Spring-Anwendungen arbeitest du meist mit ApplicationContext, nicht direkt mit BeanFactory.

---

9. ApplicationContext vs. BeanFactory

ApplicationContext erweitert BeanFactory.

Das heißt:

ApplicationContext = BeanFactory + mehr Features

Vergleich:

Feature	BeanFactory	ApplicationContext
Basis-Bean-Erzeugung	ja	ja
Dependency Injection	ja	ja
Bean-Lookup	ja	ja
Event Publishing	nein/basis	ja
Internationalisierung	nein/basis	ja
Resource Loading	begrenzt	ja
Environment und Profile	begrenzt	ja
Application Events	nein/basis	ja
Üblich in Spring Boot	nein	ja

Merksatz:

BeanFactory ist der Basis-Container. ApplicationContext ist der voll ausgestattete Container — in den meisten Spring-Anwendungen der Standard.

---

10. Lazy vs. eager Bean-Erzeugung

Wichtig für die Prüfung.

BeanFactory

Traditionell erzeugt BeanFactory Beans lazy.

Das heißt:

Bean erst erzeugen, wenn sie angefragt wird.

ApplicationContext

Standardmäßig erzeugt ApplicationContext Singleton-Beans eager beim Start.

Das heißt:

Singleton-Beans beim App-Start erzeugen.

So findet Spring Konfigurationsfehler früh.

Beispiel:

Wenn OrderService OrderRepository braucht, aber keine OrderRepository-Bean existiert, schlägt Spring beim Start fehl.

Das ist gut — die App startet nicht in einem kaputten Zustand.

---

11. Wichtig: Singleton-Beans beim Start

In Spring sind die meisten Beans standardmäßig Singleton.

Beim Start erzeugt Spring sie deshalb meist sofort.

Beispiel:

@Service
public class OrderService {
}

Standardmäßig erzeugt Spring eine OrderService-Bean beim Start.

Außer Lazy Initialization ist aktiv.

---

12. Was ist eine BeanDefinition?

Bevor Spring eine Bean erzeugt, hat er Metadaten darüber.

Diese Metadaten heißen BeanDefinition.

Eine BeanDefinition beschreibt, wie eine Bean erzeugt wird.

Sie kann enthalten:

• Bean-Klasse
• Bean-Name
• Scope
• Konstruktor-Argumente
• Abhängigkeiten
• Lifecycle-Methoden
• Lazy- oder Eager-Verhalten
• Init-Methode
• Destroy-Methode

Kurzdefinition:

Eine BeanDefinition ist Metadaten, die Spring sagen, wie eine Bean erzeugt und verwaltet werden soll.

---

13. BeanDefinition-Beispiel

Wenn Spring das sieht:

@Service
public class OrderService {
}

registriert Spring intern eine Bean-Definition.

Konzeptionell:

BeanDefinition
------------------------------------------------
Bean-Name: orderService
Bean-Klasse: OrderService
Scope: singleton
Lazy: false
Abhängigkeiten: OrderRepository

Dann nutzt Spring diese Metadaten, um das eigentliche Bean-Objekt zu erzeugen.

---

14. BeanDefinition vs. Bean

Der Unterschied ist wichtig.

Konzept	Bedeutung
BeanDefinition	Rezept / Metadaten zur Bean-Erzeugung
Bean	Das tatsächliche, von Spring verwaltete Objekt

Merksatz:

BeanDefinition ist das Rezept. Bean ist das echte Objekt.

Beispiel:

Rezept: wie man Pizza macht
Pizza: das fertige Essen

BeanDefinition: wie man OrderService erzeugt
Bean: das echte OrderService-Objekt

---

15. Was passiert beim Spring-Boot-Start?

Vereinfachter Ablauf:

1. main()-Methode läuft
2. SpringApplication.run(...) startet
3. ApplicationContext wird erstellt
4. Spring liest Konfiguration
5. Component Scanning findet Klassen
6. BeanDefinitions werden registriert
7. Singleton-Beans werden erzeugt
8. Abhängigkeiten werden injiziert
9. Lifecycle-Callbacks laufen
10. App ist bereit

Wichtig:

Spring erzeugt Beans nicht blind sofort.

Zuerst liest er Konfiguration und registriert Bean-Definitionen.

Dann erzeugt er die eigentlichen Bean-Objekte.

---

16. Startablauf mit Beispiel

Angenommen, du hast:

@Repository
public class OrderRepository {
}

@Service
public class OrderService {

    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
}

Spring-Start:

1. Findet OrderRepository
2. Registriert BeanDefinition für orderRepository
3. Findet OrderService
4. Registriert BeanDefinition für orderService
5. Erzeugt OrderRepository-Bean
6. Erzeugt OrderService-Bean
7. Sieht: OrderService-Konstruktor braucht OrderRepository
8. Injiziert OrderRepository-Bean
9. OrderService ist bereit

---

17. Kann es mehrere ApplicationContexts geben?

Ja.

Technisch kann eine Spring-Anwendung mehrere Application Contexts haben.

In normalen Spring-Boot-Apps denkst du aber meist an einen Haupt-ApplicationContext.

In Web-Apps gibt es in manchen Setups Parent-Child-Contexts — das ist fortgeschrittener.

Für die Zertifizierung reicht:

ApplicationContext ist der Hauptcontainer, den Spring-Anwendungen nutzen.

---

18. Gängige ApplicationContext-Implementierungen

Spring hat verschiedene Implementierungen.

Beispiele:

AnnotationConfigApplicationContext
ClassPathXmlApplicationContext
FileSystemXmlApplicationContext
WebApplicationContext

Spring Boot erzeugt den passenden Context meist automatisch.

Für Annotation-basierte Konfiguration ist eine häufige:

AnnotationConfigApplicationContext

Beispiel:

ApplicationContext context =
        new AnnotationConfigApplicationContext(AppConfig.class);

In Spring Boot nutzt du normalerweise:

SpringApplication.run(MyApplication.class, args);

---

19. Manuelles Mini-Beispiel

Hilfreich für die Theorie.

@Configuration
public class AppConfig {

    @Bean
    public OrderRepository orderRepository() {
        return new OrderRepository();
    }

    @Bean
    public OrderService orderService(OrderRepository orderRepository) {
        return new OrderService(orderRepository);
    }
}

public class Main {

    public static void main(String[] args) {
        ApplicationContext context =
                new AnnotationConfigApplicationContext(AppConfig.class);

        OrderService service = context.getBean(OrderService.class);
    }
}

Hier erzeugt Spring die Beans aus Java-Konfiguration.

Spring Boot brauchst du dafür nicht.

Das zeigt: Spring Framework und Spring Boot sind nicht dasselbe.

Spring Boot macht den Start einfacher — der Container kommt aus dem Spring Framework.

---

20. Typische Prüfungsfallen

Falle 1

ApplicationContext und BeanFactory sind nicht auf gleicher Ebene.

Richtig:

ApplicationContext erweitert BeanFactory und fügt mehr Features hinzu.

---

Falle 2

Eine Spring Bean entsteht nicht nur durch @Component.

Beans können auch erzeugt werden durch:

@Bean

---

Falle 3

Ein mit new erzeugtes Java-Objekt ist nicht automatisch Spring-verwaltet.

OrderService service = new OrderService(...);

Das ist ein normales Java-Objekt.

---

Falle 4

BeanDefinition ist nicht dasselbe wie eine Bean.

BeanDefinition = Metadaten
Bean = das echte Objekt

---

Falle 5

ApplicationContext erzeugt Singleton-Beans meist eager beim Start.

Deshalb tauchen viele Dependency-Fehler schon beim App-Start auf.

---

21. Interview-Antwort

Frage:

Was ist ApplicationContext in Spring?

Gute Antwort:

ApplicationContext ist der zentrale Spring IoC-Container. Er erzeugt, verdrahtet, konfiguriert und verwaltet Spring Beans. Er liest Konfiguration, registriert Bean-Definitionen, erzeugt Singleton-Beans, injiziert Abhängigkeiten und steuert Lifecycle-Callbacks. Gegenüber BeanFactory bietet er zusätzliche Features: Event Publishing, Resource Loading, Environment-Zugriff, Profile und Internationalisierung. In modernen Spring- und Spring-Boot-Anwendungen ist ApplicationContext der Container, den wir nutzen.

---

22. Kurze Prüfungsantwort

Frage:

Was ist der Unterschied zwischen BeanFactory und ApplicationContext?

Antwort:

BeanFactory ist der grundlegende IoC-Container für Bean-Erzeugung und Dependency Injection. ApplicationContext erweitert BeanFactory und fügt Enterprise-Features hinzu: Events, Internationalisierung, Resource Loading, Environment-Zugriff und einfachere Integration mit Spring-Features. In modernen Spring-Anwendungen wird meist ApplicationContext genutzt.

---

Übungsfragen

Frage 1

Was ist ApplicationContext?

Antwort:

ApplicationContext ist der zentrale Spring-Container. Er erzeugt, verdrahtet, konfiguriert und verwaltet Spring Beans. Außerdem bietet er Features wie Event Publishing, Environment-Zugriff, Profile, Resource Loading und Lifecycle-Management.

---

Frage 2

Was ist BeanFactory?

Antwort:

BeanFactory ist der grundlegende Spring IoC-Container. Er kann Beans erzeugen, Abhängigkeiten verdrahten und Beans auf Anfrage liefern. Er ist einfacher als ApplicationContext.

---

Frage 3

Was ist der Unterschied zwischen BeanFactory und ApplicationContext?

Antwort:

BeanFactory ist der Basis-Container für Bean-Erzeugung und Dependency Injection. ApplicationContext erweitert BeanFactory und fügt Features hinzu: Event Publishing, Internationalisierung, Resource Loading, Environment-Zugriff und Profile. Die meisten modernen Spring-Anwendungen nutzen ApplicationContext.

---

Frage 4

Was ist eine BeanDefinition?

Antwort:

Eine BeanDefinition ist Metadaten, die Spring sagen, wie eine Bean erzeugt und verwaltet werden soll. Sie kann Bean-Klasse, Name, Scope, Abhängigkeiten, Lifecycle-Methoden und Lazy/Eager-Verhalten enthalten.

---

Frage 5

Was ist der Unterschied zwischen BeanDefinition und Bean?

Antwort:

BeanDefinition ist das Rezept bzw. die Metadaten zur Bean-Erzeugung. Eine Bean ist das tatsächliche, von Spring verwaltete Objekt.

Merksatz:

BeanDefinition ist das Rezept. Bean ist das echte Objekt.

---

Frage 6

Warum kann Spring fehlende Abhängigkeiten beim App-Start erkennen?

Antwort:

Weil ApplicationContext Singleton-Beans meist eager erzeugt. Beim Erzeugen prüft Spring die Konstruktor-Abhängigkeiten. Fehlt eine erforderliche Dependency, startet die Anwendung nicht.

---

Frage 7

Ist dieses Objekt Spring-verwaltet?

OrderService service = context.getBean(OrderService.class);

Antwort:

Ja. Es kommt aus dem Spring ApplicationContext — also eine Spring-verwaltete Bean.

---

Frage 8

Ist dieses Objekt Spring-verwaltet?

OrderService service = new OrderService(new OrderRepository());

Antwort:

Nein. Mit new erzeugt — Spring verwaltet es nicht automatisch.

Merksätze zum Mitnehmen

• ApplicationContext ist der zentrale Spring-Container.
• BeanFactory ist der grundlegende IoC-Container.
• ApplicationContext erweitert BeanFactory.
• ApplicationContext bringt Events, Resources, Profile, Environment-Zugriff und Internationalisierung.
• BeanDefinition sind Metadaten zur Bean-Erzeugung.
• BeanDefinition ist das Rezept. Bean ist das Objekt.
• Objekte aus dem ApplicationContext sind Spring-verwaltet.
• Mit new erzeugte Objekte sind nicht automatisch Spring-verwaltet.
• Singleton-Beans werden meist eager beim Start erzeugt.