Woche 3, Tag 2 — Spring Boot Starters und Dependency Management

Ziel

Heute verstehst du Spring Boot Starters und Dependency Management.

Die Kernfragen:

Was ist ein Spring Boot Starter?
Warum gibt es Starters?
Was ist Dependency Management?
Welches Problem löst Spring Boot Dependency Management?
Was ist der Unterschied zwischen einem Starter und Auto-Configuration?
Was ist eine transitive Dependency?
Warum solltest du Versionen meist nicht manuell angeben?
Was ist das Spring Boot Parent POM?
Was ist das Spring Boot BOM?
Wie funktioniert das in Gradle?
Welche Starter Dependencies sind häufig?
Welche typischen Prüfungsfallen gibt es?

1. Kurz-Wiederholung von Woche 3, Tag 1

An Tag 1 hast du gelernt:

Spring Boot macht Spring Applications einfacher zu konfigurieren, zu starten und zu deployen.
@SpringBootApplication enthält:

@Configuration
@EnableAutoConfiguration
@ComponentScan

@EnableAutoConfiguration aktiviert Spring Boot Auto-Configuration.
Auto-Configuration ist conditional.
Starters bringen Dependencies.
Auto-Configuration konfiguriert Beans basierend auf diesen Dependencies.

Merksatz:

Starters bringen Libraries.
Auto-Configuration konfiguriert sie.

Heute gehst du tiefer in Starters und Dependency Management ein.

2. Was ist ein Spring Boot Starter?

Ein Spring Boot Starter ist ein Dependency Bundle.

Er gruppiert häufige Dependencies für ein bestimmtes Feature.

Beispiel:

implementation("org.springframework.boot:spring-boot-starter-web")

Diese eine Dependency bringt die üblichen Libraries, die du für eine Spring MVC Web Application brauchst.

Kurze Definition:

Ein Spring Boot Starter ist eine praktische Dependency, die einen Satz zusammengehöriger Libraries für ein häufiges Application Feature mitbringt.

3. Warum gibt es Starters?

Ohne Starters müsstest du viele Dependencies manuell auswählen.

Für eine Web Application bräuchtest du vielleicht:

Spring MVC
Jackson JSON support
embedded Tomcat
logging
validation if needed
Spring core dependencies

Statt viele Dependencies manuell hinzuzufügen, fügst du hinzu:

implementation("org.springframework.boot:spring-boot-starter-web")

Spring Boot liefert ein sinnvolles Dependency Set.

Merksatz:

Starters reduzieren Dependency Boilerplate.

4. Starter bedeutet nicht Auto-Configuration

Wichtige Unterscheidung:

Starter = dependency bundle
Auto-Configuration = bean configuration mechanism

Beispiel:

implementation("org.springframework.boot:spring-boot-starter-web")

Der Starter legt Web Libraries auf den Classpath.

Dann sieht Auto-Configuration diese Libraries und konfiguriert:

embedded Tomcat
Spring MVC
DispatcherServlet
HTTP message converters
JSON serialization

Der Starter selbst „startet“ die App nicht.

Er bringt nur Dependencies.

5. Starter vs Auto-Configuration

Thema	Starter	Auto-Configuration
Was es ist	dependency bundle	automatic bean setup
Funktioniert über	Maven/Gradle dependencies	Spring Boot conditions
Beispiel	`spring-boot-starter-web`	`WebMvcAutoConfiguration`
Hauptaufgabe	bringt Libraries	konfiguriert Beans
Basiert auf	dependency metadata	classpath, properties, beans

Merksatz:

Der Starter legt die Tools in die Box. Auto-Configuration entscheidet, wie sie genutzt werden.

6. Beispiel: Web Starter

Gradle:

implementation("org.springframework.boot:spring-boot-starter-web")

Das gibt dir eine klassische servlet-basierte Web Application.

Häufige Dinge, die er mitbringt:

Spring MVC
embedded Tomcat
Jackson JSON support
Spring Boot core starter
logging support

Dann kannst du schreiben:

@RestController
@RequestMapping("/api/hello")
public class HelloController {

    @GetMapping
    public String hello() {
        return "Hello";
    }
}

Spring Boot kann diesen Endpoint bereitstellen, weil die Web Dependencies und die Web Auto-Configuration vorhanden sind.

7. Wichtig: Validation ist meist separat

Nimm nicht an, dass Validation immer im Web Starter enthalten ist.

Für Bean Validation Annotations wie:

@NotBlank
@Email
@Valid

fügst du normalerweise hinzu:

implementation("org.springframework.boot:spring-boot-starter-validation")

Beispiel DTO:

public record CreateUserRequest(
        @NotBlank String name,
        @Email String email
) {
}

Controller:

@PostMapping
public void createUser(@Valid @RequestBody CreateUserRequest request) {
}

Merksatz:

Für Validation nutze spring-boot-starter-validation.

8. Häufige Spring Boot Starters

Häufige Starters:

spring-boot-starter
spring-boot-starter-web
spring-boot-starter-webflux
spring-boot-starter-data-jpa
spring-boot-starter-data-mongodb
spring-boot-starter-security
spring-boot-starter-validation
spring-boot-starter-test
spring-boot-starter-actuator
spring-boot-starter-mail
spring-boot-starter-cache
spring-boot-starter-quartz

Du musst nicht jeden Starter auswendig kennen.

Aber du solltest das Muster verstehen.

9. `spring-boot-starter`

Das ist der Core Starter.

Er enthält grundlegende Spring Boot Dependencies wie:

Spring Boot core
Spring Framework core support
logging
auto-configuration support
YAML/property support through Boot infrastructure

Die meisten anderen Starters hängen von ihm ab.

Beispiel:

implementation("org.springframework.boot:spring-boot-starter")

Nutze ihn für Non-Web Apps, Worker, CLI Apps oder Background Services.

10. `spring-boot-starter-web`

Nutze ihn für klassische REST APIs und Spring MVC Apps.

implementation("org.springframework.boot:spring-boot-starter-web")

Typische Use Cases:

REST API
MVC web application
JSON HTTP endpoints
Servlet-based web app

Häufiger Stack:

Spring MVC
embedded Tomcat
Jackson

11. `spring-boot-starter-webflux`

Nutze ihn für reactive Web Applications.

implementation("org.springframework.boot:spring-boot-starter-webflux")

Typische Use Cases:

reactive HTTP APIs
non-blocking web clients
high-concurrency reactive systems

Meist basiert auf:

Spring WebFlux
Project Reactor
Reactor Netty by default

Wichtig:

Mische spring-boot-starter-web und spring-boot-starter-webflux nicht wahllos — außer du verstehst den Application Type.

Für die meisten normalen REST APIs nutze:


spring-boot-starter-web

12. `spring-boot-starter-data-jpa`

Nutze ihn für relationalen Datenbankzugriff mit JPA.

implementation("org.springframework.boot:spring-boot-starter-data-jpa")

Häufig genutzt mit:

PostgreSQL
MySQL
MariaDB
H2

Er bringt Support für:

Spring Data JPA
Hibernate
JPA repositories
transaction infrastructure

Du brauchst trotzdem einen Database Driver.

Beispiel PostgreSQL Driver:

runtimeOnly("org.postgresql:postgresql")

Merksatz:

Der JPA Starter gibt JPA Support — aber du brauchst trotzdem den Database Driver.

13. Beispiel: JPA Dependencies

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    runtimeOnly("org.postgresql:postgresql")
}

Konfiguration:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/app
    username: postgres
    password: postgres

Ohne Database Config oder embedded Database kann die App fehlschlagen, weil Boot versucht, eine DataSource zu konfigurieren.

14. `spring-boot-starter-security`

Nutze ihn für Spring Security.

implementation("org.springframework.boot:spring-boot-starter-security")

Wichtiger Effekt:

Der Security Starter ändert das Application Verhalten.

Für eine Web App kann Spring Boot Endpoints standardmäßig absichern.

Du musst oft eine Security Configuration definieren:

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
                .authorizeHttpRequests(auth -> auth
                        .anyRequest().authenticated()
                )
                .build();
    }
}

Prüfungsfalle:

Manche Starters fügen nicht nur Libraries hinzu — sie triggern auch Auto-Configuration, die das Verhalten ändert.

15. `spring-boot-starter-actuator`

Nutze ihn für Production Monitoring Endpoints.

implementation("org.springframework.boot:spring-boot-starter-actuator")

Häufige Actuator Endpoints:

/actuator/health
/actuator/info
/actuator/metrics
/actuator/beans
/actuator/conditions
/actuator/configprops

Beispiel Config:

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics

Merksatz:

Actuator fügt production-ready Monitoring- und Management Endpoints hinzu.

16. `spring-boot-starter-test`

Nutze ihn für Tests.

testImplementation("org.springframework.boot:spring-boot-starter-test")

Er bringt häufig Testing Libraries wie:

JUnit Jupiter
Spring Test
AssertJ
Mockito
Hamcrest
JSONassert
JsonPath

Dann kannst du schreiben:

@SpringBootTest
class ApplicationTest {

    @Test
    void contextLoads() {
    }
}

17. Was ist eine transitive Dependency?

Eine transitive Dependency ist eine Dependency, die von einer anderen Dependency mitgebracht wird.

Beispiel:

Du fügst hinzu:

implementation("org.springframework.boot:spring-boot-starter-web")

Dieser Starter bringt weitere Dependencies.

Du hast nicht alle manuell hinzugefügt.

Sie sind transitive Dependencies.

Kurze Definition:

Eine transitive Dependency ist eine Dependency, die indirekt über eine andere Dependency kommt.

18. Beispiel für transitive Dependencies

Du fügst eine Dependency hinzu:

implementation("org.springframework.boot:spring-boot-starter-web")

Maven/Gradle löst viele Dependencies auf, zum Beispiel:

spring-web
spring-webmvc
spring-boot-starter-tomcat
spring-boot-starter-json
spring-boot-starter

Du musst nicht jede Library manuell hinzufügen.

Das ist der Komfort von Starters.

19. Das Problem mit manuellen Dependency-Versionen

Ohne Spring Boot Dependency Management würdest du vielleicht schreiben:

implementation("org.springframework:spring-webmvc:6.x.x")
implementation("com.fasterxml.jackson.core:jackson-databind:2.x.x")
implementation("org.apache.tomcat.embed:tomcat-embed-core:10.x.x")
implementation("org.hibernate.orm:hibernate-core:6.x.x")

Problem:

Welche Versionen passen zusammen?
Welche Jackson Version ist kompatibel?
Welche Hibernate Version passt zu Spring Boot?
Welche Tomcat Version ist sicher?

Manuelles Version Management kann schmerzhaft werden.

20. Was ist Dependency Management?

Dependency Management bedeutet:

Ein Build System nutzt ein bekanntes Set von Dependency Versionen, damit Libraries gut zusammenarbeiten.

Spring Boot bietet Dependency Management für viele häufige Libraries.

Du kannst also schreiben:

implementation("org.springframework.boot:spring-boot-starter-web")
runtimeOnly("org.postgresql:postgresql")

ohne Versionen für Boot-managed Dependencies manuell anzugeben.

Merksatz:

Spring Boot verwaltet kompatible Dependency Versionen für dich.

21. Warum Version Alignment wichtig ist

Libraries hängen von anderen Libraries ab.

Wenn Versionen nicht zusammenpassen, kannst du Runtime Errors bekommen wie:

ClassNotFoundException
NoSuchMethodError
NoClassDefFoundError
Bean creation errors
serialization errors
database integration errors

Beispiel Problem:

Spring erwartet eine neuere Methode aus einer Library.
Aber der Classpath enthält eine ältere Version.
Die App schlägt zur Runtime fehl.

Dependency Management reduziert dieses Risiko.

22. Maven: Spring Boot Parent POM

In Maven nutzen viele Projekte:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>...</version>
</parent>

Das Parent POM liefert:

Dependency Management
Plugin Management
Default Java Settings
Resource Filtering Support
sinnvolle Maven Defaults

Dann können Dependencies Versionen weglassen:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Das Parent verwaltet die Version.

23. Maven ohne Parent: BOM

Manchmal kann ein Projekt das Spring Boot Parent nicht nutzen.

Dann kann es das Spring Boot BOM importieren.

BOM bedeutet:


Bill of Materials

Es definiert Dependency Versionen.

Maven Beispiel:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>...</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Dann können Dependencies trotzdem Versionen weglassen.

Merksatz:

Das Spring Boot BOM verwaltet Dependency Versionen ohne das Boot Parent POM.

24. Parent POM vs BOM

Thema	Parent POM	BOM
Maven parent	ja	nein
Dependency versions	ja	ja
Plugin management	ja	nein, nicht dasselbe
Nützlich wenn	normale Boot Maven App	Projekt hat bereits ein anderes Parent
Artifact	`spring-boot-starter-parent`	`spring-boot-dependencies`

25. Gradle: Spring Boot Plugin

In Gradle nutzt ein Spring Boot Projekt oft:

plugins {
    id("org.springframework.boot") version "..."
    id("io.spring.dependency-management") version "..."
    java
}

Oder Kotlin DSL:

plugins {
    id("org.springframework.boot") version "..."
    id("io.spring.dependency-management") version "..."
    kotlin("jvm") version "..."
    kotlin("plugin.spring") version "..."
}

Das Spring Boot Gradle Plugin hilft bei:

Packaging executable JARs
Boot Tasks
Dependency Management Integration
App starten
Layered JARs Support

26. Gradle Dependencies ohne Versionen

Typische Gradle Dependencies:

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    runtimeOnly("org.postgresql:postgresql")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

Beachte:


Für diese Dependencies werden keine Versionen angegeben.

Spring Boot Dependency Management liefert kompatible Versionen.

27. Sollst du Versionen manuell angeben?

Meistens, für Dependencies, die Spring Boot verwaltet:


Nein.

Bevorzuge:

implementation("org.springframework.boot:spring-boot-starter-web")

Vermeide:

implementation("org.springframework.boot:spring-boot-starter-web:3.x.x")

in einem Boot Projekt, das bereits Boot Dependency Management anwendet.

Für Third-Party Dependencies, die Boot nicht verwaltet, musst du vielleicht eine Version angeben.

Merksatz:

Lass Spring Boot Versionen verwalten, wenn möglich.

28. Was, wenn du eine andere Version brauchst?

Manchmal musst du eine verwaltete Version überschreiben.

Beispiel Gründe:

security patch
bug fix
company standard
compatibility issue

Aber sei vorsichtig.

Managed Versionen zu überschreiben kann Kompatibilität brechen.

Best Practice:

Nur überschreiben, wenn nötig.
Verstehe die Auswirkung auf die Kompatibilität.
Bevorzuge ein Spring Boot Upgrade, wenn möglich.

29. Häufiger Fehler: Spring Boot Versionen mischen

Schlechte Idee:

implementation("org.springframework.boot:spring-boot-starter-web:3.3.0")
implementation("org.springframework.boot:spring-boot-starter-data-jpa:3.1.0")

Das kann Dependency Conflicts verursachen.

Besser:

plugins {
    id("org.springframework.boot") version "3.x.x"
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
}

Nutze eine Spring Boot Version, um das Dependency Set zu verwalten.

30. Häufiger Fehler: Web und WebFlux zusammen hinzufügen

Beispiel:

implementation("org.springframework.boot:spring-boot-starter-web")
implementation("org.springframework.boot:spring-boot-starter-webflux")

Das kann in Spezialfällen valide sein, verwirrt aber Anfänger.

Die meisten normalen REST APIs sollten nutzen:


spring-boot-starter-web

Reactive Apps sollten nutzen:


spring-boot-starter-webflux

Merksatz:

Wähle den Web Stack bewusst.

31. Häufiger Fehler: JPA Starter ohne Database

Beispiel:

implementation("org.springframework.boot:spring-boot-starter-data-jpa")

Wenn keine Datasource konfiguriert ist und keine embedded Database verfügbar ist, kann Boot beim Start fehlschlagen.

Warum?

Weil der JPA Starter database-bezogene Auto-Configuration triggert.

Fix Optionen:

Datasource konfigurieren
Database Driver hinzufügen
embedded Database für Tests nutzen
JPA Starter entfernen, wenn nicht nötig
DataSourceAutoConfiguration ausschließen, wenn wirklich nötig

32. Häufiger Fehler: Runtime Driver vergessen

Der JPA Starter weiß nicht automatisch, welche Database du nutzt.

Für PostgreSQL:

runtimeOnly("org.postgresql:postgresql")

Für MySQL:

runtimeOnly("com.mysql:mysql-connector-j")

Für MariaDB:

runtimeOnly("org.mariadb.jdbc:mariadb-java-client")

Merksatz:

Füge den Database Driver für deine Database hinzu.

33. Häufiger Fehler: Validation Starter vergessen

Wenn du nutzt:

@NotBlank
@Valid

aber Validation nicht funktioniert oder Annotations fehlen, brauchst du vielleicht:

implementation("org.springframework.boot:spring-boot-starter-validation")

Das ist häufig in REST APIs.

34. Häufiger Fehler: Zu viele Dependencies

Schlecht:

implementation("org.springframework.boot:spring-boot-starter-web")
implementation("org.springframework:spring-web")
implementation("org.springframework:spring-webmvc")
implementation("com.fasterxml.jackson.core:jackson-databind")

Meist unnötig.

Der Web Starter bringt bereits häufige Web Dependencies.

Zu viele manuelle Dependencies können Version Conflicts erzeugen.

Merksatz:

Starte mit Starters. Füge spezifische Dependencies nur hinzu, wenn nötig.

35. Dependency Scopes / Configurations

In Gradle sind häufige Configurations:

implementation
runtimeOnly
compileOnly
annotationProcessor
testImplementation
testRuntimeOnly
developmentOnly

Beispiele:

implementation("org.springframework.boot:spring-boot-starter-web")
runtimeOnly("org.postgresql:postgresql")
testImplementation("org.springframework.boot:spring-boot-starter-test")
developmentOnly("org.springframework.boot:spring-boot-devtools")

36. `implementation`

Nutze implementation für Dependencies, die zum Kompilieren und Ausführen der App nötig sind.

Beispiel:

implementation("org.springframework.boot:spring-boot-starter-web")

Dein Code nutzt Klassen aus dieser Dependency.

37. `runtimeOnly`

Nutze runtimeOnly für Dependencies, die nur zur Runtime nötig sind.

Beispiel:

runtimeOnly("org.postgresql:postgresql")

Deine App kompiliert normalerweise nicht direkt gegen PostgreSQL Driver Klassen.

Der Driver wird zur Runtime von JDBC gebraucht.

38. `testImplementation`

Nutze testImplementation für Test Dependencies.

Beispiel:

testImplementation("org.springframework.boot:spring-boot-starter-test")

Diese Dependencies sind für Tests verfügbar — nicht für Main Production Code.

39. `developmentOnly`

Nutze developmentOnly für Development-only Tools.

Beispiel:

developmentOnly("org.springframework.boot:spring-boot-devtools")

Devtools können helfen bei:

automatischem Restart
Development Convenience

In Production sollte es nicht nötig sein.

40. Starter Naming Pattern

Die meisten offiziellen Spring Boot Starters folgen:


spring-boot-starter-*

Beispiele:

spring-boot-starter-web
spring-boot-starter-data-jpa
spring-boot-starter-security
spring-boot-starter-actuator

Manche Third-Party Libraries bieten auch eigene Starters.

Für die Zertifizierung fokussiere dich auf offizielle Boot Starters und das Konzept.

41. Dependencies inspizieren

Nützliche Commands:

Gradle:


./gradlew dependencies

Spezifische Dependency Insight:

./gradlew dependencyInsight --dependency jackson-databind

Maven:


mvn dependency:tree

Diese Commands helfen bei Fragen wie:

Warum ist diese Dependency hier?
Welche Version wird genutzt?
Welche Dependency hat sie mitgebracht?
Gibt es Conflicts?

42. Wie Starters mit Auto-Configuration zusammenhängen

Beispiel:

Du fügst hinzu:

implementation("org.springframework.boot:spring-boot-starter-actuator")

Das legt Actuator Klassen auf den Classpath.

Auto-Configuration sieht Actuator Klassen.

Dann konfiguriert Boot Actuator Endpoints.

Wenn du hinzufügst:

management:
  endpoints:
    web:
      exposure:
        include: health,info

nutzt Boot Properties, um zu entscheiden, welche Endpoints exposed werden.

Ablauf:

starter dependency
      ↓
classes on classpath
      ↓
auto-configuration conditions match
      ↓
beans are created
      ↓
properties customize behavior

43. Echte Prüfungsfrage: Starter

Frage:

Was ist ein Spring Boot Starter?

Antwort:

Ein Spring Boot Starter ist ein Dependency Bundle, das häufig genutzte Dependencies für ein bestimmtes Feature zusammenbringt — wie Web, JPA, Security, Testing oder Actuator.

44. Echte Prüfungsfrage: Starter vs Auto-Configuration

Frage:

Was ist der Unterschied zwischen einem Starter und Auto-Configuration?

Antwort:

Ein Starter bringt Dependencies auf den Classpath. Auto-Configuration sieht diese Dependencies und konfiguriert Spring Beans basierend auf Conditions, Properties und vorhandenen Beans.

45. Echte Prüfungsfrage: Transitive Dependency

Frage:

Was ist eine transitive Dependency?

Antwort:

Eine transitive Dependency ist eine Dependency, die indirekt von einer anderen Dependency mitgebracht wird.

Beispiel:

Du fügst spring-boot-starter-web hinzu.
Er bringt spring-webmvc und embedded Tomcat.
Das sind transitive Dependencies.

46. Echte Prüfungsfrage: Dependency Management

Frage:

Welches Problem löst Spring Boot Dependency Management?

Antwort:

Es liefert ein kompatibles Set von Dependency Versionen, damit Entwickler nicht manuell Versionen für häufige Libraries wählen müssen. Das reduziert Version Conflicts und Runtime Kompatibilitätsprobleme.

47. Echte Prüfungsfrage: Manuelle Versionen

Frage:

Solltest du meistens Versionen für Spring Boot managed Dependencies angeben?

Antwort:

Nein. In einem Spring Boot Projekt mit Boot Dependency Management solltest du meistens Versionen für managed Dependencies weglassen und Spring Boot kompatible Versionen wählen lassen.

48. Echte Prüfungsfrage: BOM

Frage:

Was ist ein BOM?

Antwort:

Ein BOM ist ein Bill of Materials. Es definiert ein Set von Dependency Versionen. Spring Boot bietet ein BOM namens spring-boot-dependencies, das Dependency Versionen verwalten kann, ohne das Boot Parent POM zu nutzen.

49. Echte Prüfungsfrage: Parent POM

Frage:

Was liefert spring-boot-starter-parent in Maven?

Antwort:

Es liefert Dependency Management, Plugin Management und sinnvolle Maven Defaults für Spring Boot Applications.

50. Echte Prüfungsfrage: Database Driver

Frage:

Enthält spring-boot-starter-data-jpa den PostgreSQL Driver automatisch?

Antwort:

Nein. Der JPA Starter liefert JPA und Hibernate Support — aber du musst trotzdem den Database Driver hinzufügen, zum Beispiel org.postgresql:postgresql.

51. Echte Prüfungsfrage: Security Starter

Frage:

Was kann passieren, wenn du spring-boot-starter-security zu einer Web App hinzufügst?

Antwort:

Spring Boot kann Spring Security Auto-Configuration anwenden und die Application standardmäßig absichern. Endpoints können Authentication erfordern, bis du das Security Verhalten konfigurierst.

52. Echte Prüfungsfrage: Validation Starter

Frage:

Welchen Starter solltest du für Bean Validation Annotations wie @NotBlank und @Valid hinzufügen?

Antwort:

Nutze:


spring-boot-starter-validation

53. Interview-Antwort

Frage:

What are Spring Boot starters?

Gute Antwort:

Spring Boot Starters sind Dependency Bundles, die häufige Libraries für ein bestimmtes Feature gruppieren. Zum Beispiel bringt spring-boot-starter-web die üblichen Dependencies für eine Spring MVC Web Application — während spring-boot-starter-data-jpa JPA und Hibernate Support mitbringt. Starters reduzieren Dependency Boilerplate und helfen Entwicklern, mit einem kompatiblen Library Set zu starten.

54. Interview-Antwort

Frage:

What is the difference between starters and auto-configuration?

Gute Antwort:

Ein Starter bringt Dependencies auf den Classpath. Auto-Configuration schaut auf den Classpath, Application Properties, vorhandene Beans und Conditions — und erzeugt und konfiguriert dann Beans automatisch. Zum Beispiel bringt der Web Starter Spring MVC und Tomcat Dependencies — und Web Auto-Configuration konfiguriert DispatcherServlet, embedded Tomcat und HTTP Message Converters.

55. Interview-Antwort

Frage:

What is Spring Boot dependency management?

Gute Antwort:

Spring Boot Dependency Management liefert ein kuratiertes Set kompatibler Library Versionen. Das heißt: Du kannst meistens Versionen für Spring Boot managed Dependencies weglassen — und Boot wählt Versionen, die zusammenarbeiten. Das reduziert Dependency Conflicts, vermeidet Runtime Errors durch inkompatible Libraries und macht Upgrades einfacher.

56. Interview-Antwort

Frage:

Why should we avoid manually overriding dependency versions?

Gute Antwort:

Manuelles Überschreiben von Versionen kann die Kompatibilität mit der Spring Boot Version und anderen managed Dependencies brechen. Es kann zu Runtime Errors wie NoSuchMethodError, ClassNotFoundException oder Bean Creation Failures führen. Wenn eine andere Version nötig ist, sollte das vorsichtig geschehen — meist aus einem klaren Grund wie einem Security Fix — und vorzugsweise durch ein Spring Boot Upgrade selbst.

57. Interview-Antwort

Frage:

What is the Spring Boot BOM?

Gute Antwort:

Das Spring Boot BOM, oder Bill of Materials, ist spring-boot-dependencies. Es definiert Dependency Versionen für viele häufige Libraries, die mit Spring Boot genutzt werden. Es ist nützlich, wenn ein Maven Projekt das Spring Boot Parent POM nicht nutzen kann, aber trotzdem Spring Boots Dependency Version Management will.

58. Kleine Code-Übung

Gradle Beispiel:

plugins {
    id("org.springframework.boot") version "3.x.x"
    id("io.spring.dependency-management") version "1.x.x"
    java
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-validation")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    runtimeOnly("org.postgresql:postgresql")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

Fragen:

Welche Dependency erzeugt eine Servlet Web App?
Welche Dependency aktiviert Bean Validation Support?
Welche Dependency liefert JPA Support?
Welche Dependency ist der Database Driver?
Warum werden Versionen weggelassen?

Antworten:

spring-boot-starter-web
spring-boot-starter-validation
spring-boot-starter-data-jpa
org.postgresql:postgresql
Spring Boot Dependency Management liefert kompatible Versionen.

59. Kleine Bug-Übung 1

Problem:

implementation("org.springframework.boot:spring-boot-starter-data-jpa")

Aber kein Database Driver wurde hinzugefügt.

Frage:

Was kann passieren?

Antwort:

Spring Boot kann versuchen, JPA und eine DataSource zu konfigurieren — aber ohne Database Driver oder passende Datasource Configuration kann die App beim Start fehlschlagen.

Fix:

runtimeOnly("org.postgresql:postgresql")

und Datasource Properties konfigurieren.

60. Kleine Bug-Übung 2

Problem:

implementation("org.springframework.boot:spring-boot-starter-web")
implementation("org.springframework:spring-webmvc:some-manual-version")
implementation("com.fasterxml.jackson.core:jackson-databind:some-manual-version")

Frage:

Was ist das Problem?

Antwort:

Der Web Starter bringt bereits häufige Web Dependencies. Manuelle Versionen hinzuzufügen kann Dependency Conflicts oder Kompatibilitätsprobleme erzeugen. Meist ist es besser, Spring Boot diese Versionen verwalten zu lassen.

Übungsfragen

Frage 1

Was ist ein Spring Boot Starter?

Antwort:

Ein Spring Boot Starter ist ein Dependency Bundle, das häufige Libraries für ein bestimmtes Feature zusammenbringt — wie Web, JPA, Security, Testing oder Actuator.

Frage 2

Warum gibt es Starters?

Antwort:

Starters existieren, um Dependency Boilerplate zu reduzieren und ein praktisches, kompatibles Library Set für häufige Application Features bereitzustellen.

Frage 3

Was ist der Unterschied zwischen einem Starter und Auto-Configuration?

Antwort:

Ein Starter bringt Dependencies auf den Classpath. Auto-Configuration konfiguriert Beans basierend auf diesen Dependencies, Properties, vorhandenen Beans und Conditions.

Frage 4

Was ist eine transitive Dependency?

Antwort:

Eine transitive Dependency ist eine Dependency, die indirekt von einer anderen Dependency mitgebracht wird.

Frage 5

Was liefert spring-boot-starter-web normalerweise?

Antwort:

spring-boot-starter-web liefert normalerweise Spring MVC, embedded Tomcat, Jackson JSON Support und Web Infrastructure Dependencies.

Frage 6

Was liefert spring-boot-starter-data-jpa?

Antwort:

spring-boot-starter-data-jpa liefert Spring Data JPA, Hibernate, JPA Repository Support und transaction-bezogene Infrastructure.

Frage 7

Brauchst du trotzdem einen Database Driver mit dem JPA Starter?

Antwort:

Ja. Du musst trotzdem einen Database Driver hinzufügen — zum Beispiel PostgreSQL, MySQL oder MariaDB.

Frage 8

Welcher Starter wird häufig für Bean Validation genutzt?

Antwort:

Nutze:


spring-boot-starter-validation

Frage 9

Was kann passieren, wenn du den Security Starter hinzufügst?

Antwort:

Der Security Starter kann Security Auto-Configuration triggern. In einer Web App können Endpoints standardmäßig abgesichert werden — bis du das Security Verhalten konfigurierst.

Frage 10

Wofür wird spring-boot-starter-actuator genutzt?

Antwort:

spring-boot-starter-actuator wird für production-ready Monitoring- und Management Endpoints genutzt — wie health, info, metrics, beans und conditions.

Frage 11

Was ist Dependency Management?

Antwort:

Dependency Management bedeutet, ein bekanntes Set von Dependency Versionen zu nutzen, damit Libraries korrekt zusammenarbeiten.

Frage 12

Warum verwaltet Spring Boot Dependency Versionen?

Antwort:

Spring Boot verwaltet Dependency Versionen, um Conflicts zu reduzieren und sicherzustellen, dass häufige Libraries mit der gewählten Spring Boot Version kompatibel sind.

Frage 13

Solltest du meistens Versionen manuell für Boot-managed Dependencies angeben?

Antwort:

Nein. Du solltest meistens Versionen für Spring Boot managed Dependencies weglassen und Boot kompatible Versionen wählen lassen.

Frage 14

Was ist das Spring Boot Parent POM?

Antwort:

Das Spring Boot Parent POM ist spring-boot-starter-parent. Es liefert Dependency Management, Plugin Management und sinnvolle Maven Defaults.

Frage 15

Was ist das Spring Boot BOM?

Antwort:

Das Spring Boot BOM ist spring-boot-dependencies. Es ist ein Bill of Materials, das Dependency Versionen für häufige Libraries definiert.

Frage 16

Was ist der Unterschied zwischen Parent POM und BOM?

Antwort:

Das Parent POM liefert Dependency Management und Plugin Management als Maven Parent. Das BOM liefert Dependency Version Management, ohne als Parent genutzt zu werden.

Frage 17

Wofür ist runtimeOnly nützlich?

Antwort:

runtimeOnly ist nützlich für Dependencies, die nur zur Runtime nötig sind — wie ein Database Driver.

Frage 18

Wofür ist testImplementation nützlich?

Antwort:

testImplementation ist nützlich für Dependencies, die nur in Tests nötig sind — wie spring-boot-starter-test.

Frage 19

Warum ist das Mischen verschiedener Spring Boot Starter Versionen gefährlich?

Antwort:

Verschiedene Spring Boot Starter Versionen zu mischen kann inkompatible Dependency Versionen erzeugen und Runtime Errors oder Bean Creation Probleme verursachen.

Frage 20

Wie kannst du Dependency Trees inspizieren?

Antwort:

Nutze:


./gradlew dependencies

oder:

./gradlew dependencyInsight --dependency dependency-name

Für Maven:


mvn dependency:tree

Merksätze zum Mitnehmen

Ein Spring Boot Starter ist ein Dependency Bundle.
Starters reduzieren Dependency Boilerplate.
Starters bringen Libraries; Auto-Configuration konfiguriert sie.
Eine transitive Dependency wird indirekt von einer anderen Dependency mitgebracht.
spring-boot-starter-web ist für Spring MVC Web Apps.
spring-boot-starter-webflux ist für reactive Web Apps.
spring-boot-starter-data-jpa liefert JPA und Hibernate Support.
Der JPA Starter ersetzt nicht den Database Driver.
Nutze spring-boot-starter-validation für Bean Validation.
Der Security Starter kann Endpoints standardmäßig absichern.
Der Actuator Starter fügt Production Monitoring Endpoints hinzu.
Spring Boot Dependency Management liefert kompatible Versionen.
Lass Versionen für Boot-managed Dependencies meist weg.
Das Parent POM liefert Maven Dependency und Plugin Management.
Das BOM liefert Dependency Version Management ohne das Boot Parent.
Überschreibe Versionen manuell nur, wenn nötig.
Nutze Dependency Tree Tools, um Dependency Probleme zu inspizieren.

Ziel​

1. Kurz-Wiederholung von Woche 3, Tag 1​

2. Was ist ein Spring Boot Starter?​

3. Warum gibt es Starters?​

4. Starter bedeutet nicht Auto-Configuration​

5. Starter vs Auto-Configuration​

6. Beispiel: Web Starter​

7. Wichtig: Validation ist meist separat​

8. Häufige Spring Boot Starters​

9. spring-boot-starter​

10. spring-boot-starter-web​

11. spring-boot-starter-webflux​

12. spring-boot-starter-data-jpa​

13. Beispiel: JPA Dependencies​

14. spring-boot-starter-security​

15. spring-boot-starter-actuator​

16. spring-boot-starter-test​

17. Was ist eine transitive Dependency?​

18. Beispiel für transitive Dependencies​

19. Das Problem mit manuellen Dependency-Versionen​

20. Was ist Dependency Management?​

21. Warum Version Alignment wichtig ist​

22. Maven: Spring Boot Parent POM​

23. Maven ohne Parent: BOM​

24. Parent POM vs BOM​

25. Gradle: Spring Boot Plugin​

26. Gradle Dependencies ohne Versionen​

27. Sollst du Versionen manuell angeben?​

28. Was, wenn du eine andere Version brauchst?​

29. Häufiger Fehler: Spring Boot Versionen mischen​

30. Häufiger Fehler: Web und WebFlux zusammen hinzufügen​

31. Häufiger Fehler: JPA Starter ohne Database​

32. Häufiger Fehler: Runtime Driver vergessen​

33. Häufiger Fehler: Validation Starter vergessen​

34. Häufiger Fehler: Zu viele Dependencies​

35. Dependency Scopes / Configurations​

36. implementation​

37. runtimeOnly​

38. testImplementation​

39. developmentOnly​

40. Starter Naming Pattern​

41. Dependencies inspizieren​

42. Wie Starters mit Auto-Configuration zusammenhängen​

43. Echte Prüfungsfrage: Starter​

44. Echte Prüfungsfrage: Starter vs Auto-Configuration​

45. Echte Prüfungsfrage: Transitive Dependency​

46. Echte Prüfungsfrage: Dependency Management​

47. Echte Prüfungsfrage: Manuelle Versionen​

48. Echte Prüfungsfrage: BOM​

49. Echte Prüfungsfrage: Parent POM​

50. Echte Prüfungsfrage: Database Driver​

51. Echte Prüfungsfrage: Security Starter​

52. Echte Prüfungsfrage: Validation Starter​

53. Interview-Antwort​

54. Interview-Antwort​

55. Interview-Antwort​

56. Interview-Antwort​

57. Interview-Antwort​

58. Kleine Code-Übung​

59. Kleine Bug-Übung 1​

60. Kleine Bug-Übung 2​

Übungsfragen​

Frage 1​

Frage 2​

Frage 3​

Frage 4​

Frage 5​

Frage 6​

Frage 7​

Frage 8​

Frage 9​

Frage 10​

Frage 11​

Frage 12​

Frage 13​

Frage 14​

Frage 15​

Frage 16​

Frage 17​

Frage 18​

Ziel

1. Kurz-Wiederholung von Woche 3, Tag 1

2. Was ist ein Spring Boot Starter?

3. Warum gibt es Starters?

4. Starter bedeutet nicht Auto-Configuration

5. Starter vs Auto-Configuration

6. Beispiel: Web Starter

7. Wichtig: Validation ist meist separat

8. Häufige Spring Boot Starters

9. `spring-boot-starter`

10. `spring-boot-starter-web`

11. `spring-boot-starter-webflux`

12. `spring-boot-starter-data-jpa`

13. Beispiel: JPA Dependencies

14. `spring-boot-starter-security`

15. `spring-boot-starter-actuator`

16. `spring-boot-starter-test`

17. Was ist eine transitive Dependency?

18. Beispiel für transitive Dependencies

19. Das Problem mit manuellen Dependency-Versionen

20. Was ist Dependency Management?

21. Warum Version Alignment wichtig ist

22. Maven: Spring Boot Parent POM

23. Maven ohne Parent: BOM

24. Parent POM vs BOM

25. Gradle: Spring Boot Plugin

26. Gradle Dependencies ohne Versionen

27. Sollst du Versionen manuell angeben?

28. Was, wenn du eine andere Version brauchst?

29. Häufiger Fehler: Spring Boot Versionen mischen

30. Häufiger Fehler: Web und WebFlux zusammen hinzufügen

31. Häufiger Fehler: JPA Starter ohne Database

32. Häufiger Fehler: Runtime Driver vergessen

33. Häufiger Fehler: Validation Starter vergessen

34. Häufiger Fehler: Zu viele Dependencies

35. Dependency Scopes / Configurations

36. `implementation`

37. `runtimeOnly`

38. `testImplementation`

39. `developmentOnly`

40. Starter Naming Pattern

41. Dependencies inspizieren

42. Wie Starters mit Auto-Configuration zusammenhängen

43. Echte Prüfungsfrage: Starter

44. Echte Prüfungsfrage: Starter vs Auto-Configuration

45. Echte Prüfungsfrage: Transitive Dependency

46. Echte Prüfungsfrage: Dependency Management

47. Echte Prüfungsfrage: Manuelle Versionen

48. Echte Prüfungsfrage: BOM

49. Echte Prüfungsfrage: Parent POM

50. Echte Prüfungsfrage: Database Driver

51. Echte Prüfungsfrage: Security Starter

52. Echte Prüfungsfrage: Validation Starter

53. Interview-Antwort

54. Interview-Antwort

55. Interview-Antwort

56. Interview-Antwort

57. Interview-Antwort

58. Kleine Code-Übung

59. Kleine Bug-Übung 1

60. Kleine Bug-Übung 2

Übungsfragen

Frage 1

Frage 2

Frage 3

Frage 4

Frage 5

Frage 6

Frage 7

Frage 8

Frage 9

Frage 10

Frage 11

Frage 12

Frage 13

Frage 14

Frage 15

Frage 16

Frage 17

Frage 18