Woche 1 — Review: Spring-Core Mental Model
Ziel
Dieses Review prüft, ob du Woche 1 wirklich verstanden hast.
Themen aus Woche 1:
- Welches Problem Spring löst
- IoC
- Dependency Injection
- Beans
ApplicationContextBeanFactoryBeanDefinition@Componentvs.@Bean- Stereotyp-Annotationen
- Component Scanning
- Constructor Injection
@Primary@Qualifier- Typische Bean-nicht-gefunden-Fehler
1. Das große Bild aus Woche 1
Spring hilft bei Objekterzeugung und Abhängigkeiten.
Ohne Spring:
OrderRepository repository = new OrderRepository();
OrderService service = new OrderService(repository);
OrderController controller = new OrderController(service);
Mit Spring:
@Repository
public class OrderRepository {
}
@Service
public class OrderService {
private final OrderRepository orderRepository;
public OrderService(OrderRepository orderRepository) {
this.orderRepository = orderRepository;
}
}
@RestController
public class OrderController {
private final OrderService orderService;
public OrderController(OrderService orderService) {
this.orderService = orderService;
}
}
Spring erzeugt die Objekte und verbindet sie.
2. Zentrale Merksätze
Auswendig lernen:
IoC heißt: Spring steuert Objekterzeugung und Dependency Management.
Dependency Injection heißt: Abhängigkeiten kommen von außen.
IoC ist die Idee. Dependency Injection ist die Technik.
Eine Spring Bean ist ein vom Spring IoC-Container verwaltetes Objekt.
ApplicationContext ist der zentrale Spring-Container.
BeanFactory ist der grundlegende Spring IoC-Container.
ApplicationContext erweitert BeanFactory und bringt mehr Features.
BeanDefinition ist das Rezept. Bean ist das echte Objekt.
Component Scanning findet annotierte Klassen und registriert sie als Beans.
@SpringBootApplication enthält @Configuration, @EnableAutoConfiguration und @ComponentScan.
@Component ist generisch.
@Service ist für Business-Logik.
@Repository ist für Persistence und kann Exception Translation unterstützen.
@RestController = @Controller + @ResponseBody.
@Component steht auf Klassen.
@Bean steht auf Methoden.
Constructor Injection ist am besten für erforderliche Abhängigkeiten.
@Autowired ist auf einem einzigen Konstruktor optional.
@Primary = Standard-Bean.
@Qualifier = exakte Bean.
Spring-Singleton = eine Bean-Instanz pro Spring-Container.
Mit new erzeugte Objekte sind nicht automatisch Spring-verwaltet.
3. Concept Map
Spring Framework
│
├── IoC Container
│ ├── BeanFactory
│ └── ApplicationContext
│
├── Beans
│ ├── BeanDefinition
│ ├── Bean lifecycle
│ ├── Bean scope
│ └── Dependency Injection
│
├── Component Scanning
│ ├── @Component
│ ├── @Service
│ ├── @Repository
│ ├── @Controller
│ ├── @RestController
│ └── @Configuration
│
└── Bean Registration
├── Stereotype annotations
└── @Bean methods
4. Wichtigste Prüfungsfallen
Falle 1 — IoC vs. DI
Falsch:
IoC und DI sind genau dasselbe.
Richtig:
IoC ist das Prinzip. DI ist eine Umsetzung von IoC.
Falle 2 — new vs. Spring Bean
Falsch:
OrderService service = new OrderService();
Nicht automatisch Spring-verwaltet.
Richtig:
OrderService service = context.getBean(OrderService.class);
Kommt aus Spring und wird von Spring verwaltet.
Falle 3 — @Service allein reicht nicht
Falsch:
Hat eine Klasse @Service, ist sie immer eine Spring Bean.
Richtig:
@Service markiert nur einen Kandidaten. Bean wird sie nur, wenn Spring ihr Package scannt.
Falle 4 — Component Scanning scannt nicht alles
Spring Boot scannt ab dem Package der Hauptklasse.
Beispiel:
package com.example.app;
@SpringBootApplication
public class MyApplication {
}
Spring scannt:
com.example.app
com.example.app.*
Nicht automatisch:
com.example.service
Falle 5 — @SpringBootApplication
Wichtig:
@SpringBootApplication
enthält:
@Configuration
@EnableAutoConfiguration
@ComponentScan
Falle 6 — @Component vs. @Bean
@Component:
@Component
public class EmailService {
}
Auf einer Klasse.
@Bean:
@Bean
public Clock clock() {
return Clock.systemUTC();
}
Auf einer Methode.
Falle 7 — BeanDefinition vs. Bean
BeanDefinition = Metadaten / Rezept
Bean = das echte Objekt
Falle 8 — Mehrere Beans
Zwei Beans für eine Abhängigkeit → Spring startet nicht, bis die Mehrdeutigkeit aufgelöst ist.
Lösungen:
@Primary
@Qualifier
List<T>
Map<String, T>
spezifischerer Typ
Falle 9 — Constructor Injection
In modernem Spring:
public OrderService(OrderRepository orderRepository) {
}
braucht kein @Autowired, wenn es der einzige Konstruktor ist.
Falle 10 — Spring-Singleton
Spring-Singleton heißt:
eine Instanz pro Spring-Container
Nicht das klassische Java-Singleton-Pattern.
Übungsfragen
Frage 1
Welches Problem löst Spring?
Antwort:
Objekterzeugung, Dependency Wiring, Konfiguration, Lifecycle-Management und Infrastruktur wie Transaktionen, Security und AOP.
Frage 2
Was ist IoC?
Antwort:
Inversion of Control — die Steuerung über Objekterzeugung und Dependency Management liegt beim Spring-Container, nicht im Anwendungscode.
Frage 3
Was ist Dependency Injection?
Antwort:
Eine Klasse bekommt Abhängigkeiten von außen statt sie selbst zu erzeugen.
Frage 4
Unterschied IoC und Dependency Injection?
Antwort:
IoC ist das übergeordnete Prinzip — Steuerung wechselt zum Framework/Container. Dependency Injection ist die Technik, bei der Abhängigkeiten von außen kommen. In Spring ist DI der Hauptweg für IoC.
Frage 5
Was ist eine Spring Bean?
Antwort:
Ein vom Spring IoC-Container erzeugtes und verwaltetes Objekt.
Frage 6
Was ist ApplicationContext?
Antwort:
Der zentrale Spring-Container. Er erzeugt, verdrahtet, konfiguriert und verwaltet Beans. Außerdem: Events, Resources, Profile, Environment-Zugriff, Lifecycle-Management.
Frage 7
Was ist BeanFactory?
Antwort:
Der grundlegende Spring IoC-Container — Basis-Bean-Erzeugung, Dependency Injection, Bean-Lookup.
Frage 8
Unterschied ApplicationContext und BeanFactory?
Antwort:
ApplicationContext erweitert BeanFactory und bringt mehr Features: Event Publishing, Internationalisierung, Resource Loading, Environment-Zugriff, Profile.
Frage 9
Was ist eine BeanDefinition?
Antwort:
Metadaten, die Spring sagen, wie eine Bean erzeugt und verwaltet werden soll.
Frage 10
Unterschied BeanDefinition und Bean?
Antwort:
BeanDefinition = Rezept/Metadaten. Bean = das echte, von Spring verwaltete Objekt.
Frage 11
Was ist Component Scanning?
Antwort:
Spring durchsucht konfigurierte Packages nach Klassen mit Stereotyp-Annotationen und registriert sie als Beans.
Frage 12
Wo startet Spring Boot standardmäßig den Scan?
Antwort:
Im Package der Klasse mit @SpringBootApplication — inklusive Unterpackages.
Frage 13
Warum soll die Spring-Boot-Hauptklasse im Root-Package liegen?
Antwort:
Damit Spring alle App-Unterpackages automatisch scannt.
Frage 14
Was enthält @SpringBootApplication?
Antwort:
@Configuration
@EnableAutoConfiguration
@ComponentScan
Frage 15
Unterschied @Component und @Bean?
Antwort:
@Component auf einer Klasse — gefunden per Component Scanning. @Bean auf einer Methode in einer Konfigurationsklasse — Rückgabewert wird Bean.
Frage 16
Unterschied @Service und @Repository?
Antwort:
@Service markiert Business-Logik. @Repository markiert Persistence-Layer und kann Exception Translation in Springs DataAccessException-Hierarchie unterstützen.
Frage 17
Was enthält @RestController?
Antwort:
@Controller
@ResponseBody
Frage 18
Warum wird Constructor Injection empfohlen?
Antwort:
Abhängigkeiten sind explizit, Felder können final sein, Immutability und Testbarkeit verbessern sich — das Objekt entsteht nicht ohne Pflicht-Abhängigkeiten.
Frage 19
Was passiert bei mehreren passenden Beans?
Antwort:
Spring startet nicht — Mehrdeutigkeit. Auflösung mit @Primary, @Qualifier, spezifischerem Typ oder Collection-Injection.
Frage 20
Unterschied @Primary und @Qualifier?
Antwort:
@Primary = Standardwahl. @Qualifier = explizite Auswahl einer bestimmten Bean. @Qualifier ist spezifischer.
7. Mini-Mock-Prüfung — Woche 1
Anleitung
Ohne Notizen antworten.
Empfohlene Zeit:
25 Minuten
Bestehensgrenze:
80 %
25 Fragen.
Frage 1
Was beschreibt IoC am besten?
A. Ein Design-Pattern für SQL-Queries
B. Ein Prinzip, bei dem die Steuerung der Objekterzeugung beim Container liegt
C. Eine Methode, Objekte manuell mit new zu erzeugen
D. Ein reines Spring-Boot-Feature
Meine Antwort:
Frage 2
Welche Aussage zu Dependency Injection ist richtig?
A. Eine Klasse erzeugt alle Abhängigkeiten selbst
B. Abhängigkeiten kommen von außen
C. Funktioniert nur mit Field Injection
D. Funktioniert nur in Spring Boot
Meine Antwort:
Frage 3
Was ist eine Spring Bean?
A. Jedes Java-Objekt
B. Jedes mit new erzeugte Objekt
C. Ein vom Spring-Container verwaltetes Objekt
D. Ein Datenbank-Datensatz
Meine Antwort:
Frage 4
Welcher Container wird in modernen Spring-Apps üblich genutzt?
A. ApplicationContext
B. ArrayList
C. Nur EntityManager
D. Nur ServletContext
Meine Antwort:
Frage 5
Was ist BeanFactory?
A. Eine Datenbank-Factory
B. Der grundlegende Spring IoC-Container
C. Ein REST-Controller
D. Ein Spring-Security-Filter
Meine Antwort:
Frage 6
Was ist richtig?
A. ApplicationContext erweitert BeanFactory
B. BeanFactory erweitert ApplicationContext
C. Sie sind unabhängig
D. ApplicationContext ist nur für Tests
Meine Antwort:
Frage 7
Was ist eine BeanDefinition?
A. Das echte Objekt im Speicher
B. Metadaten, die beschreiben, wie eine Bean erzeugt wird
C. Ein REST-Endpoint
D. Eine SQL-Tabelle
Meine Antwort:
Frage 8
Was registriert eine Bean per Component Scanning?
A. @Service
B. new
C. private
D. static
Meine Antwort:
Frage 9
Welche Annotation steht auf einer Methode, deren Rückgabewert Bean wird?
A. @Service
B. @Bean
C. @Repository
D. @PathVariable
Meine Antwort:
Frage 10
Wann nutzt man meist @Bean?
A. Für Drittanbieter-Klassen oder eigene Erzeugungslogik
B. Nur für Controller
C. Nur für Repositories
D. Nie
Meine Antwort:
Frage 11
Was enthält @SpringBootApplication?
A. @Configuration, @EnableAutoConfiguration, @ComponentScan
B. @Service, @Repository, @Entity
C. @RestController, @RequestMapping, @Bean
D. @Transactional, @Autowired, @Test
Meine Antwort:
Frage 12
Wo startet Spring Boot standardmäßig den Component Scan?
A. Im Package der Klasse mit @SpringBootApplication
B. In allen Packages der JVM
C. Im Datenbank-Schema
D. Im Betriebssystem
Meine Antwort:
Frage 13
Garantiert @Service immer, dass eine Klasse Bean wird?
A. Ja, immer
B. Nein — sie muss per Component Scanning gefunden oder registriert werden
C. Nur wenn die Klasse private ist
D. Nur wenn die Klasse keinen Konstruktor hat
Meine Antwort:
Frage 14
Standard-Bean-Name für diese Klasse?
@Service
public class PaymentService {
}
A. PaymentService
B. paymentService
C. servicePayment
D. payment-service
Meine Antwort:
Frage 15
Was ist besonders an @Repository?
A. Kann Persistence Exception Translation unterstützen
B. Erzeugt REST-Endpoints
C. Deaktiviert Transaktionen
D. Ist kein Spring-Stereotyp
Meine Antwort:
Frage 16
Was enthält @RestController?
A. @Controller und @ResponseBody
B. @Service und @Bean
C. @Repository und @Transactional
D. @ComponentScan und @Configuration
Meine Antwort:
Frage 17
Welche Injektionsart ist für erforderliche Abhängigkeiten empfohlen?
A. Field Injection
B. Constructor Injection
C. Random Injection
D. Static Injection
Meine Antwort:
Frage 18
Ist @Autowired auf einem einzigen Konstruktor in modernem Spring nötig?
A. Ja
B. Nein
C. Nur für Repositories
D. Nur für Controller
Meine Antwort:
Frage 19
Was passiert, wenn keine passende Bean für eine erforderliche Konstruktor-Abhängigkeit existiert?
A. Spring injiziert standardmäßig null
B. Spring startet meist nicht
C. Spring erzeugt ein zufälliges Objekt
D. Spring ignoriert die Abhängigkeit
Meine Antwort:
Frage 20
Was passiert bei zwei passenden Beans ohne @Primary oder @Qualifier?
A. Spring injiziert beide automatisch in eine Variable
B. Spring wählt zufällig
C. Spring startet meist nicht — Mehrdeutigkeit
D. Spring ignoriert beide
Meine Antwort:
Frage 21
Was macht @Primary?
A. Markiert eine Bean als Standardwahl
B. Löscht alle anderen Beans
C. Erzeugt einen Datenbank-Primary-Key
D. Macht eine Klasse static
Meine Antwort:
Frage 22
Was macht @Qualifier?
A. Wählt eine spezifische Bean
B. Aktiviert Component Scanning
C. Startet Spring Boot
D. Erzeugt eine Transaktion
Meine Antwort:
Frage 23
Was ist spezifischer?
A. @Primary
B. @Qualifier
C. Immer gleich
D. Keines funktioniert mit Spring
Meine Antwort:
Frage 24
Was injiziert Spring in List<NotificationSender>?
A. Nichts
B. Nur die Primary-Bean
C. Alle Beans vom Typ NotificationSender
D. Eine zufällige String-Liste
Meine Antwort:
Frage 25
Was bedeutet Spring-Singleton?
A. Eine Instanz pro JVM, immer
B. Eine Instanz pro Spring-Container
C. Eine Instanz pro Datenbank-Tabelle
D. Eine Instanz pro HTTP-Request
Meine Antwort:
8. Lösungen Mini-Mock-Prüfung
Antwortschlüssel
1. B
2. B
3. C
4. A
5. B
6. A
7. B
8. A
9. B
10. A
11. A
12. A
13. B
14. B
15. A
16. A
17. B
18. B
19. B
20. C
21. A
22. A
23. B
24. C
25. B
9. Punkte
Fragen gesamt: 25
Richtige Antworten:
Falsche Antworten:
Punktzahl:
Berechnung:
richtige Antworten / 25 * 100
Beispiel:
20 / 25 * 100 = 80 %
10. Fehleranalyse-Vorlage
Für jede falsche Antwort:
## Fehler
Fragennummer:
Meine falsche Antwort:
Richtige Antwort:
Warum ich falsch lag:
Richtiges Konzept:
Merksatz:
Beispiel:
## Fehler
Fragennummer: 13
Meine falsche Antwort: A
Richtige Antwort: B
Warum ich falsch lag:
Ich dachte, @Service erzeugt immer eine Bean.
Richtiges Konzept:
@Service markiert nur einen Kandidaten. Die Klasse muss per Component Scanning gefunden werden.
Merksatz:
Annotation allein reicht nicht. Das Package muss gescannt werden.
11. Mündliche Abschlussprüfung Woche 1
Laut antworten.
Frage 1
Erkläre Spring IoC, als wärst du Junior-Entwickler.
Frage 2
Erkläre, warum Dependency Injection Tests verbessert.
Frage 3
Erkläre, was beim Spring-Boot-Start passiert.
Frage 4
Erkläre den Unterschied zwischen @Component und @Bean.
Frage 5
Erkläre, warum @Service vielleicht nicht gefunden wird.
Frage 6
Erkläre, was passiert, wenn zwei Beans dasselbe Interface implementieren.
Frage 7
Erkläre den Unterschied zwischen @Primary und @Qualifier.
Frage 8
Erkläre, warum Constructor Injection empfohlen wird.
12. Gute mündliche Antworten
Mündliche Antwort 1 — IoC
Spring IoC heißt: Spring steuert Objekterzeugung und Dependency Management. Statt Services und Repositories manuell mit new zu bauen, lässt du den Spring-Container sie erzeugen und verbinden. Das macht die App einfacher konfigurierbar, testbar und wartbar. Die von Spring verwalteten Objekte heißen Beans.
Mündliche Antwort 2 — Dependency Injection und Tests
Dependency Injection verbessert Tests, weil eine Klasse ihre Abhängigkeiten nicht selbst erzeugt — sie bekommt sie von außen. In Produktion ein echtes Repository, in Tests ein Fake oder Mock. Constructor Injection macht das besonders einfach, weil Abhängigkeiten explizite Konstruktor-Parameter sind.
Mündliche Antwort 3 — Spring-Boot-Start
Beim Start ruft main SpringApplication.run auf. Spring erzeugt den ApplicationContext, liest Konfiguration, scannt Packages, registriert Bean-Definitionen, erzeugt Singleton-Beans, injiziert Abhängigkeiten, führt Lifecycle-Callbacks aus, startet bei Bedarf den Embedded Webserver — dann ist die App bereit.
Mündliche Antwort 4 — @Component vs. @Bean
@Component steht auf einer Klasse und wird per Component Scanning gefunden — meist für eigene App-Klassen. @Bean steht auf einer Methode in einer Konfigurationsklasse; der Rückgabewert wird Bean. Nützlich für Drittanbieter-Klassen oder eigene Erzeugungslogik.
Mündliche Antwort 5 — Warum @Service nicht gefunden wird
Vielleicht liegt die Klasse außerhalb des Component-Scan-Pfads. In Spring Boot startet der Scan im Package der Klasse mit @SpringBootApplication. Weitere Gründe: inaktives Profil, false-Bedingung, fehlende Abhängigkeiten, falscher Import, Test-Slices, die den Service nicht laden.
Mündliche Antwort 6 — Zwei Beans, gleiches Interface
Implementieren zwei Beans dasselbe Interface und hängt eine andere Bean davon ab, weiß Spring nicht, welche Implementierung injiziert werden soll. Mehrdeutigkeit — die App startet meist nicht. Auflösung: @Primary, @Qualifier, spezifischerer Typ oder alle Implementierungen als Liste/Map injizieren.
Mündliche Antwort 7 — @Primary vs. @Qualifier
@Primary markiert eine Bean als Standard bei mehreren Kandidaten. @Qualifier wählt explizit eine bestimmte Bean. @Primary, wenn meist eine Implementierung genutzt werden soll. @Qualifier ist spezifischer und gewinnt, wenn du eine exakte Bean brauchst.
Mündliche Antwort 8 — Constructor Injection
Constructor Injection macht Abhängigkeiten explizit. Felder können final sein, Immutability und Testbarkeit verbessern sich — das Objekt entsteht nicht ohne Pflicht-Abhängigkeiten. Designprobleme wie zu viele Dependencies oder Zirkularität werden früher sichtbar.
13. Readiness-Checkliste Woche 1
Vor Woche 2 solltest du alles abhaken können:
[ ] Ich kann erklären, welches Problem Spring löst.
[ ] Ich kann IoC erklären.
[ ] Ich kann Dependency Injection erklären.
[ ] Ich kann IoC und DI unterscheiden.
[ ] Ich kann erklären, was eine Spring Bean ist.
[ ] Ich kann erklären, was ApplicationContext macht.
[ ] Ich kann BeanFactory erklären.
[ ] Ich kann ApplicationContext und BeanFactory vergleichen.
[ ] Ich kann BeanDefinition erklären.
[ ] Ich kann BeanDefinition und Bean vergleichen.
[ ] Ich kann Component Scanning erklären.
[ ] Ich weiß, wo Spring Boot standardmäßig scannt.
[ ] Ich weiß, warum die Hauptklasse im Root-Package liegen soll.
[ ] Ich weiß, was @SpringBootApplication enthält.
[ ] Ich kann @Component und @Bean vergleichen.
[ ] Ich kann @Component, @Service und @Repository vergleichen.
[ ] Ich weiß, was @RestController enthält.
[ ] Ich kann Constructor Injection erklären.
[ ] Ich weiß, warum Field Injection nicht empfohlen wird.
[ ] Ich weiß, dass @Autowired auf einem Konstruktor optional ist.
[ ] Ich kann erklären, was passiert, wenn keine Bean existiert.
[ ] Ich kann erklären, was bei mehreren Beans passiert.
[ ] Ich kann @Primary erklären.
[ ] Ich kann @Qualifier erklären.
[ ] Ich kann erklären, wie man alle Beans eines Typs injiziert.
[ ] Ich weiß, dass new-Objekte nicht Spring-verwaltet sind.
14. Schwache Themen vor Woche 2
## Meine Schwachstellen
1.
2.
3.
4.
5.
Pro Schwachstelle:
## Schwachstelle
Thema:
Warum verwirrend:
Richtige Erklärung:
Code-Beispiel:
Merksatz:
15. Woche-1-Zusammenfassung
Woche 1 legt das Spring-Fundament.
Die wichtigste Idee:
Spring verwaltet Objekte — Beans — im ApplicationContext.
Spring findet Beans durch:
Component Scanning
oder registriert sie über:
@Bean-Methoden
Spring verbindet Beans durch:
Dependency Injection
Mehrdeutigkeit löst Spring mit:
@Primary und @Qualifier
Spring Boot vereinfacht den Einstieg mit:
@SpringBootApplication
das enthält:
@Configuration
@EnableAutoConfiguration
@ComponentScan
Wenn du das verstanden hast, bist du bereit für Woche 2.