Zum Hauptinhalt springen

Woche 1, Tag 1 — Welches Problem löst Spring?

Ziel​

Heute baust du das grundlegende Bild von Spring auf.

Die Kernfragen:

  1. Welches Problem löst Spring?
  2. Was ist IoC?
  3. Was ist Dependency Injection?
  4. Was ist eine Spring Bean?
  5. Was ist ApplicationContext?
  6. Was ist der Unterschied zwischen Spring Framework und Spring Boot?

1. Welches Problem löst Spring?​

In normalem Java-Code erzeugen Klassen ihre Abhängigkeiten oft selbst:


public class OrderService {

    private final OrderRepository orderRepository;

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

Das funktioniert — erzeugt aber Probleme.

Was schiefgeht​

  • OrderService hängt fest an OrderRepository — enge Kopplung.
  • Schwer testbar.
  • Schwer austauschbar (andere Implementierung).
  • In großen Apps wird die Objekterzeugung unübersichtlich.
  • Die Klasse übernimmt zu viel Verantwortung.

Spring übernimmt Erzeugung und Verdrahtung der Objekte.

2. Was ist IoC?​

IoC = Inversion of Control (Umkehrung der Steuerung).

Ohne Spring:


Mein Code erzeugt Objekte.

Mit Spring:


Spring erzeugt Objekte.

Kurz:

Die Steuerung über Objekterzeugung und Abhängigkeiten liegt beim Spring-Container — nicht mehr im Anwendungscode.

Merksatz:

IoC heißt: Spring erzeugt und verwaltet Objekte für dich.

3. Was ist Dependency Injection?​

Eine Klasse bekommt Abhängigkeiten von außen — statt sie selbst mit new zu bauen.

Schlecht:


public class OrderService {

    private final OrderRepository orderRepository;

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

Besser:


public class OrderService {

    private final OrderRepository orderRepository;

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

OrderService erzeugt OrderRepository nicht mehr selbst. Es bekommt es injiziert — das ist Dependency Injection.

4. IoC vs. Dependency Injection​

Zusammenhang, aber nicht dasselbe.

IoC​

Das übergeordnete Prinzip: Das Framework steuert Erzeugung und Verwaltung von Objekten.

Dependency Injection​

Eine konkrete Technik für IoC: Abhängigkeiten kommen von außen.

Merksatz:

IoC ist die Idee. Dependency Injection ist die Technik.

5. Was ist eine Spring Bean?​

Eine Bean ist ein von Spring verwaltetes Objekt.


@Service
public class OrderService {
}

Wenn Spring dieses Objekt erzeugt und verwaltet, ist es eine Bean.

Das ist keine Bean:


OrderService orderService = new OrderService();

Mit new erzeugt — Spring verwaltet es nicht automatisch.

Prüfungsdefinition:

Eine Spring Bean ist ein Objekt, dessen Lebenszyklus vom Spring IoC-Container verwaltet wird.

6. Was heißt „von Spring verwaltet“?​

Spring kann:

  • das Objekt erzeugen
  • Abhängigkeiten injizieren
  • es konfigurieren
  • Lifecycle-Methoden aufrufen
  • Proxies drumherum legen
  • es beim Shutdown zerstören

@Service
public class OrderService {

    private final OrderRepository orderRepository;

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

Spring erzeugt OrderService und injiziert OrderRepository.

7. Was ist ApplicationContext?​

Der zentrale Spring-Container. Er verwaltet alle Beans.

Er „weiß“ im Prinzip:


Es gibt eine OrderService-Bean.
Es gibt eine OrderRepository-Bean.
OrderService braucht OrderRepository.
Ich verbinde die beiden.

Kurz:

ApplicationContext erzeugt, verdrahtet, konfiguriert und verwaltet Beans.

8. Zwei Wege, Beans zu registrieren​

Weg 1 — Annotation auf der Klasse​


@Component
@Service
@Repository
@Controller
@RestController

@Service
public class OrderService {
}

Spring findet die Klasse per Component Scanning.

Weg 2 — @Bean-Methode​


@Configuration
public class AppConfig {

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

@Bean, wenn:

  • die Klasse aus einer Drittanbieter-Lib kommt
  • du keine @Component setzen kannst
  • die Erzeugung eigene Logik braucht

9. Was passiert beim Spring-Boot-Start?​

Vereinfachter Ablauf:


1. main() läuft
2. SpringApplication.run(...) startet
3. ApplicationContext wird erstellt
4. Spring scannt Packages
5. Bean-Definitionen werden registriert
6. Beans werden erzeugt
7. Abhängigkeiten werden injiziert
8. Lifecycle-Callbacks laufen
9. Embedded Webserver startet (bei Web-Apps)
10. App ist bereit

@SpringBootApplication
public class MyApplication {

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

10. Spring Framework vs. Spring Boot​

Spring Framework​

Das Fundament:

  • IoC-Container
  • Dependency Injection
  • AOP
  • Transaktionen
  • MVC
  • Datenzugriff

Spring Boot​

Macht Spring schneller start- und betriebsfähig:

  • Auto-Konfiguration
  • Starter-Dependencies
  • Embedded Tomcat
  • einfachere Konfiguration
  • Actuator
  • sinnvolle Defaults

Merksatz:

Spring ist das Fundament. Boot macht den Einstieg und Betrieb einfacher.

Übungsfragen​

Frage 1​

Was ist das Problem hier?


public class OrderService {

    private final OrderRepository orderRepository;

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

Antwort:

OrderService erzeugt OrderRepository selbst. Enge Kopplung an eine konkrete Implementierung — schwer testbar, schwer austauschbar, Spring kann die Abhängigkeit nicht sinnvoll übernehmen.

Frage 2​

Warum ist das besser?


public class OrderService {

    private final OrderRepository orderRepository;

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

Antwort:

Die Abhängigkeit kommt von außen und ist explizit. In Produktion ein echtes Repository, in Tests ein Mock — Dependency Injection.

Frage 3​

Unterschied IoC und Dependency Injection?

Antwort:

IoC: Steuerung wechselt vom eigenen Code zum Container/Framework. Dependency Injection: Dependencies werden von außen geliefert — in Spring der Hauptweg für IoC.

Frage 4​

Wird das automatisch von Spring verwaltet?


UserService userService = new UserService();

Antwort:

Nein. new = Spring verwaltet es nicht. Bean werden z. B. über @Component, @Service oder @Bean.

Frage 5​

Was ist eine Spring Bean?

Antwort:

Ein vom IoC-Container erzeugtes und verwaltetes Objekt. Spring injiziert Dependencies, steuert den Lebenszyklus und kann Proxies für Transaktionen, Security usw. legen.

Merksätze zum Mitnehmen​

  • IoC: Spring steuert die Objekterzeugung.
  • Dependency Injection: Abhängigkeiten kommen von außen.
  • IoC = Idee, DI = Technik.
  • Bean = vom Container verwaltetes Objekt.
  • ApplicationContext = der Hauptcontainer.
  • Framework = Kern. Boot = Komfort und Defaults drumherum.