Next:
Impressum
SpringBoot Basics
1
Impressum
2
Spring im Java-Ökosystem
2.1
Warum eigentlich Spring?
2.2
Die Integrationsschicht
2.3
Marktdominanz
2.4
Nicht nur Web
3
Spring als Architekturprinzip
3.1
Das Problem ohne Architektur
3.2
Inversion of Control
3.3
Warum das wichtig ist
3.4
Mehr als eine Technik
4
Spring Framework vs. Spring Boot
4.1
Ein kurzer Blick zurück
4.2
Was Spring Framework liefert
4.3
Was Spring Boot hinzufügt
4.4
Die richtige Perspektive
4.5
Für diese Schulung
5
Das Übungsprojekt starten
5.1
Die Idee
5.2
Die Entwicklungsumgebung
5.3
Die Anwendung starten
5.4
Die Landingpage
5.5
Was da gerade passiert ist
5.6
Bei Problemen
6
Convention over Configuration
6.1
Das Prinzip
6.2
Ein Beispiel aus dem Arcade-Projekt
6.3
Was Spring Boot annimmt
6.4
Die Macht der Defaults
6.5
Konvention ≠ Magie
6.6
Wann Konventionen brechen
6.7
Der Aha-Moment
7
Auto-Konfiguration
7.1
Das Prinzip der bedingten Konfiguration
7.2
Was im Arcade-Projekt passiert
7.3
Die
@Conditional-Familie
7.4
Überschreiben statt Deaktivieren
7.5
Den Überblick behalten
7.6
Die Grenze der Magie
8
Projektstruktur und Starters
8.1
Die Standardstruktur
8.2
Die Verzeichnisse im Detail
8.3
Package-Konventionen
8.4
Namenskonventionen
8.5
Starters verstehen
8.6
Resources im Detail
8.7
Die Application-Klasse
9
Übung: Defaults anpassen
9.1
Ausgangslage
9.2
Aufgabe 1: Port ändern
9.3
Aufgabe 2: Context Path setzen
9.4
Aufgabe 3: Log-Level anpassen
9.5
Aufgabe 4: Eigenes Banner
9.6
Aufgabe 5: Zusammenführen
9.7
Was wir gelernt haben
10
Inversion of Control
10.1
Das traditionelle Modell
10.2
Die Probleme
10.3
Die Umkehrung
10.4
Warum “Inversion”?
10.5
Der Container
10.6
Ein mentales Modell
11
Dependency Injection als Entkopplung
11.1
Was ist eine Dependency?
11.2
Injection statt Konstruktion
11.3
Entkopplung durch Interfaces
11.4
Das Arcade-Beispiel
11.5
Lose vs. enge Kopplung
11.6
Der Dominoeffekt
11.7
Zusammenspiel der Konzepte
12
Arten der Injection
12.1
Constructor Injection
12.2
Field Injection
12.3
Setter Injection
12.4
Der Vergleich
12.5
Warum Constructor Injection gewinnt
12.6
Wann Setter Injection?
12.7
Die Empfehlung
13
Vorteile von Dependency Injection
13.1
Testbarkeit
13.2
Austauschbarkeit
13.3
Modularisierung
13.4
Single Responsibility
13.5
Konfigurierbarkeit
13.6
Übersicht der Vorteile
14
Bean Lifecycle im Überblick
14.1
Was ist eine Bean?
14.2
Der Lebenszyklus
14.3
Initialisierung mit
@PostConstruct
14.4
Aufräumen mit
@PreDestroy
14.5
Bean Scope: Singleton
14.6
Was du wissen musst
15
Übung: Dependency Injection in Aktion
15.1
Ziel
15.2
Schritt 1: Das Interface definieren
15.3
Schritt 2: Die In-Memory-Implementierung
15.4
Schritt 3: Der Service
15.5
Schritt 4: Domain-Klasse anpassen
15.6
Schritt 5: Controller erweitern
15.7
Schritt 6: Testen
15.8
Was hier passiert ist
15.9
Bonus: Die Injection sichtbar machen
16
Component Scan
16.1
Das Prinzip
16.2
Wo der Scan startet
16.3
Die häufigste Fehlerquelle
16.4
Scan-Bereich erweitern
16.5
Was der Scan ignoriert
16.6
Performance-Aspekt
17
Die Stereotypen-Annotationen
17.1
Die Familie
17.2
@Component
17.3
@Service
17.4
@Repository
17.5
@Controller
17.6
@RestController
17.7
Wann welche Annotation?
17.8
Warum die Unterscheidung?
18
Was passiert beim Projektstart?
18.1
Die Startsequenz
18.2
Phase 1: Bootstrap
18.3
Phase 2: Component Scan
18.4
Phase 3: Dependency Resolution
18.5
Phase 4: Bean-Erzeugung
18.6
Phase 5: Auto-Configuration
18.7
Phase 6: Server-Start
18.8
Die Konsolenausgabe lesen
18.9
Wenn etwas schiefgeht
18.10
Die Startzeit optimieren
19
Übung: Component Scan sichtbar machen
19.1
Teil 1: Beans auflisten
19.2
Teil 2: Eine Bean verstecken
19.3
Teil 3: Package-Grenzen testen
19.4
Teil 4: Debug-Logging aktivieren
20
Der ApplicationContext
20.1
Was ist der ApplicationContext?
20.2
Der Context in Aktion
20.3
Singleton-Container
20.4
Context-Hierarchien
20.5
Der Context als Vermittler
20.6
ApplicationContext vs. BeanFactory
20.7
Zugriff auf den Context
21
Die Schichtenarchitektur
21.1
Die drei Schichten
21.2
Im Arcade-Projekt
21.3
Warum Schichten?
21.4
Die Regeln
21.5
Was in welche Schicht gehört
21.6
Ein Anti-Pattern
21.7
Schichten sind keine Bürokratie
22
Bootstrapping einer Spring-Boot-Anwendung
22.1
Der Einstiegspunkt
22.2
Was
@SpringBootApplication
bedeutet
22.3
Der Bootstrap-Prozess
22.4
Kommandozeilenargumente
22.5
ApplicationRunner und CommandLineRunner
22.6
Startup-Events
22.7
Graceful Shutdown
22.8
Das Ergebnis
23
Auto-Configuration und Embedded Server
23.1
Auto-Configuration im Überblick
23.2
Wie es funktioniert
23.3
Was Auto-Configuration nicht kann
23.4
Der Embedded Server
23.5
Welcher Server?
23.6
Server-Konfiguration
23.7
Das JAR ist alles
23.8
Wann kein Embedded Server?
23.9
Das Zusammenspiel
24
Properties und YAML
24.1
Zwei Formate, ein Zweck
24.2
Wo die Dateien liegen
24.3
Was konfiguriert werden kann
24.4
Typische Konfiguration
24.5
YAML-Syntax Grundlagen
24.6
Umgebungsvariablen
24.7
Prioritäten
25
Profile
25.1
Die Idee
25.2
Profile-spezifische Dateien
25.3
Profil aktivieren
25.4
Was passiert beim Start
25.5
Mehrere Profile
25.6
Beans pro Profil
25.7
Typische Profile
25.8
Für das Arcade-Projekt
25.9
Ein Wort der Warnung
26
Konfigurationswerte einbinden
26.1
@Value
– der direkte Weg
26.2
Defaultwerte
26.3
@Value
mit Constructor Injection
26.4
@ConfigurationProperties
– der typsichere Weg
26.5
Properties-Klasse nutzen
26.6
Wann welchen Ansatz?
26.7
Eigene Properties im Arcade-Projekt
27
Übung: Konfiguration anwenden
27.1
Teil 1: Eigene Properties definieren
27.2
Teil 2: Properties im Controller nutzen
27.3
Teil 3: Template anpassen
27.4
Teil 4: Entwicklungsprofil anlegen
27.5
Teil 5: Profil aktivieren
27.6
Teil 6: Produktionsprofil (optional)
27.7
Teil 7: Default-Profil setzen
27.8
Ergebnis prüfen
27.9
Bonus: Umgebungsvariable testen
27.10
Zusammenfassung