Spring Core — IoC, DI & Beans
Das Herzstueck: Inversion of Control
Statt Objekte selbst zu erzeugen, überlässt du das dem Spring-Container (IoC-Container). Er erzeugt, verdrahtet und verwaltet alle Beans.
Lektion 6: Was ist eine Bean?
Eine Bean ist ein Objekt, das Spring verwaltet. Registriert wird sie per Annotation:
@Component // generische Bean
@Service // Business-Logik
@Repository // Datenzugriff
@Configuration + @Bean // manuelle Fabrik-Methoden
Alle Beans landen im ApplicationContext — dem IoC-Container.
Lektion 7: Dependency Injection — der richtige Weg
Frueher: @Autowired auf Feldern. Heute: Constructor Injection.
@Service
public class OrderService {
private final PaymentService payment;
public OrderService(PaymentService payment) { // Spring injiziert
this.payment = payment;
}
}
Konstruktor-Injection macht Abhaengigkeiten sichtbar, final (immutable)
und einfach testbar — ohne Spring-Reflexion.
Warum Constructor Injection?
- Testbarkeit:
new OrderService(mockPayment)— kein Mock-Framework noetig - Immutability:
final-Felder sind Thread-sicher - Sichtbarkeit: Der Konstruktor zeigt alle Abhaengigkeiten auf einen Blick
- Fail-fast: Fehlende Abhaengigkeit = App startet gar nicht erst
Lektion 8: Bean-Scopes
Standard-Scope ist Singleton — eine Instanz pro ApplicationContext.
| Scope | Instanzen | Use Case |
|---|---|---|
singleton | 1 pro Context | Services, Config |
prototype | 1 pro Anfrage | Zustaendsbehaftete Objekte |
request | 1 pro HTTP-Request (Web) | Request-Kontext |
session | 1 pro HTTP-Session (Web) | Nutzer-Kontext |
Lektion 9: @Qualifier & @Primary
Mehrere Beans vom selben Typ? Spring braucht Hilfe:
public interface Notifier { void send(String msg); }
@Component @Primary
class EmailNotifier implements Notifier { /* ... */ }
@Component("sms")
class SmsNotifier implements Notifier { /* ... */ }
@Service
class AlertService {
AlertService(@Qualifier("sms") Notifier notifier) { /* ... */ }
}
Lektion 10: DI im Playground erleben
Der Bean-Lifecycle: mehr als nur new()
Eine Spring-Bean durchläuft Phasen: Instantiierung → Dependency Injection →
@PostConstruct → Initialisierung → Einsatz → @PreDestroy → Destruction.
Das ApplicationContext-Interface bietet getBean() für manuellen Zugriff, aber
in der Praxis solltest du dich auf DI verlassen — getBean() ist ein Anti-Pattern.
Praxis-Szenario: DI in der Praxis
Du erbst ein Legacy-Projekt mit 50 @Autowired-Feldern. Der Tech Lead will Constructor Injection. Wie gehst du systematisch vor, ohne alles auf einmal zu ändern?
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren: