Spring Boot

ein Java DI Framework

Informatik – 3. Semester

Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

Warum Spring?

Software- und Web-Engineering I · TH Lübeck
Ausgangssituation in SWE I
  • Ihr kennt bereits HTML, CSS, JS, TS & DI
  • Letzte Woche: REST und Web-APIs, also die Schnittstelle zwischen Front- und Back-End
  • Fokus verschiebt sich nun auf serverseitige Umsetzung für das Teamprojekt
  • Gemeinsames Vokabular für Backend-Architektur schafft die Basis für die Umsetzung in Phase 4
Software- und Web-Engineering I · TH Lübeck
Warum Spring Boot im Teamprojekt?
  • Geht gut mit Java-Kenntnissen aus INF1 / INF2
  • Bietet meinungsstarkes Setup (Konvention vor Konfiguration) und minimiert Boilerplate
  • Riesiges Ökosystem mit Starter-Modulen, Guides und Community-Support
Software- und Web-Engineering I · TH Lübeck
Framework-Wahl
  • Welche Kriterien habt ihr bei bisherigen Projekten genutzt?
  • Passt ein monolithischer Ansatz für das kommende Teamprojekt?
  • Welche Risiken seht ihr, wenn jedes Team Mitglied ein anderes Framework nutzt?
Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

Was gibt es alles so?

Software- und Web-Engineering I · TH Lübeck
JVM-Framework-Landschaft
  • Alternative Frameworks: Jakarta EE, Micronaut, Quarkus, Play, Vaadin
  • Spring ist de-facto-Standard im Enterprise/Cloud Umfeld
  • Stärke: Modularer Aufbau + grosse Auswahl an Community Projekten
Software- und Web-Engineering I · TH Lübeck
Spring Baukasten im Überblick
  • Spring Core liefert IoC-Container, Bean-Verwaltung, SpEL
  • Zusatzmodule für Data Access (JDBC, JPA, Hibernate), Web (MVC), AOP
  • Spring Boot als Glue-Schicht für Konfiguration, Auto-Setup, Starter-Abhängigkeiten
Software- und Web-Engineering I · TH Lübeck
Spring Core Komponenten
  • ApplicationContext verwaltet Beans inklusive Instanziierung, Scopes und Lifecycle-Hooks
  • Bean-Definitionen lassen sich über Annotationen konfigurieren und vom Container auflösen
  • SpEL (Spring Expression Language) ermöglicht dynamische Werte in Konfigurationen und Annotationen
  • Kernmodul bildet die Basis für spätere Erweiterungen wie Data, Web oder Security
Software- und Web-Engineering I · TH Lübeck
Kernmodule und Schichten
  • Web-Schicht: Controller, Views, REST-Endpoints
  • Service-Schicht: Business-Logik, Transaktionen
  • Data-Schicht: Repositories, Persistence-Abstraktionen
Spring Boot flow architecture
Quelle: https://miro.medium.com/0*qTIkBrhl90wcE6oK.png
Software- und Web-Engineering I · TH Lübeck
Cross-Cutting Concerns mit AOP
  • Viele Anwendungen brauchen Logging, Tracing, Security Checks
  • Aspektorientierung kapselt solche Funktionen in Wiederverwendungsbausteinen
  • Pointcuts beschreiben, wo Aspekte greifen; Advice (before/after) definiert Verhalten
Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

Dependency Injection & Beans

Software- und Web-Engineering I · TH Lübeck
Prinzip der Inversion of Control
  • Objekte erzeugen ihre Abhängigkeiten nicht selbst; Container uebernimmt das
  • Führt zu lose gekoppelten Komponenten und erleichtert Unit Tests
  • Ermöglicht austauschbare Implementierungen (z.B. Mock vs echte Datenbank)
Statt „ich hole mir, was ich brauche“ -> „ich bekomme, was ich brauche“
Software- und Web-Engineering I · TH Lübeck
Setter vs Constructor Injection
  • Constructor Injection erzwingt komplette Abhängigkeiten, ideal für Immutability
  • Setter Injection erlaubt optionale Abhängigkeiten und späte Bindungen
  • In Spring können beide gemischt auftreten, Constructor Injection ist bevorzugt
class UserRegistrationService {
  private emailPort!: EmailPort;

  setEmailPort(emailPort: EmailPort) {
    this.emailPort = emailPort;
  }

  register(email: string) {
    // ... User speichern
    this.emailPort.send(email, 'Willkommen!');
  }
}
Software- und Web-Engineering I · TH Lübeck
Bean-Lebenszyklus verstehen
  • Definition via Annotationen (@Component, @Service, @Repository) oder Config-Klassen
  • Container instanziiert, verwaltet Scope und sorgt für Cleanup
  • Hooks wie @PostConstruct / @PreDestroy für Initialisierung und Aufräumen
Software- und Web-Engineering I · TH Lübeck
Beispiel: Service mit Repository
@Service
public class GreetingService {
  private final GreetingRepository repo;

  public GreetingService(GreetingRepository repo) {
    this.repo = repo; // Constructor Injection
  }

  public String greet(String name) {
    return repo.findTemplate().formatted(name);
  }
}
Software- und Web-Engineering I · TH Lübeck
Interfaces identifizieren
  • Welche Komponenten in eurem aktuellen Projekt sollten als Interface modelliert werden?
  • Gebt 2 Beispiele, bei denen ein Austausch (z.B. andere Datenquelle) realistisch ist
  • Diskutiert in 2er-Teams, wie ihr diese Abhängigkeiten injizieren würdet
2 Min
Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

Toolchain & Quickstart

Software- und Web-Engineering I · TH Lübeck
Werkzeuge im Einsatz
  • Java 21 (oder aktuelles LTS), Git für Versionskontrolle
  • Maven oder Gradle als Build-Werkzeuge für Compile/Test/Package
  • IDE oder Editor (IntelliJ, VS Code) plus Spring Boot DevTools für Hot Reload
Java Maven Gradle Java Duke
Wikipedia.org
Software- und Web-Engineering I · TH Lübeck
Spring Initializr Workflow
  • https://start.spring.io/ aufrufen, Projektmetadaten ausfüllen
  • Wichtige Starter: Spring Web, Spring Data JDBC/JPA, Thymeleaf, H2, DevTools
  • Projekt als ZIP laden, entpacken, ins Repo importieren
Spring Initializr
Software- und Web-Engineering I · TH Lübeck
Projektstart per CLI
./mvnw spring-boot:run

# oder Gradle
./gradlew bootRun
Software- und Web-Engineering I · TH Lübeck
Abhängigkeiten planen
  • Gerne auch im Internet recherchieren!
  • Welcher Starter deckt Template-Rendering ab?
  • Welche DB nutzt ihr für Prototypen? (H2, PostgreSQL, ...)
  • Plant zwei Profil-Konfigurationen (dev vs prod) für später
3 Min
Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

MVC = Model View Control

Software- und Web-Engineering I · TH Lübeck
Model vs View
  • Model enthält Attribute, die in der View verfügbar sind
  • Rückgabe ist String (Template-Name) oder View-Objekt bzw. ResponseEntity
  • Achtet auf Namensgleichheit zwischen Rückgabewert und Template-Datei
Software- und Web-Engineering I · TH Lübeck
Request-Response-Fluss visualisieren
  • DispatcherServlet routet jede HTTP-Anfrage an passende Handler
  • Handler gibt View-Namen oder ResponseEntity zurück
DispatcherServlet Request-Response-Fluss
Quelle: https://miro.medium.com/0*TyVNx5Wcxu6429_F.png
Software- und Web-Engineering I · TH Lübeck
Request Mapping und Parameter
  • @GetMapping, @PostMapping, @RequestMapping für Pfade und HTTP-Methoden
  • @RequestParam für Query-Parameter, optional mit defaultValue
  • @PathVariable für Segmente im Pfad, @RequestBody für JSON/Form-Daten
Software- und Web-Engineering I · TH Lübeck
Controller-Grundgeruest
@Controller
public class GreetingController {
  @GetMapping("/greeting")
  public String greeting(@RequestParam(defaultValue = "World") String name,
      Model model) {
    model.addAttribute("name", name);
    return "greeting"; // verweist auf templates/greeting.html
  }
}
Software- und Web-Engineering I · TH Lübeck
Serverseitiges Rendering oder REST?
  • Spring Web kann klassische HTML-Views (JSP, Thymeleaf) oder reine JSON-Antworten liefern
  • Gleiche Controller lassen sich über @ResponseBody oder @RestController zu REST-APIs ausbauen
  • Sessions, Rechte und Rollenverwaltung sind über Spring MVC + Security kombinierbar
  • Entscheidet früh, ob ihr Templates, APIs oder hybride Szenarien braucht, um UI-Team zu entkoppeln
Software- und Web-Engineering I · TH Lübeck
Routing entwerfen
  • Definiert die Pfade für "Team-Board anzeigen" (GET) und "Task anlegen" (POST)
  • Welche Parameter braucht ihr jeweils?
  • Bonus: Wie würdet ihr Validierungsfehler zurückgeben?
3 Min
Software- und Web-Engineering I · TH Lübeck
@Controller
@RequestMapping("/team-board")
class TeamBoardController {
  @GetMapping
  String showBoard(Model model) {
    model.addAttribute("members", teamService.loadMembers());
    model.addAttribute("taskForm", new TaskForm());
    return "team-board";
  }

  @PostMapping("/tasks")
  String addTask(@Valid TaskForm taskForm, BindingResult errors, RedirectAttributes flash) {
    if (errors.hasErrors()) {
      return "team-board";
    }
    boardService.createTask(taskForm);
    flash.addFlashAttribute("message", "Task angelegt");
    return "redirect:/team-board";
  }
}
Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

HTML Templating

Software- und Web-Engineering I · TH Lübeck
Einstieg in Thymeleaf
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
  <body>
    <p th:text="'Hello, ' + ${name} + '!'" />
  </body>
</html>
  • Templates liegen unter src/main/resources/templates
  • Server rendert HTML vor dem Senden an den Client
Software- und Web-Engineering I · TH Lübeck
Variable und Selection Expressions
  • ${book.author.name} greift auf verschachtelte Eigenschaften zu
  • th:object definiert Kontext, *{title} referenziert aktuelles Objekt
  • Eigene Variablen via th:with oder Schleifenvariable in th:each
Software- und Web-Engineering I · TH Lübeck
Message-, Linkund Fragment-Expressions
  • #{main.title} nutzt MessageSource für i18n-Texte
  • @{/order/details(id=${orderId})} erzeugt interne Links inkl. Parameter
  • ~{fragments :: header} bindet wiederverwendbare Markup-Snippets ein
Software- und Web-Engineering I · TH Lübeck
Thymeleaf Fragmente & Wiederverwendung
<!-- fragments.html -->
<div th:fragment="main">
  <header>Team Board</header>
  <div th:insert="~{::body}"></div>
</div>

<!-- general.html -->
<body>
  <div th:insert="~{fragments :: main}">Fallback Content</div>
</body>
  • Fragmente helfen, Header/Footer konsistent zu halten und Duplikate zu vermeiden
  • th:insert oder th:replace entscheidet, ob bestehende Knoten erhalten bleiben
  • Übergebt Variablen an Fragmente via th:with, um dynamische Inhalte zu ermöglichen
Software- und Web-Engineering I · TH Lübeck
Literale und Operationen
  • Unterstützt Strings in '', Zahlen, true/false, null
  • Operatoren: Text (+, | |), arithmetisch (+,-,*,/,%), boolsch (and, or, not)
  • Ternary: condition ? valueIfTrue : valueIfFalse
Software- und Web-Engineering I · TH Lübeck
Basisattribute für Rendering
  • th:text ersetzt Textknoten, th:utext ermöglicht HTML
  • th:each iteriert Listen, th:if / th:unless für Bedingungen
  • Formulare: th:action, th:value, th:field für Bindung an Model-Attribute
Software- und Web-Engineering I · TH Lübeck
Team-Liste rendern
  • Modell liefert List<TeamMember> members
  • Schreibe ein <ul> mit th:each="member : ${members}"
  • Gib Name und Rolle je Person aus; optional Link auf Profil
Software- und Web-Engineering I · TH Lübeck
<ul>
  <li th:each="member : ${members}">
    <a th:href="@{/profiles/{id}(id=${member.id})}" th:text="${member.name}"></a>
    <span th:text="${member.role}"></span>
  </li>
</ul>
Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

Datenbankzugriff über ORMs

Software- und Web-Engineering I · TH Lübeck
Object-Relational Impedance Mismatch
  • Relationale DBs speichern Tabellen + Fremdschlüssel, OO-Code kennt Vererbung/Assoziationen
  • Mapping zwischen beiden Welten fuehrt zu Boilerplate, wenn man reines JDBC nutzt
  • Strategien: Table per Class, Single Table, Joined Subclass
Software- und Web-Engineering I · TH Lübeck
JDBC-Wiederholung & Herausforderungen
  • Direkter JDBC-Zugriff erfordert SQL-Strings, Connection/Statement-Handling und Fehlerbehandlung
  • ResultSet -> Objekt Mapping muss für jede Tabelle von Hand gepflegt werden
  • Transaktionen, Ressourcen-Freigabe und Schema-änderungen führen schnell zu Fragilität
Software- und Web-Engineering I · TH Lübeck
Grenzen von JDBC-Only
  • SQL wird hart codiert; Schema-änderungen erzeugen manuellen Aufwand
  • Mapping von ResultSet -> Objekt ist wiederkehrend und fehleranfällig
  • Welche Probleme habt ihr bereits erlebt?
Software- und Web-Engineering I · TH Lübeck
DAO Pattern Wiederholung
  • DAO kapselt DB-spezifische Zugriffe, stellt CRUD-Methoden bereit
  • Kennt Verbindung, Queries, Transaktionen
  • Bsp. accountDao.create(account) aus ORMLite Code
Software- und Web-Engineering I · TH Lübeck
Beispiel: ORMLite DAO
String databaseUrl = "jdbc:h2:mem:account";
ConnectionSource connectionSource = new JdbcConnectionSource(databaseUrl);
Dao<Account, String> accountDao = DaoManager.createDao(connectionSource, Account.class);

Account account = new Account();
account.setName("Jim Coakley");
accountDao.create(account);
  • Library übernimmt SQL-Generierung und Mapping, dennoch bleibt man nah an JDBC dran
  • Zeigt, warum vollwertige ORM-Frameworks wie JPA/Hibernate noch mehr Komfort liefern
Software- und Web-Engineering I · TH Lübeck
Repository Pattern vs DAO
  • Repository repräsentiert Sammlung von Domain-Objekten
  • Fokus auf Fachsprache (findActiveOrders) statt technische Details
  • Spring Data stellt Standardmethoden automatisch bereit
Software- und Web-Engineering I · TH Lübeck
Verantwortlichkeiten abgrenzen
  • Welche Aufgaben gehören in Service, welche in Repository?
  • Identifiziert 2 Methoden, die eher Business-Logik als DB-Zugriff sind
2 Min
Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

Java Persistence API

Software- und Web-Engineering I · TH Lübeck
JPA Entitäten definieren
@Entity
public class Customer {
  @Id @GeneratedValue
  private Long id;
  private String firstName;
  private String lastName;
  @OneToMany(mappedBy = "customer")
  private List<Address> addresses;
}
  • @Entity mappt Klasse auf Tabelle, Felder auf Spalten
  • @Transient schliesst Felder vom Mapping aus
Software- und Web-Engineering I · TH Lübeck
Spring Data Repositories
  • interface CustomerRepository extends JpaRepository<Customer, Long>
  • Erbt CRUD-Methoden (save, findAll, delete)
  • PagingAndSortingRepository oder CrudRepository für spezielle Fälle
Software- und Web-Engineering I · TH Lübeck
CrudRepository API Ausschnitt
public interface CrudRepository<T, ID> extends Repository<T, ID> {
  <S extends T> S save(S entity);
  Optional<T> findById(ID id);
  Iterable<T> findAll();
  void deleteById(ID id);
  long count();
}
  • Generische Signaturen vermeiden Casting und geben klar vor, was ein Repository leisten muss
  • Spezialisierte Interfaces wie JpaRepository bauen darauf auf und ergänzen Paging/Sorting
Software- und Web-Engineering I · TH Lübeck
Abfragen über Methodennamen
  • findByUsername, findByLastnameOrderByCreatedAtAsc usw.
  • Kombiniert Operatoren (And, Or, Between, Like, IgnoreCase)
  • Spart Boilerplate, solange Query simpel ist
Software- und Web-Engineering I · TH Lübeck
Custom Queries mit @Query
@Query("SELECT u FROM User u WHERE u.status = 1")
List<User> findAllActiveUsers();

@Query(value = "SELECT * FROM users u WHERE u.status = 1", nativeQuery = true)
List<User> findAllActiveUsersNative();
  • JPQL bevorzugt, native SQL für Spezialfälle
Software- und Web-Engineering I · TH Lübeck
Named Queries in Spring Data
@Entity
@NamedQueries({
  @NamedQuery(name = "findAllRecipes", query = "SELECT r FROM Recipe r"),
  @NamedQuery(name = "findRecipeById", query = "SELECT r FROM Recipe r WHERE r.id = :id")
})
public class Recipe {}

List<Recipe> recipes = entityManager.createNamedQuery("findAllRecipes", Recipe.class).getResultList();
  • Wiederverwendbare Abfragen bleiben zentral und lassen sich z.B. für Reporting nutzen
  • Repository-Methoden können die Named Queries automatisch aufrufen, wenn der Name passt
Erleichtert Code-Reviews, weil Query-Definitionen nicht über Klassen verteilt sind
Software- und Web-Engineering I · TH Lübeck
1 Motivation & Rahmen
2 Spring Ökosystem
3 Dependency Injection & Beans
4 Toolchain & Quickstart
5 Spring MVC Controller
6 Thymeleaf Templates
7 Datenbankzugriff über ORMs
8 JPA & Spring Data
9 Spring Security & Sessions

Spring Security & Sessions

Software- und Web-Engineering I · TH Lübeck
Security-Motivation
  • Schutzbedarf: Authentifizierung, Autorisierung, Session-Management
  • Unterstützt HTTP Basic, Form Login, OAuth2, LDAP usw.
  • Session-Handling, Token, Password Encoding integriert
Software- und Web-Engineering I · TH Lübeck
Sicherheitsfilterkette
  • Filter verarbeiten Requests sequenziell; Chain entscheidet über Zugriff
  • Anpassbar ueber SecurityFilterChain Bean
Multi SecurityFilterChain
Quelle: https://docs.spring.io/spring-security/reference/_images/servlet/architecture/multi-securityfilterchain.png
Software- und Web-Engineering I · TH Lübeck
CSRF und Session Management
  • CSRF-Schutz standardmässig aktiv (sollte nur für stateless APIs deaktiviert werden)
  • Sessions benötigen sichere IDs (z.B. JSESSIONID) und Timeouts
  • Best Practices: invalidate session on login/logout, erneuere Tokens nach Rollenwechsel
Software- und Web-Engineering I · TH Lübeck
Grundkonfiguration per Java Config
@Configuration
@EnableWebSecurity
public class SecurityConfig {
  @Bean
  SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http.authorizeHttpRequests(auth -> auth
        .requestMatchers("/css/**", "/images/**").permitAll()
        .anyRequest().authenticated())
      .formLogin().and()
      .logout();
    return http.build();
  }
}
Software- und Web-Engineering I · TH Lübeck
Method Security Annotations
  • @EnableGlobalMethodSecurity oder @EnableMethodSecurity aktiviert @Secured, @RolesAllowed, @PreAuthorize
  • Fein-granulare Kontrolle auf Service-Ebene, z.B. @PreAuthorize("hasRole('ADMIN')")
  • Ideal für Use-Cases, bei denen URL-basierte Regeln nicht reichen
Software- und Web-Engineering I · TH Lübeck
URL-Absicherung planen
  • Welche Endpunkte sollen öffentlich bleiben?
  • Welche Rollen braucht ihr mindestens für euer Projekt?
  • Skizziert eine SecurityFilterChain für eure API
3 Min
Software- und Web-Engineering I · TH Lübeck
Software- und Web-Engineering I · TH Lübeck

- Einstieg: Spring Boot als Java-DI-Framework vorstellen - Nicht auf dem Titel verweilen

- Motivation: begruenden, warum serverseitige Themen jetzt Vorrang haben und an INF1/INF2 anschliessen - Rahmenbedingung: Teamprojekt braucht skalierbares Backend, Architekturentscheidungen (Monolith vs. Services) vorwegnehmen

- Technologien einzeln aufgreifen: HTML, CSS, JS, TS, DI (Dependency Injection), REST; wir bauen darauf auf - DI-Konzepte aus der DI-Vorlesung werden explizit auf Spring Boot uebertragen

- Erinnern: Java aus INF1/INF2 bekannt, Spring Boot nutzt diese Kenntnisse direkt - Starter wie spring-boot-starter-web als Beispiel fuer Konvention-vor-Konfiguration; Community-Ressourcen (Spring Guides, Baeldung) nennen

- Kriterienliste (z.B. Lernkurve, Deployment) sammeln, Monolith vs. Microservices abwaegen, Risiken heterogener Frameworks betonen - Loesungsvorschlag: einheitlicher Tech-Stack, klare Evaluationskriterien (Performance, Testbarkeit, Deployment-Automation)

- Historie: Spring als Reaktion auf schwergewichtiges J2EE (Java 2 Platform, Enterprise Edition) - Uebergang zu Spring Boot als leichter Einstieg, der den Modulkatalog buendelt

- Alternativen knapp einordnen: Jakarta EE (Enterprise-Plattform), Micronaut/Quarkus (Cloud/Serverless), Play (reaktiv), Vaadin (UI-first) - Empfehlung: bei Greenfield-Projekten Messwerte (Startup-Zeit, Speicher) aufnehmen, um Entscheidungen zu objektivieren

- Begriffe glossieren: IoC (Inversion of Control), SpEL (Spring Expression Language), JDBC (Java Database Connectivity), JPA (Jakarta Persistence API), AOP (Aspect-Oriented Programming) - Beispiel: spring-boot-starter-data-jpa plus spring-boot-starter-web zeigen, wie Boot Module per Starter zusammenstellt

- ApplicationContext als IoC-Container beschreiben: Beans inkl. Scope (Singleton, Prototype) - SpEL anhand @Value("#{systemEnvironment['HOME']}") demonstrieren

- Schichtenmodell erklaeren: Web (Controller + Views/REST), Service (Business-Logik, Transaktionen), Data (Repositories, Persistenz) - Beispiel-Flow: HTTP-Request → Controller validiert → Service fuehrt Geschaeftsregel aus → Repository spricht DB an

- AOP (Aspect-Oriented Programming) trennt Logging, Tracing, Security Checks vom Kerncode - Beispiel: @Around-Advice sammelt Metriken; Pointcuts eng definieren (z.B. Package com.example.service..*)

- Fragen, wer bereits mit DI in Spring, Angular oder anderen Frameworks gearbeitet hat - Ankuendigen: vom Konzept (Inversion of Control) zu Spring-Annotationen wie @Component oder @Service

- IoC: Objekte bekommen Abhaengigkeiten vom Container geliefert, statt sie selbst zu erzeugen - Beispiel: MailService erhaelt echten SMTP-Client oder Fake-Adapter; @Primary/@Profile stellen beim Testen alternative Beans bereit

- Constructor Injection erzwingt vollstaendige Abhaengigkeiten (gut fuer Immutability), Setter fuer optionale/spaete Bindungen - Beispiel: Feature-Flag-Service via Setter; im Alltag Constructor Injection, ggf. mit Lombok @RequiredArgsConstructor

- Annotationen registrieren Beans; Container instanziiert, verwaltet Scope (z.B. Singleton), ruft Lifecycle-Hooks - Beispiel: CommandLineRunner zeigt beim Start, wann Beans entstehen; @PreDestroy schliesst Ressourcen wie DB-Verbindungen

- @Service kennzeichnet die Bean, Constructor Injection sorgt fuer ein final Repository, greet ruft repo.findTemplate().formatted(name) auf - GreetingRepository kann ein Spring-Data-Repository sein; Umgang mit fehlenden Templates diskutieren (Optional, Exception, Fallback)

- Kandidaten: PaymentProvider, MailAdapter, StorageService - Loesungsidee: erst Contracts schreiben, dann Implementierungen ueber @Profile("dev")/@Profile("prod") bzw. Mocks austauschen

- Zeigen, welche Werkzeuge noetig sind, um in Minuten ein Spring-Boot-Projekt aufzusetzen; GUI (Spring Initializr) vs. CLI - Vom Setup direkt in IDE/Editor springen, Toolchain live demonstrieren

- Tools erlaeutern: Java 21 (LTS), Git, Maven/Gradle, IntelliJ oder VS Code plus Spring Boot DevTools (Hot Reload) - Konkretes Setup: VS Code mit Spring Extension Pack, gemeinsames JDK im Team fuer reproduzierbare Builds

- Schritt fuer Schritt: start.spring.io oeffnen, Group/Artifact ausfuellen, Starter waehlen, ZIP laden, ins Repo legen - Tipp: Maven/Gradle Wrapper (mvnw, gradlew) einchecken, damit alle dieselbe Build-Version nutzen

- Kommandos erklaeren: ./mvnw spring-boot:run (Maven Wrapper), ./gradlew bootRun (Gradle); Standard-Port 8080 - DevTools: Hot Reload (Speichern → Browser-Reload), in Produktion deaktivieren

- Erwartung: spring-boot-starter-thymeleaf fuer Templates, H2 (in-memory) oder PostgreSQL fuer Prototyp - Loesungsidee: application-dev.yml mit H2 + DevTools, application-prod.yml mit PostgreSQL + Flyway, aktiviert via spring.config.activate.on-profile

- MVC steht fuer Model-View-Controller; typischen HTTP-Lifecycle kurz beschreiben - Vorwissen aktivieren: Wer hat @Controller, @RestController, @GetMapping schon genutzt?

- Model haelt View-Attribute; Rueckgabename muss zur Template-Datei passen (greeting → templates/greeting.html) - Fuer REST-Endpunkte ResponseEntity erwaehnen (Statuscodes, Header exakt steuern)

- Flow: Browser → DispatcherServlet → Handler Mapping → Controller (ModelAndView) → View Resolver → View rendern → Response - Beispiel: GET /teams landet im Controller, ruft TeamService/TeamRepository, Thymeleaf rendert die View

- Annotationen an Beispielen erlaeutern: @RequestParam mit defaultValue, @PathVariable fuer URL-Segmente, @RequestBody fuer JSON/Form-Data - Zusatz: bei Formularen DTO + @Valid + BindingResult fuer saubere Validierungsfehler

- @Controller markiert die MVC-Komponente, @GetMapping("/greeting") mappt GET, @RequestParam liest Query-Parameter, Model fuellt die View - Alternative: @RestController/@ResponseBody liefert JSON; Demo-URL http://localhost:8080/greeting?name=Sam

- SSR (Server-Side Rendering) vs. REST erklaeren; @ResponseBody/@RestController machen aus MVC-Controllern APIs - Praxisfall: Admin-Interface per SSR, Mobile-App ueber REST; bei hybriden Szenarien CORS konfigurieren

- Erwartung: GET /team-board (Board zeigen), POST /tasks (Task anlegen) mit Titel, Beschreibung, Verantwortlichem - Bonusloesung: Validierungsfehler via BindingResult + Rueckkehr zur View, in REST-Szenarien HTTP 400 mit Fehlerobjekt

- Loesungsfolie zur Routing-Uebung: GET zeigt Board, POST legt Task an - @Valid + BindingResult fuer Validierung, RedirectAttributes fuer Flash-Message nach Redirect

- Thymeleaf: serverseitige Java-Template-Engine, vergleichbar mit Handlebars oder JSX, voll im Spring Stack integriert - Vorteil: SSR ist SEO-freundlich und passt zu klassischen Formular-Workflows

- xmlns:th bindet Thymeleaf, th:text setzt den Textknoten mit Expression und escaped HTML automatisch - Demo: name-Attribut im Model setzen, DevTools-Reload zeigen; th:utext liefert unescaped HTML

- ${...} greift verschachtelte Properties ab, th:object setzt Kontext, *{...} referenziert das aktuelle Objekt - th:with fuer Hilfsvariablen (z.B. count=${members.size()}); SpEL kann Methoden aufrufen

- #{...} holt Messages aus messages.properties (i18n), @{...} baut URLs inkl. Parameter, ~{...} bindet Fragmente - Beispiel: @{/order/details(id=${orderId})} generiert /order/details?id=...; relative Links sind Context-Path-safe

- th:fragment="main" definiert wiederverwendbares Fragment, th:insert fuegt es ein; ~{::body} referenziert den Body des aktuellen Templates - Variablen via th:with an Fragmente uebergeben; Layout-Dialekt erlaubt komplexere Masterpages

- String-, Zahlen-, Boolean-Literale und Operatoren fuer Text, Arithmetik und Booleans; ternaere Ausdruecke - Beispiel: member.active ? 'Aktiv' : 'Inaktiv' fuer Status-Badges; Piped-Literale |Hello ${name}| fuer lesbare Strings

- th:text ersetzt Textinhalt, th:utext laesst HTML zu, th:each iteriert, th:if/th:unless steuern Sichtbarkeit - Formular-Beispiel: <form th:object="${task}"> mit th:field="*{title}" und th:errors fuer Fehlermeldungen

- Aufgabe: members iterieren, <ul> bauen, Name + Rolle ausgeben, optional Profil verlinken - Loesung folgt auf der naechsten Folie

- Loesungsfolie zur Team-Liste: th:each iteriert, th:text rendert Name/Rolle sicher (kein HTML-Injection) - Link zeigt, wie Parameter mit @{} gesetzt werden; fuer reine Textausgabe kann der a-Block entfallen

- ORM = Object-Relational Mapping; Anekdote: Legacy-JDBC-Projekt motivierte die Einfuehrung eines ORM - Ziel: Domainlogik von Persistenzdetails trennen (Wartbarkeit, Testbarkeit)

- Impedance Mismatch: relationale Tabellen vs. objektorientierte Konzepte (Vererbung, Assoziationen) - Strategien erlaeutern und Beispiel skizzieren (PaymentMethod-Hierarchie → Single Table)

- Reines JDBC (Java Database Connectivity) erfordert viel Boilerplate und manuelles Mapping - Risiken: fehlende finally-Bloecke → Connection-Leaks, Copy-Paste-SQL schwer wartbar, Tests brauchen viel Setup

- Hart codierte SQL-Strings, manuelles Mapping, hoher Aufwand bei Schemaaenderungen - Loesungshinweis: wenn kein ORM moeglich, wenigstens RowMapper-Utilities oder DAOs bauen

- DAO (Data Access Object): kapselt DB-Zugriffe, stellt CRUD-Methoden bereit, kennt Connections/Queries/Transaktionen - Beispiel: AccountDao-Interface mit create, find, delete; Tests mit H2 (In-Memory) oder Mocks

- JdbcConnectionSource verbindet zur H2-In-Memory-DB, DaoManager.createDao erzeugt das DAO, create persistiert - Vergleich zu Spring Data (Container verwaltet DataSource); connectionSource mit try-with-resources schliessen

- Repository: Sammlung von Domain-Objekten mit fachlichen Methodennamen; DAO ist technisch (SQL-orientiert) - Spring Data generiert Standardmethoden; Services koennen Domain-Events ausloesen

- Erwartung: Services fuer Business-Logik/Transaktionen, Repository fuer Datenzugriff - Testvorschlag: Service-Tests mit Mock-Repositories (Mockito) plus Integrationstests mit H2/PostgreSQL

- JPA = Jakarta Persistence API, Spring Data baut darauf auf; Ziel: CRUD-Repositories erstellen und Queries anpassen - Kontext: H2 (In-Memory) in dev, PostgreSQL in prod; JPA abstrahiert die Unterschiede

- @Entity mappt die Klasse auf eine Tabelle, @Id @GeneratedValue markiert den Primaerschluessel, @OneToMany(mappedBy = "customer") beschreibt die Beziehung - @Table ueberschreibt Tabellennamen; equals/hashCode sorgfaeltig umsetzen

- JpaRepository erbt CRUD, Paging und Sorting; PagingAndSortingRepository/CrudRepository sind schlankere Alternativen - Spring Data generiert Implementierungen zur Laufzeit per Proxy, es braucht nur Interfaces

- Kernvertrag: save, findById, findAll, deleteById, count - Tipp: fuer Tests laesst sich eine In-Memory-Implementierung via Map<ID,T> erstellen

- Spring Data parst Methodennamen und generiert SQL/HQL daraus; Operatoren And, Or, Between, Like, IgnoreCase - Beispiel findByEmailIgnoreCaseAndStatus; bei komplexen Namen ist @Query besser lesbar

- JPQL (Jakarta Persistence Query Language, objektorientierte Syntax) vs. native SQL - Tipp: benannte Parameter (:status) verwenden; bei Reporting/Aggregationen native SQL einsetzen

- @NamedQueries definiert JPQL-Statements auf der Entitaet, entityManager.createNamedQuery ruft sie per Name auf - Spring Data nutzt Named Queries automatisch bei gleichem Methodennamen (RecipeRepository.findAllRecipes())

- Spring Security mit Session-Management kombinieren; Minimal-Setup fuer Teamprojekte zeigen - Vorwissen abfragen: Wer hat schon mit Spring Security oder JWT (JSON Web Tokens) gearbeitet?

- Authentifizierung (Wer bist du?), Autorisierung (Was darfst du?), Session-Management (Zustand halten) - Praxisbeispiel: ungesicherter Admin-Endpoint → Datenleck; Passwoerter via BCryptPasswordEncoder hashen

- FilterChainProxy enthaelt Filter wie AuthenticationFilter, AuthorizationFilter, CsrfFilter; sie laufen sequenziell - Diagramm: DelegatingFilterProxy → FilterChainProxy waehlt die passende SecurityFilterChain (z.B. /api/** vs /**), danach geht es weiter zum Servlet

- CSRF (Cross-Site Request Forgery) ist standardmaessig aktiv; Angriffsbeispiel: https://bank.example/transfer?to=hacker&amount=1000 - Best Practices: Session bei Login/Logout invalidieren, Tokens rotieren, Secure + HttpOnly Flags setzen

- @EnableWebSecurity aktiviert Spring Security; requestMatchers("/css/**") → permitAll, anyRequest().authenticated() - formLogin() aktiviert die Standard-Login-Seite, logout() den /logout-Endpunkt; fuer REST-APIs ggf. csrf deaktivieren

- Annotationen sichern Service-Methoden ab, wenn URL-Regeln nicht reichen - Beispiel: @PreAuthorize("#userId == authentication.principal.id"); DTOs auf erlaubte Felder pruefen

- Erwartung: offene Endpunkte (/public/**), Rollen (z.B. ROLE_ADMIN fuer /admin/**), /api/** via Session oder JWT - Empfehlung: Ergebnisse als Security-Kapitel im Teamprojekt dokumentieren

- Leere Abschlussfolie wie im Original (pptx-Folie 62, Titel-Layout ohne Inhalt) - Raum fuer Fragen und Abschlussdiskussion