Spring Certified Professional — Theory-First Curriculum

Profil: React- / Full-Stack-Entwickler mit bestehender Projekterfahrung Ziel: Spring-Theorie festigen und dich auf die Spring Certified Professional Prüfung vorbereiten Stil: Prüfungsorientiert, theorie-lastig, Schritt für Schritt, mit kleinen fokussierten Übungen Empfohlene Dauer: 10–12 Wochen Tägliche Zeit: 1,5–2,5 Stunden Hauptregel: Baue kein weiteres riesiges Projekt. Nutze nur kleine Code-Experimente, um die Theorie zu beweisen.

0. Zertifizierungsziel

Zielzertifizierung:

Spring Certified Professional 2024
Prüfung: Spring Professional Develop 2V0-72.22

Kernprüfungsbereiche, die du beherrschen musst:

Spring Core
Dependency Injection
Bean lifecycle
Configuration
Spring Boot
Auto-configuration
Spring MVC und REST
Validation und Error Handling
Data access
Transactions
AOP und Proxies
Spring Security
Testing
Actuator und Production Readiness

1. So nutzt du dieses Curriculum

Dieses Curriculum ist kein normales „Spring Boot lernen“-Tutorial.

Du hast schon Projekte gebaut. Das Ziel ist deshalb:

zu verstehen, warum Spring funktioniert
zu wissen, was intern passiert
dich auf prüfungsähnliche Fragen vorzubereiten
Spring-Konzepte in Interviews klar zu erklären
schwache Theorie-Lücken zu schließen

Für jedes Thema folge diesem Format:

## Themenname

### 1. Was ist das?

Erkläre die Idee in einfacher Sprache.

### 2. Warum gibt es das?

Erkläre das Problem, das es löst.

### 3. Wie setzt Spring das um?

Nenne Annotationen, Klassen, Container-Verhalten, Proxies oder Auto-configuration.

### 4. Typische Prüfungsfallen

Liste knifflige Punkte auf.

### 5. Kleiner Code-Nachweis

Schreibe den kleinstmöglichen Code, um das Konzept zu beweisen.

### 6. Interview-Antwort

Erkläre das Konzept in 5–8 Sätzen.

2. Wochenstruktur

Jede Woche hat fünf Lerntage plus Review.

Tag	Aktivität
Montag	Theorie lesen und Notizen schreiben
Dienstag	Annotationen und Konzepte vergleichen
Mittwoch	Kleine Code-Experimente machen
Donnerstag	Übungsfragen beantworten
Freitag	Konzepte laut erklären
Samstag	Fehler reviewen und Cheat Sheet aktualisieren
Sonntag	Pause oder leichte Flashcards

3. Tägliche Study-Vorlage

Nutze das jeden Tag.

# Tägliches Spring-Study-Log

Datum:

## Thema

## Was ich gelernt habe

## Wichtige Annotationen

## Was Spring intern macht

## Typische Fallen

## 5 Prüfungsfragen, die ich jetzt beantworten kann

1.
2.
3.
4.
5.

## Ein kleiner Code-Nachweis

## Mein Schwachpunkt heute

## Meine finale Erklärung in einfachen Worten

Empfohlener Tagesablauf:

Zeit	Aufgabe
20 min	Offizielle Theorie lesen
25 min	Eigene Erklärung schreiben
25 min	Ähnliche Konzepte vergleichen
25 min	Kleines Code-Experiment
20 min	Übungsfragen
15 min	Flashcards

10-Wochen-Zertifizierungsplan

Woche 1 — Spring-Core Mental Model

Ziel

Verstehe Spring als Container, der Objekte erzeugt, verbindet, konfiguriert und verwaltet.

Kernfragen

Am Ende dieser Woche musst du antworten können:

Was ist Spring Framework?
Was ist der IoC-Container?
Was ist Dependency Injection?
Was ist eine Bean?
Was ist ApplicationContext?
Was ist der Unterschied zwischen Spring und Spring Boot?
Warum erzeugt Spring Objekte, statt dass wir überall new verwenden?

Tag 1 — Welches Problem löst Spring?

Lerninhalt

Vor Spring haben Anwendungen oft viele Klassen manuell erzeugt.

Beispiel:

UserRepository repository = new UserRepository();
EmailService emailService = new EmailService();
UserService userService = new UserService(repository, emailService);

Das führt zu Problemen:

schwer testbar
schwer, Abhängigkeiten auszutauschen
schwer zu konfigurieren
schwer, den Objekt-Lebenszyklus zu steuern
schwer, Infrastruktur wiederzuverwenden

Spring löst das mit dem IoC-Container.

Kernidee

IoC bedeutet:

Statt dass dein Code die Objekterzeugung steuert, steuert der Spring-Container die Objekterzeugung.

React-Vergleich

In React denkst du oft in Komponenten:

<App>
  <UserPage />
</App>

React steuert Rendering und Lifecycle.

In Spring:

@Service
public class UserService {}

Spring steuert Objekterzeugung und Lifecycle.

Kleiner Code-Nachweis

Erzeuge einen Service manuell und einen mit Spring.

Manuell:

TaskRepository repository = new InMemoryTaskRepository();
TaskService service = new TaskService(repository);

Mit Spring:

@Service
public class TaskService {
    private final TaskRepository repository;

    public TaskService(TaskRepository repository) {
        this.repository = repository;
    }
}

Typische Prüfungsfallen

IoC und DI hängen zusammen, sind aber nicht identisch.
IoC ist das Prinzip.
DI ist eine Implementierung von IoC.
Spring kennt nicht magisch alle Klassen. Es findet Beans über Configuration und Component Scanning.

Tag 2 — ApplicationContext und BeanFactory

Lerninhalt

ApplicationContext ist der zentrale Spring-Container in modernen Anwendungen.

Er kann:

Beans erzeugen
Abhängigkeiten verdrahten
den Bean-Lifecycle verwalten
Events publishen
Messages auflösen
Environment-Properties lesen
Profile unterstützen

BeanFactory ist ein einfacherer Container. ApplicationContext erweitert ihn und fügt Enterprise-Features hinzu.

Das musst du wissen

Konzept	Bedeutung
BeanFactory	Basis-Bean-Container
ApplicationContext	Voll ausgestatteter Spring-Container
Bean	Vom Spring verwaltetes Objekt
BeanDefinition	Metadaten, die beschreiben, wie eine Bean erzeugt wird

Typische Prüfungsfallen

Eine Spring Bean ist nicht einfach irgendein Java-Objekt.
Eine Bean ist ein vom Spring-Container verwaltetes Objekt.
ApplicationContext erzeugt Singleton-Beans standardmäßig eager.
Lazy Initialization kann dieses Verhalten ändern.

Kleine Übung

Schreibe Notizen und beantworte:


Was passiert, wenn eine Spring-Boot-Anwendung startet?

Erwartete Antwort:

SpringApplication startet.
ApplicationContext wird erzeugt.
Configuration-Klassen werden verarbeitet.
Component Scanning läuft.
Bean Definitions werden registriert.
Singleton-Beans werden erzeugt.
Abhängigkeiten werden injiziert.
Lifecycle-Callbacks laufen.
Embedded Web Server startet, wenn es eine Web-App ist.

Tag 3 — Beans und Bean Definitions

Lerninhalt

Eine Bean hat:

Name
Typ
Scope
Abhängigkeiten
Lifecycle-Callbacks
Initialisierungsverhalten

Bean-Registrierung kann erfolgen über:

@Component
@Service
@Repository
@Controller
@Configuration
@Bean

Vergleich

Annotation	Zweck
`@Component`	Generische Spring-verwaltete Komponente
`@Service`	Spezialisierung für die Service-Schicht
`@Repository`	Spezialisierung für die Persistence-Schicht
`@Controller`	MVC-Controller
`@RestController`	REST-Controller = `@Controller` + `@ResponseBody`
`@Configuration`	Definiert eine Configuration-Klasse
`@Bean`	Erzeugt eine Bean manuell über eine Methode

Prüfungsfalle

@Service und @Repository sind Spezialisierungen von @Component.

Aber @Repository unterstützt auch Persistence Exception Translation.

Kleine Übung

Beantworte:


Wann soll ich @Component und wann @Bean verwenden?

Erwartete Antwort:

Nutze @Component / @Service, wenn die Klasse dir gehört und annotiert werden kann.
Nutze @Bean, wenn du Third-Party-Klassen, Library-Objekte erzeugst oder die Konstruktion Custom Logic braucht.

Tag 4 — Dependency Injection

Lerninhalt

Dependency Injection bedeutet: Ein Objekt bekommt seine Abhängigkeiten von außen, statt sie selbst zu erzeugen.

Typen:

Constructor Injection
Setter Injection
Field Injection

Best Practice:

@Service
public class TaskService {
    private final TaskRepository repository;

    public TaskService(TaskRepository repository) {
        this.repository = repository;
    }
}

Vermeide:

@Autowired
private TaskRepository repository;

Warum Constructor Injection am besten ist

macht Abhängigkeiten explizit
unterstützt Immutability
einfacher zu testen
vermeidet null-Abhängigkeiten
funktioniert gut bei required Dependencies

Typische Prüfungsfallen

@Autowired auf einem einzigen Constructor ist in modernem Spring optional.
Field Injection funktioniert, ist aber nicht empfohlen.
Wenn mehrere Beans zu einer Abhängigkeit passen, schlägt Spring fehl — außer du nutzt @Primary, @Qualifier oder einen spezifischeren Typ.

Kleiner Code-Nachweis

Erzeuge zwei Implementierungen:

public interface NotificationSender {
    void send(String message);
}

@Component
public class EmailNotificationSender implements NotificationSender {}

@Component
public class SmsNotificationSender implements NotificationSender {}

Dann löse die Mehrdeutigkeit mit:

@Qualifier("emailNotificationSender")

Tag 5 — Component Scanning

Lerninhalt

Spring findet annotierte Klassen über Component Scanning.

@SpringBootApplication enthält @ComponentScan.

Standardmäßig scannt es das Package der Main-Application-Klasse und Subpackages.

Beispiel

@SpringBootApplication
public class MyApplication {}

Wenn diese Klasse in liegt:


com.example.app

scannt Spring:


com.example.app.*

Aber nicht:


com.other.*

Typische Prüfungsfallen

Package-Struktur ist wichtig.
Eine Klasse mit @Service wird keine Bean, wenn sie außerhalb des gescannten Packages liegt.
Du kannst Scanning mit @ComponentScan anpassen.

Kleine Übung

Schreibe:


Warum sollte die Main-Spring-Boot-Klasse im Root-Package liegen?

Woche-1-Review-Checkliste

Du bist bereit weiterzumachen, wenn du erklären kannst:

IoC
DI
Bean
ApplicationContext
Component Scanning
@Component vs. @Bean
@Service vs. @Repository
Constructor Injection
@Primary
@Qualifier

Woche 2 — Configuration, Profiles, Properties, Bean Lifecycle

Ziel

Verstehe, wie Spring Anwendungen konfiguriert und Bean-Erzeugung vom Start bis zum Shutdown verwaltet.

Tag 1 — Java Configuration

Lerninhalt

Modernes Spring bevorzugt Java Configuration gegenüber XML.

Beispiel:

@Configuration
public class AppConfig {

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

Wichtig

@Configuration-Klassen werden von Spring geproxied.

Das heißt: Wenn eine @Bean-Methode eine andere @Bean-Methode aufruft, kann Spring die verwaltete Singleton-Bean zurückgeben, statt manuell ein neues Objekt zu erzeugen.

Typische Prüfungsfallen

@Configuration ist stärker als ein einfaches @Component.
@Bean-Methoden in @Configuration-Klassen werden von CGLIB geproxied.
@Bean-Methodennamen werden standardmäßig zu Bean-Namen.

Tag 2 — Externe Configuration

Lerninhalt

Spring Boot liest Configuration aus vielen Quellen:

application.properties
application.yml
Environment Variables
Command-Line-Arguments
Profile-spezifische Dateien
Config Server, falls genutzt

Beispiel:

app:
  name: task-api
  max-tasks-per-user: 50

Mit @Value:

@Value("${app.name}")
private String appName;

Mit @ConfigurationProperties:

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private int maxTasksPerUser;
}

Bevorzugt

Nutze @ConfigurationProperties für gruppierte Config.

Nutze @Value für einfache Einzelwerte.

Typische Prüfungsfallen

@ConfigurationProperties ist type-safe.
Es muss über Component Scanning, @EnableConfigurationProperties oder Configuration Properties Scanning aktiviert werden.
Environment Variables können Property Files überschreiben.

Tag 3 — Profiles

Lerninhalt

Profiles erlauben unterschiedliche Beans oder Config für verschiedene Umgebungen.

Beispiel:

spring:
  profiles:
    active: dev

Profile-spezifische Dateien:

application-dev.yml
application-test.yml
application-prod.yml

Profile-spezifische Bean:

@Profile("dev")
@Bean
public DataSource devDataSource() {}

Typische Profile-Anwendungsfälle

Profile	Zweck
dev	lokale Entwicklung
test	automatisierte Tests
prod	Produktion
docker	Container-Umgebung

Typische Prüfungsfallen

Profiles können Beans aktivieren.
Profiles können Property Files aktivieren.
Mehrere Profiles können gleichzeitig aktiv sein.
@Profile("!prod") bedeutet aktiv, wenn prod nicht aktiv ist.

Tag 4 — Bean Scopes

Lerninhalt

Häufige Scopes:

Scope	Bedeutung
singleton	eine Bean pro Spring-Container
prototype	neue Instanz bei jeder Anfrage
request	eine Bean pro HTTP-Request
session	eine Bean pro HTTP-Session
application	eine Bean pro ServletContext
websocket	eine Bean pro WebSocket-Session

Standard-Scope:


singleton

Wichtig

Singleton in Spring bedeutet:

eine Instanz pro Spring-Container

Es bedeutet nicht das Java-Singleton-Pattern.

Prüfungsfalle

Eine Prototype-Bean in eine Singleton-Bean zu injizieren erzeugt nicht automatisch bei jeder Nutzung eine neue Prototype-Instanz.

Lösungen:

ObjectProvider<T>
Provider<T>
Lookup Method Injection
Scoped Proxy

Tag 5 — Bean Lifecycle

Lerninhalt

Bean-Lifecycle vereinfacht:

Bean instanziieren
Abhängigkeiten befüllen
Aware-Callbacks
BeanPostProcessor vor Initialisierung
Initialisierungs-Callbacks
BeanPostProcessor nach Initialisierung
Bean ist bereit
Destruction-Callbacks beim Shutdown

Häufige Callbacks:

@PostConstruct
public void init() {}

@PreDestroy
public void cleanup() {}

Weitere Optionen:

InitializingBean
DisposableBean
@Bean(initMethod = "init", destroyMethod = "cleanup")

Typische Prüfungsfallen

BeanPostProcessor kann Beans vor und nach der Initialisierung modifizieren.
AOP-Proxies werden oft über Post-Processors erzeugt.
@PostConstruct läuft nach Dependency Injection.
@PreDestroy läuft für Prototype-Beans normalerweise nicht automatisch.

Woche-2-Review-Checkliste

Du musst wissen:

@Configuration
@Bean
@Value
@ConfigurationProperties
Profiles
Property Overriding
Singleton Scope
Prototype Scope
Request/Session Scope
Bean Lifecycle
BeanPostProcessor
@PostConstruct
@PreDestroy

Woche 3 — Spring Boot und Auto-configuration

Ziel

Verstehe, was Spring Boot zusätzlich zum Spring Framework liefert.

Tag 1 — Spring-Boot Mental Model

Lerninhalt

Spring Boot hilft dir, production-ready Spring-Anwendungen schnell zu erstellen.

Es bietet:

Starter Dependencies
Auto-configuration
Embedded Web Server
Externalized Configuration
Actuator
opinionated Defaults

Wichtige Annotation

@SpringBootApplication

Sie kombiniert:

@Configuration
@EnableAutoConfiguration
@ComponentScan

Prüfungsfalle

Viele kennen @SpringBootApplication, aber nicht, was drinsteckt.

Tag 2 — Starters

Lerninhalt

Starters sind Dependency-Bundles.

Beispiele:

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

Warum sie existieren

Ohne Starters müsstest du manuell kompatible Versionen für viele Libraries wählen.

Mit Starters verwaltet Spring Boot kompatible Dependencies.

Typische Prüfungsfallen

Ein Starter ist kein magischer Code.
Es ist vor allem Dependency Management.
Starters arbeiten mit Auto-configuration zusammen.

Tag 3 — Auto-configuration

Lerninhalt

Auto-configuration bedeutet: Spring Boot konfiguriert Beans automatisch basierend auf:

Klassen im Classpath
vorhandenen Beans
Property-Werten
Environment
Web-Application-Typ

Beispiel:

Wenn spring-boot-starter-web im Classpath liegt, konfiguriert Boot:

DispatcherServlet
Embedded Tomcat
JSON Converter
Error Handling
MVC-Infrastruktur

Häufige Conditional Annotations

@ConditionalOnClass
@ConditionalOnMissingBean
@ConditionalOnBean
@ConditionalOnProperty
@ConditionalOnWebApplication

Typische Prüfungsfallen

Auto-configuration tritt zurück, wenn du deine eigene Bean definierst.
@ConditionalOnMissingBean ist wichtig.
Auto-configuration heißt nicht, dass du das Verhalten nicht anpassen kannst.

Tag 4 — SpringApplication und Runners

Lerninhalt

Application-Startup:

SpringApplication.run(App.class, args);

Code nach dem Start ausführen:

@Bean
CommandLineRunner runner() {
    return args -> {
        System.out.println("Application started");
    };
}

Außerdem:

ApplicationRunner

Unterschied

Interface	Argument-Typ
CommandLineRunner	rohes String-Array
ApplicationRunner	geparste ApplicationArguments

Tag 5 — Boot Configuration Debugging

Lerninhalt

Du musst wissen, wie du Auto-configuration inspizierst.

Nützliche Tools:


debug=true

Actuator-Endpoint:


/actuator/conditions

Startup-Logs können zeigen, welche Auto-configurations gematcht haben oder nicht.

Kleine Übung

Aktiviere Debug-Mode und beantworte:

Welche Auto-configurations sind in meiner App aktiv?
Welche haben nicht gematcht?
Warum?

Woche-3-Review-Checkliste

Du musst wissen:

Spring vs. Spring Boot
@SpringBootApplication
Starters
Auto-configuration
Conditional Annotations
Embedded Server
Auto-configured Beans überschreiben
CommandLineRunner
ApplicationRunner

Woche 4 — Spring MVC und REST

Ziel

Verstehe, wie Spring HTTP-Requests empfängt und HTTP-Responses zurückgibt.

Tag 1 — DispatcherServlet

Lerninhalt

DispatcherServlet ist der Front Controller in Spring MVC.

Request-Flow:

Client sendet HTTP-Request.
DispatcherServlet empfängt ihn.
HandlerMapping findet die Controller-Methode.
Argument Resolvers bereiten Methodenargumente vor.
Controller-Methode läuft.
Return Value Handlers verarbeiten die Response.
Message Converters serialisieren die Response zu JSON.
HTTP-Response wird gesendet.

Typische Prüfungsfallen

DispatcherServlet ist zentral für Spring MVC.
Controller hören nicht direkt auf Sockets.
JSON-Konvertierung übernehmen HTTP Message Converters.

Tag 2 — Controller und Request Mapping

Lerninhalt

Häufige Annotationen:

@RestController
@RequestMapping("/api/tasks")
@GetMapping
@PostMapping
@PutMapping
@PatchMapping
@DeleteMapping
@PathVariable
@RequestParam
@RequestBody

Beispiel:

@GetMapping("/{id}")
public TaskResponse getTask(@PathVariable Long id) {
    return taskService.findById(id);
}

Typische Prüfungsfallen

@RestController = @Controller + @ResponseBody.
@RequestBody liest den JSON-Body.
@PathVariable liest den URL-Pfad.
@RequestParam liest Query-Parameter.

Tag 3 — DTOs und Message Conversion

Lerninhalt

DTO bedeutet Data Transfer Object.

Nutze DTOs für API-Input/Output.

Gib JPA-Entities nicht direkt frei.

Warum?

vermeidet Lazy-Loading-Probleme
schützt das interne Datenmodell
kontrolliert die API-Form
verhindert versehentliche Updates
verbessert Validation

Beispiel

public record CreateTaskRequest(
    String title,
    Long clientId
) {}

public record TaskResponse(
    Long id,
    String title,
    String status
) {}

Typische Prüfungsfallen

Jackson übernimmt meist JSON-Serialisierung/Deserialisierung.
Spring nutzt HttpMessageConverter.
Records eignen sich gut als DTOs.

Tag 4 — Validation

Lerninhalt

Validation nutzt Jakarta Bean Validation.

Häufige Annotationen:

@NotNull
@NotBlank
@Size
@Email
@Min
@Max
@Pattern
@Valid

Beispiel:

public record CreateTaskRequest(
    @NotBlank String title,
    @NotNull Long clientId
) {}

Controller:

@PostMapping
public ResponseEntity<TaskResponse> create(@Valid @RequestBody CreateTaskRequest request) {}

Typische Prüfungsfallen

@Valid triggert Validation.
Validation-Fehler können global behandelt werden.
Method Parameter Validation kann je nach Use Case zusätzliches Setup brauchen.

Tag 5 — Exception Handling

Lerninhalt

Nutze @ControllerAdvice für globales Exception Handling.

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(TaskNotFoundException.class)
    public ResponseEntity<ApiError> handle(TaskNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(new ApiError("TASK_NOT_FOUND", ex.getMessage()));
    }
}

Typische Prüfungsfallen

@ExceptionHandler kann lokal oder global sein.
@ControllerAdvice gilt über Controller hinweg.
ResponseEntity gibt Kontrolle über Status, Headers und Body.

Woche-4-Review-Checkliste

Du musst wissen:

DispatcherServlet
HandlerMapping
@RestController
Request-Mapping-Annotationen
@RequestBody
@PathVariable
@RequestParam
DTOs
Jackson
Validation
Exception Handling
ResponseEntity

Woche 5 — Data Access

Ziel

Verstehe Spring JDBC, JPA, Spring Data, Repositories und Exception Translation.

Tag 1 — JDBC und JdbcTemplate

Lerninhalt

JDBC ist die Low-Level-Java-API für Datenbankzugriff.

Spring bietet JdbcTemplate, um Boilerplate zu reduzieren.

Ohne Spring JDBC:

Connection öffnen
Statement erstellen
Query ausführen
Result mappen
Exceptions behandeln
Ressourcen schließen

Mit JdbcTemplate:

List<Client> clients = jdbcTemplate.query(
    "select id, name from clients",
    (rs, rowNum) -> new Client(rs.getLong("id"), rs.getString("name"))
);

Typische Prüfungsfallen

JdbcTemplate übernimmt Resource Management.
Es übersetzt SQL-Exceptions in Spring DataAccessException.
Spring Data Access Exceptions sind unchecked.

Tag 2 — JPA und Hibernate

Lerninhalt

JPA ist eine Spezifikation. Hibernate ist eine Implementierung.

JPA mappt Java-Objekte auf Datenbanktabellen.

Beispiel:

@Entity
public class Task {

    @Id
    @GeneratedValue
    private Long id;

    private String title;
}

Das musst du wissen

Konzept	Bedeutung
Entity	Persistentes Domain-Objekt
EntityManager	JPA-API für Persistence-Operationen
Persistence context	First-Level-Cache / verwalteter Entity-Kontext
Hibernate	JPA Provider
Dirty checking	Hibernate erkennt geänderte verwaltete Entities

Typische Prüfungsfallen

JPA ist nicht Hibernate.
Hibernate implementiert JPA.
Managed Entities werden getrackt.
Detached Entities werden nicht automatisch getrackt.

Tag 3 — Spring Data JPA

Lerninhalt

Spring Data JPA reduziert Repository-Boilerplate.

public interface TaskRepository extends JpaRepository<Task, Long> {
    List<Task> findByStatus(TaskStatus status);
}

Spring erzeugt die Implementierung zur Laufzeit.

Query-Optionen

Derived Query Methods
@Query
Specifications
Query by Example
Custom Repository Implementation

Typische Prüfungsfallen

JpaRepository erweitert PagingAndSortingRepository und CrudRepository-Konzepte.
Repository-Implementierungen werden von Spring Data generiert.
Methodennamen werden in Queries geparst.

Tag 4 — Relationships und Fetching

Lerninhalt

Häufige Relationships:

@OneToMany
@ManyToOne
@OneToOne
@ManyToMany

Beispiel:

@ManyToOne(fetch = FetchType.LAZY)
private Client client;

Lazy vs. eager

Fetch type	Bedeutung
LAZY	laden, wenn benötigt
EAGER	sofort laden

Typische Prüfungsfallen

Lazy Loading braucht einen offenen Persistence Context.
Lazy Loading kann N+1-Query-Probleme verursachen.
EAGER ist nicht immer besser.
DTO-Queries können unnötiges Entity-Loading vermeiden.

Tag 5 — Exception Translation

Lerninhalt

@Repository aktiviert Persistence Exception Translation.

Datenbankspezifische Exceptions werden zu Spring's konsistenter Exception-Hierarchie.

Beispiel:


SQLException -> DataAccessException

Warum nützlich?

Deine Service-Schicht muss nicht von datenbankspezifischen Exception-Typen abhängen.

Typische Prüfungsfallen

DataAccessException ist unchecked.
@Repository ist nicht nur semantisch; es kann Exception Translation aktivieren.

Woche-5-Review-Checkliste

Du musst wissen:

JDBC
JdbcTemplate
DataAccessException
JPA
Hibernate
EntityManager
Persistence context
Spring Data Repositories
Derived Queries
@Query
Relationships
Lazy/Eager Loading
Exception Translation

Woche 6 — Transactions

Ziel

Beherrsche @Transactional, Transaction Boundaries, Rollback, Propagation, Isolation und Proxy-Limitierungen.

Das ist einer der wichtigsten Prüfungsbereiche.

Tag 1 — Transaction Basics

Lerninhalt

Eine Transaction ist eine Arbeitseinheit.

ACID:

Buchstabe	Bedeutung
A	Atomicity
C	Consistency
I	Isolation
D	Durability

Beispiel:

@Transactional
public TaskResponse createTask(CreateTaskRequest request) {
    Client client = clientRepository.findById(request.clientId())
        .orElseThrow();

    Task task = new Task(request.title(), client);
    taskRepository.save(task);

    auditRepository.save(new AuditLog("TASK_CREATED"));

    return mapper.toResponse(task);
}

Wenn etwas fehlschlägt, kann die ganze Operation zurückgerollt werden.

Tag 2 — Wo `@Transactional` hin gehört

Best Practice

Setze @Transactional auf Service-Layer-Methoden.

Warum?

Service-Methoden repräsentieren Business Use Cases
ein Use Case kann mehrere Repositories betreffen
die Transaction Boundary sollte die ganze Business-Operation abdecken

Vermeide Transactions hauptsächlich auf Controllern.

Typische Prüfungsfallen

@Transactional kann auf Klasse oder Methode stehen.
Method-Level-Annotation überschreibt Class-Level-Annotation.
Public Methods werden normalerweise geproxied.
Interne Self-Calls können den Proxy umgehen.

Tag 3 — Rollback Rules

Lerninhalt

Standardmäßig:

Exception-Typ	Rollback?
RuntimeException	ja
Error	ja
Checked Exception	nein

Beispiel:

@Transactional(rollbackFor = IOException.class)
public void importFile() throws IOException {}

Typische Prüfungsfallen

Checked Exceptions triggern standardmäßig kein Rollback.
Du kannst Rollback mit rollbackFor anpassen.
Exceptions fangen und verschlucken kann Rollback verhindern.

Tag 4 — Propagation

Lerninhalt

Transaction Propagation definiert, wie sich eine transaktionale Methode verhält, wenn sie innerhalb einer anderen Transaction aufgerufen wird.

Wichtige Propagation-Typen:

Propagation	Bedeutung
REQUIRED	bestehende Transaction joinen oder neue erzeugen
REQUIRES_NEW	bestehende suspendieren und neue Transaction erzeugen
SUPPORTS	joinen wenn vorhanden, sonst ohne Transaction laufen
MANDATORY	muss bestehende Transaction haben
NEVER	fehlschlagen, wenn Transaction existiert
NOT_SUPPORTED	Transaction suspendieren und ohne laufen
NESTED	verschachtelte Transaction mit Savepoint

Wichtigste für die Prüfung

REQUIRED
REQUIRES_NEW
MANDATORY
NESTED

Prüfungsfalle

REQUIRES_NEW committed oder rollt unabhängig von der äußeren Transaction zurück.

Tag 5 — Isolation und Read-Only

Lerninhalt

Isolation steuert, wie Transactions Änderungen anderer Transactions sehen.

Häufige Probleme:

Problem	Bedeutung
Dirty read	uncommitted Daten lesen
Non-repeatable read	gleiche Zeile zweimal lesen liefert anderes Ergebnis
Phantom read	gleiche Query liefert unterschiedliche Zeilen

Isolation Levels:

@Transactional(isolation = Isolation.READ_COMMITTED)

Read-only:

@Transactional(readOnly = true)

Typische Prüfungsfallen

Isolation-Support hängt von der Datenbank ab.
readOnly = true ist ein Optimierungshinweis.
Es verhindert Writes auf DB-Ebene nicht immer strikt.

Woche-6-Review-Checkliste

Du musst wissen:

ACID
Transaction Boundary
@Transactional
Rollback Rules
Checked vs. Unchecked Exceptions
Propagation
Isolation
Read-only Transactions
Self-Invocation Problem
Transaction Proxies

Woche 7 — AOP und Proxies

Ziel

Verstehe Spring AOP und warum Proxies zentral für Transactions, Security und Method Interception sind.

Tag 1 — AOP Mental Model

Lerninhalt

AOP bedeutet Aspect-Oriented Programming.

Es löst Cross-Cutting Concerns:

Logging
Security
Transactions
Metrics
Auditing
Caching

Statt denselben Code in jede Methode zu schreiben, kann Spring Verhalten um Methodenaufrufe legen.

Vokabular

Begriff	Bedeutung
Aspect	Modul mit Cross-Cutting Logic
Advice	Aktion eines Aspects
Pointcut	Expression, die festlegt, wo Advice gilt
Join point	Punkt in der Ausführung, meist Method Execution
Weaving	Aspects anwenden
Proxy	Wrapper-Objekt, das Aufrufe abfängt

Tag 2 — Advice Types

Lerninhalt

Advice-Typen:

@Before
@After
@AfterReturning
@AfterThrowing
@Around

Am mächtigsten:

@Around

Beispiel:

@Around("execution(* com.example..*Service.*(..))")
public Object measure(ProceedingJoinPoint pjp) throws Throwable {
    long start = System.currentTimeMillis();
    try {
        return pjp.proceed();
    } finally {
        long duration = System.currentTimeMillis() - start;
        System.out.println("Duration: " + duration);
    }
}

Typische Prüfungsfallen

@Around muss proceed() aufrufen, sonst läuft die Zielmethode nicht.
@After läuft nach Methodenabschluss, unabhängig von Erfolg oder Exception.
@AfterReturning läuft nur nach erfolgreichem Return.
@AfterThrowing läuft nur, wenn eine Exception geworfen wird.

Tag 3 — Proxies

Lerninhalt

Spring erzeugt oft ein Proxy-Objekt um deine Bean.

Caller spricht mit dem Proxy. Proxy fügt Verhalten hinzu. Proxy ruft das Zielobjekt auf.


Controller -> Service Proxy -> Real Service

Genutzt von:

@Transactional
Spring Security Method Security
Caching
AOP

Proxy-Typen

Proxy-Typ	Genutzt wenn
JDK dynamic proxy	Interface-basierter Proxy
CGLIB proxy	Klassen-basierter Proxy

Typische Prüfungsfallen

Self-Invocation umgeht den Proxy.
Final Methods/Classes können beim Proxying problematisch sein.
Private Methods werden von Spring AOP nicht advised.
Spring AOP ist proxy-basiert und auf Method Execution fokussiert.

Tag 4 — AOP vs. Filters vs. Interceptors

Vergleich

Mechanismus	Schicht
Servlet Filter	bevor Request Spring MVC erreicht
Spring HandlerInterceptor	um Controller Handling
AOP	um Spring-Bean-Methodenaufrufe

Anwendungsfälle

Bedarf	Tool
Authentication Filter	Filter
Request Logging	Filter oder Interceptor
Controller Timing	Interceptor
Service Method Audit	AOP
Transaction Boundary	AOP Proxy

Tag 5 — AOP Prüfungs-Zusammenfassung

Du musst erklären können

@Transactional funktioniert, weil Spring einen Proxy um die Service Bean erzeugt.
Wenn eine andere Bean die Service-Methode aufruft, geht der Aufruf durch den Proxy.
Der Proxy öffnet eine Transaction vor der Methode und committed oder rollt nach der Methode zurück.
Wenn die Methode eine andere Methode in derselben Klasse aufruft, geht der Aufruf nicht durch den Proxy.
Deshalb kann Self-Invocation transaktionales Verhalten brechen.

Woche-7-Review-Checkliste

Du musst wissen:

AOP
Aspect
Advice
Pointcut
Join point
Proxy
JDK dynamic proxy
CGLIB
Self-Invocation
Zusammenhang zwischen AOP und Transactions

Woche 8 — Spring Security

Ziel

Verstehe die Security Filter Chain, Authentication, Authorization, Password Encoding, CSRF, CORS und Method Security.

Tag 1 — Security Mental Model

Lerninhalt

Authentication:

Wer bist du?

Authorization:

Was darfst du tun?

Spring Security arbeitet meist über Filters.

Request-Flow:

HTTP request
-> Security filter chain
-> DispatcherServlet
-> Controller

Typische Prüfungsfallen

Security passiert vor der Controller-Ausführung.
Spring Security basiert für Web Security auf Servlet Filters.
Method Security kann auch Service-Methoden schützen.

Tag 2 — SecurityFilterChain

Lerninhalt

Modernes Spring Security nutzt SecurityFilterChain.

Beispiel:

@Bean
SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    return http
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/actuator/health").permitAll()
            .anyRequest().authenticated()
        )
        .formLogin(Customizer.withDefaults())
        .build();
}

Typische Prüfungsfallen

WebSecurityConfigurerAdapter ist alter Stil.
SecurityFilterChain ist aktueller Stil.
Request Matchers definieren Authorization Rules.

Tag 3 — Users, Roles, Authorities

Lerninhalt

Wichtige Interfaces/Klassen:

UserDetails
UserDetailsService
GrantedAuthority
PasswordEncoder
Authentication
SecurityContext
SecurityContextHolder

Roles vs. authorities

In Spring Security:


ROLE_ADMIN

ist eine Authority.

hasRole("ADMIN") prüft auf:


ROLE_ADMIN

hasAuthority("ROLE_ADMIN") prüft direkt.

Typische Prüfungsfallen

Roles werden meist als Authorities mit ROLE_-Prefix gespeichert.
Passwörter sollten encoded sein, nicht als Klartext.
BCrypt wird häufig genutzt.

Tag 4 — CSRF und CORS

CSRF

CSRF schützt browser-basierte Session Authentication vor ungewollten state-changing Requests.

Für stateless REST APIs mit Tokens ist CSRF oft deaktiviert.

Aber verstehe den Grund — merke dir nicht nur „CSRF deaktivieren“.

CORS

CORS ist ein Browser-Security-Mechanismus.

Deine React-App unter:


http://localhost:3000

ruft Backend auf unter:


http://localhost:8080

Das ist Cross-Origin.

Spring kann erlaubte Origins, Methods und Headers konfigurieren.

Typische Prüfungsfallen

CSRF und CORS sind unterschiedlich.
CORS wird vom Browser erzwungen.
CSRF geht um ungewollte authentifizierte Aktionen.
CSRF deaktivieren ist bei stateless APIs üblich, nicht immer bei session-basierten Apps.

Tag 5 — Method Security

Lerninhalt

Method Security aktivieren:

@EnableMethodSecurity

Nutzen:

@PreAuthorize("hasRole('ADMIN')")
public void deleteTask(Long id) {}

Typische Prüfungsfallen

Method Security nutzt auch Proxies.
Self-Invocation kann Method Security beeinflussen.
Controller Security und Method Security können kombiniert werden.

Woche-8-Review-Checkliste

Du musst wissen:

Authentication
Authorization
Filter Chain
SecurityFilterChain
UserDetails
UserDetailsService
PasswordEncoder
BCrypt
Roles und Authorities
CSRF
CORS
Method Security
@PreAuthorize

Woche 9 — Testing

Ziel

Verstehe Spring-Testing-Annotationen und wann du welche nutzt.

Tag 1 — Testing Pyramid

Lerninhalt

Test-Typen:

Test-Typ	Speed	Zweck
Unit test	schnellste	reine Java-Logik
Slice test	schnell	eine Spring-Schicht
Integration test	langsamer	größerer Spring Context
End-to-end test	langsamste	ganzes System

Prüfungsfalle

Nutze nicht @SpringBootTest für alles.

Tag 2 — Unit Tests mit Mockito

Lerninhalt

Nutze Mockito für Service-Tests ohne Spring Context.

@ExtendWith(MockitoExtension.class)
class TaskServiceTest {

    @Mock
    TaskRepository taskRepository;

    @InjectMocks
    TaskService taskService;
}

Typische Prüfungsfallen

Unit Tests brauchen kein Spring.
Mockito mockt Dependencies.
Schnelle Tests sind nützlich für Business Logic.

Tag 3 — MVC Slice Tests

Lerninhalt

Nutze:

@WebMvcTest(TaskController.class)

Meist mit:

MockMvc
@MockBean

Beispiel-Zweck:

Request Mapping testen
Validation testen
Status Codes testen
JSON Response testen
Controller-Verhalten testen

Typische Prüfungsfallen

@WebMvcTest lädt nicht den vollen Application Context.
Service Beans müssen meist gemockt werden.
Fokus liegt auf der Web-Schicht.

Tag 4 — JPA Slice Tests

Lerninhalt

Nutze:

@DataJpaTest

Zweck:

Repositories testen
Entity Mapping testen
Queries testen
Persistence-Verhalten testen

Typische Prüfungsfallen

@DataJpaTest lädt JPA-bezogene Komponenten.
Es nutzt standardmäßig meist eine Embedded Database, sofern nicht anders konfiguriert.
Tests sind oft transaktional und rollen nach jedem Test zurück.

Tag 5 — Full Integration Tests

Lerninhalt

Nutze:

@SpringBootTest

Zweck:

vollen Context laden
mehrere Schichten zusammen testen
echte Configuration testen
Application Wiring testen

Optional:

@AutoConfigureMockMvc

Typische Prüfungsfallen

@SpringBootTest ist schwerer.
Es ist nützlich, sollte aber kleinere Tests nicht ersetzen.
Es lädt den vollen Application Context.

Woche-9-Review-Checkliste

Du musst wissen:

JUnit 5
Mockito
@SpringBootTest
@WebMvcTest
@DataJpaTest
MockMvc
@MockBean
Test Profiles
Transaction Rollback in Tests
Unit vs. Integration Tests

Woche 10 — Actuator, Production Readiness, Final Exam Review

Ziel

Verstehe production-ready Features und schließe das Prüfungs-Cheat Sheet ab.

Tag 1 — Actuator

Lerninhalt

Actuator bietet production-ready Endpoints.

Häufige Endpoints:

/actuator/health
/actuator/info
/actuator/metrics
/actuator/env
/actuator/beans
/actuator/conditions

Konfiguration

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

Typische Prüfungsfallen

Exponiere nicht alle Endpoints öffentlich in Produktion.
Health Endpoint wird häufig exponiert.
Actuator kann Conditions und Bean-Informationen zeigen.

Tag 2 — Logging

Lerninhalt

Spring Boot nutzt Logging-Abstraktion und Default-Logging-Configuration.

Häufige Levels:

TRACE
DEBUG
INFO
WARN
ERROR

Beispiel:

logging:
  level:
    org.springframework.security: DEBUG

Typische Prüfungsfallen

Debug Logging kann Auto-configuration und Security verständlich machen.
Aktiviere nicht zu viel Debug Logging in Produktion.

Tag 3 — Packaging und Running

Lerninhalt

Spring-Boot-Anwendungen können als executable JARs gepackt werden.

Starten:

java -jar app.jar

Profile wechseln:

java -jar app.jar --spring.profiles.active=prod

Environment Variable:

SPRING_PROFILES_ACTIVE=prod java -jar app.jar

Typische Prüfungsfallen

Spring Boot nutzt standardmäßig einen Embedded Server für Web Apps.
Du musst kein WAR auf externen Tomcat deployen für typische Boot Apps.

Tag 4 — Finale Schwachstellen

Review alle schwachen Themen:

## Schwaches Thema

Warum ich falsch lag:

Korrekte Erklärung:

Code-Nachweis:

Prüfungsfalle:

Finaler Merksatz:

Tag 5 — Finaler Mock-Exam-Ablauf

Mache eine Mock-Exam-Simulation:

# Mock-Exam-Log

Datum:

Score:

Benötigte Zeit:

Schwachstellen:

Top 10 falsche Fragen:

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

Themen für morgen zum Reviewen:

Finales Prüfungs-Cheat Sheet

Spring Core

IoC

IoC bedeutet: Das Framework steuert Objekterzeugung und Wiring.

Dependency Injection

DI bedeutet: Abhängigkeiten werden von außen bereitgestellt, meist vom Spring-Container.

Bean

Eine Bean ist ein vom Spring verwaltetes Objekt.

ApplicationContext

Der zentrale Spring-Container. Er verwaltet Beans, Configuration, Events, Environment und Lifecycle.

Component Scanning

Spring scannt Packages nach Stereotype-Annotationen wie @Component, @Service, @Repository und @Controller.

`@Component` vs. `@Bean`

@Component: annotiere deine eigene Klasse.
@Bean: erzeuge eine Bean manuell in einer Configuration-Klasse.

`@Primary` vs. `@Qualifier`

@Primary: Standard-Bean, wenn mehrere Kandidaten existieren.
@Qualifier: wähle explizit eine bestimmte Bean.

Bean Lifecycle

Reihenfolge:

Instanziieren
Abhängigkeiten injizieren
Aware-Callbacks
BeanPostProcessor vor Init
Init-Callbacks
BeanPostProcessor nach Init
Bean bereit
Destroy-Callbacks

Spring Boot

`@SpringBootApplication`

Kombination aus:

@Configuration
@EnableAutoConfiguration
@ComponentScan

Auto-Configuration

Spring Boot erzeugt Beans automatisch basierend auf Classpath, Properties, vorhandenen Beans und Conditions.

Starters

Dependency-Bundles, die Maven/Gradle-Configuration vereinfachen.

Spring MVC

DispatcherServlet

Front Controller, der Requests empfängt und an Controller weiterleitet.

`@RestController`

Äquivalent zu:

@Controller
@ResponseBody

Request Annotations

Annotation	Zweck
`@RequestBody`	JSON-Body
`@PathVariable`	Pfadwert
`@RequestParam`	Query-Parameter
`@Valid`	Validation triggern

Data Access

JDBC

Low-Level-Datenbankzugriffs-API.

JdbcTemplate

Spring-Helfer, der JDBC-Boilerplate reduziert.

JPA

Spezifikation für ORM.

Hibernate

Beliebte JPA-Implementierung.

Spring Data JPA

Erzeugt Repository-Implementierungen automatisch.

Transactions

`@Transactional`

Erzeugt eine Transaction um eine Methode über Spring AOP Proxy.

Rollback Default

Exception	Rollback
RuntimeException	ja
Error	ja
Checked Exception	nein

Propagation

Wichtigste:

REQUIRED
REQUIRES_NEW
MANDATORY
NESTED

Self-Invocation

Eine Methode in derselben Klasse, die eine andere transaktionale Methode aufruft, umgeht den Proxy.

AOP

Aspect

Klasse mit Cross-Cutting Behavior.

Advice

Aktion, die an einem Join Point ausgeführt wird.

Pointcut

Expression, die festlegt, wo Advice gilt.

Proxy

Wrapper-Objekt, das Spring nutzt, um Verhalten um Methodenaufrufe zu legen.

Security

Authentication

Wer bist du?

Authorization

Was darfst du tun?

SecurityFilterChain

Definiert Web-Security-Regeln.

CSRF

Schutz vor ungewollten browser-basierten authentifizierten Requests.

CORS

Browser-Mechanismus für Cross-Origin Requests.

Testing

`@SpringBootTest`

Lädt den vollen Application Context.

`@WebMvcTest`

Lädt nur die Web-Schicht.

`@DataJpaTest`

Lädt nur die JPA-Schicht.

MockMvc

Testet MVC-Requests ohne echten Server zu starten.

Actuator

Production-ready Endpoints für:

health
metrics
info
beans
conditions
environment

Exponiere nicht alle Endpoints öffentlich in Produktion.

Prüfungsfragen-Bank

Nutze diese Fragen für Active Recall.

Spring Core

Was ist IoC?
Was ist Dependency Injection?
Was ist eine Spring Bean?
Was ist ApplicationContext?
Was ist der Unterschied zwischen BeanFactory und ApplicationContext?
Was ist Component Scanning?
Was macht @Component?
Was ist der Unterschied zwischen @Component und @Bean?
Was ist der Unterschied zwischen @Service und @Repository?
Warum wird Constructor Injection empfohlen?
Was passiert, wenn zwei Beans zu einer Abhängigkeit passen?
Was macht @Primary?
Was macht @Qualifier?
Was ist der Standard-Bean-Scope?
Was ist der Unterschied zwischen Singleton und Prototype Scope?
Was ist ein Bean-Lifecycle-Callback?
Wann läuft @PostConstruct?
Was macht BeanPostProcessor?
Was sind Profiles?
Was ist der Unterschied zwischen @Value und @ConfigurationProperties?

Spring Boot

Was enthält @SpringBootApplication?
Was ist Auto-configuration?
Was ist ein Starter?
Wie entscheidet Spring Boot, was auto-konfiguriert wird?
Wie kannst du eine auto-konfigurierte Bean überschreiben?
Was ist @ConditionalOnMissingBean?
Was ist Embedded Tomcat?
Was ist CommandLineRunner?
Was ist ApplicationRunner?
Wie aktivierst du Debug-Informationen für Auto-configuration?

Spring MVC

Was ist DispatcherServlet?
Was ist @RestController?
Was ist der Unterschied zwischen @Controller und @RestController?
Was macht @RequestBody?
Was macht @PathVariable?
Was macht @RequestParam?
Was ist ResponseEntity?
Was ist Validation?
Warum nutzen wir DTOs?
Was macht @ControllerAdvice?

Data Access

Was ist JDBC?
Was macht JdbcTemplate?
Was ist DataAccessException?
Was ist JPA?
Was ist Hibernate?
Was ist eine Entity?
Was ist EntityManager?
Was ist Persistence context?
Was ist Spring Data JPA?
Wie funktionieren Derived Query Methods?
Was ist Lazy Loading?
Was ist das N+1-Problem?
Warum kann das Freigeben von Entities in REST APIs problematisch sein?

Transactions

Was macht @Transactional?
Wo sollten Transaction Boundaries normalerweise liegen?
Welche Exceptions triggern standardmäßig Rollback?
Wie rollst du bei einer Checked Exception zurück?
Was ist Transaction Propagation?
Was bedeutet REQUIRED?
Was bedeutet REQUIRES_NEW?
Was bedeutet MANDATORY?
Was ist Transaction Isolation?
Was ist ein Dirty Read?
Was ist ein Non-repeatable Read?
Was ist ein Phantom Read?
Was ist das Self-Invocation Problem?

AOP

Was ist AOP?
Was ist ein Aspect?
Was ist Advice?
Was ist ein Pointcut?
Was ist ein Join point?
Was macht @Around?
Warum muss proceed() aufgerufen werden?
Was ist ein Proxy?
Was ist der Unterschied zwischen JDK dynamic proxy und CGLIB proxy?
Wie hängt AOP mit @Transactional zusammen?

Security

Was ist Authentication?
Was ist Authorization?
Was ist SecurityFilterChain?
Was ist UserDetails?
Was ist UserDetailsService?
Was ist PasswordEncoder?
Was ist BCrypt?
Was ist der Unterschied zwischen Role und Authority?
Was ist CSRF?
Was ist CORS?
Wann ist das Deaktivieren von CSRF sinnvoll?
Was ist Method Security?
Was macht @PreAuthorize?

Testing

Was ist ein Unit Test?
Was ist ein Integration Test?
Was lädt @SpringBootTest?
Was lädt @WebMvcTest?
Was lädt @DataJpaTest?
Was ist MockMvc?
Was ist @MockBean?
Warum sind Slice Tests nützlich?
Wie verhalten sich Transactions in Tests?
Was ist ein Test Profile?
Warum sollte nicht jeder Test @SpringBootTest nutzen?

Actuator

Was ist Actuator?
Was ist /actuator/health?
Was ist /actuator/metrics?
Was ist /actuator/conditions?
Warum sollten Actuator Endpoints abgesichert sein?

Flashcard-Vorlage

Nutze das für Anki oder Markdown-Flashcards.

## Karte

F:

A:

Code-Beispiel:

Prüfungsfalle:

Merksatz:

Beispiel:

## Karte

F: Was enthält @SpringBootApplication?

A: Es kombiniert @Configuration, @EnableAutoConfiguration und @ComponentScan.

Code-Beispiel:

@SpringBootApplication
public class App {}

Prüfungsfalle:
Viele Entwickler wissen nur, dass es die App startet — die Prüfung erwartet die drei internen Annotationen.

Merksatz:
Spring Boot startet mit Configuration, Auto-configuration und Component Scanning.

Persönliche Study-Regeln

Merke dir nicht nur Annotationen.
Frag immer: „Welches Problem löst das?“
Frag immer: „Was macht Spring intern?“
Vergleiche immer ähnliche Annotationen.
Kenn immer das Standardverhalten.
Kenn immer, wie du das Standardverhalten überschreibst.
Kenn immer die Prüfungsfalle.
Mach immer einen kleinen Code-Nachweis.
Erkläre das Thema immer in einfachen Worten.
Review Fehler öfter als richtige Antworten.

Finaler 14-Tage-Prüfungs-Countdown

Tag -14

Review Spring Core.

Tag -13

Review Configuration, Profiles, Properties und Lifecycle.

Tag -12

Review Spring Boot und Auto-configuration.

Tag -11

Review Spring MVC und REST.

Tag -10

Review Validation und Exception Handling.

Tag -9

Review JDBC, JPA, Spring Data.

Tag -8

Review Transactions.

Tag -7

Review AOP und Proxies.

Tag -6

Review Spring Security.

Tag -5

Review Testing-Annotationen.

Tag -4

Review Actuator und Production Readiness.

Tag -3

Mock Exam 1 und Fehleranalyse.

Tag -2

Mock Exam 2 und Schwachstellen reparieren.

Tag -1

Nur leichtes Review. Keine schweren neuen Themen.

Prüfungstag

Vor der Prüfung reviewen:

@SpringBootApplication
Bean Scopes
Lifecycle
@Transactional
Rollback Rules
Propagation
AOP Proxy-Verhalten
Spring MVC Request Flow
Testing-Annotationen
Security Filter Chain
Actuator Security

Merksatz-Bank

Nutze diese Sätze für schnelles Review.

Spring verwaltet Objekte über den IoC-Container.
Eine Spring Bean ist ein von Spring erzeugtes und verwaltetes Objekt.
Dependency Injection bedeutet: Abhängigkeiten werden von außen bereitgestellt.
Constructor Injection ist bevorzugt, weil Abhängigkeiten explizit und immutable sind.
@Component registriert eine Klasse über Scanning.
@Bean registriert den Rückgabewert einer Methode.
@Repository kann Exception Translation aktivieren.
Der Standard-Bean-Scope ist singleton.
Spring Singleton bedeutet eine Instanz pro Container.
@PostConstruct läuft nach Dependency Injection.
@SpringBootApplication kombiniert Configuration, Auto-configuration und Component Scanning.
Auto-configuration hängt von Classpath, Properties, Conditions und vorhandenen Beans ab.
Starters sind Dependency-Bundles.
DispatcherServlet ist der Front Controller von Spring MVC.
@RestController gibt Response Bodies direkt zurück.
@RequestBody mappt JSON-Body auf Java-Objekt.
@Valid triggert Validation.
@ControllerAdvice behandelt Exceptions global.
JdbcTemplate reduziert JDBC-Boilerplate.
JPA ist eine Spezifikation; Hibernate ist eine Implementierung.
Spring Data JPA generiert Repository-Implementierungen.
Transactions gehören meist in die Service-Schicht.
Runtime Exceptions triggern standardmäßig Rollback.
Checked Exceptions triggern standardmäßig kein Rollback.
REQUIRES_NEW startet eine unabhängige Transaction.
Spring AOP ist proxy-basiert.
Self-Invocation umgeht Spring Proxies.
@Transactional funktioniert über einen Proxy.
Authentication bedeutet: Wer bist du?
Authorization bedeutet: Was darfst du tun?
Spring Security Web Protection nutzt eine Filter Chain.
CSRF und CORS sind unterschiedliche Probleme.
@SpringBootTest lädt den vollen Context.
@WebMvcTest testet die Web-Schicht.
@DataJpaTest testet die Persistence-Schicht.
Actuator bietet production-ready Monitoring Endpoints.

Finale Readiness-Checkliste

Bevor du die Prüfung buchst, solltest du all das können:

[ ] IoC ohne Notizen erklären
[ ] DI ohne Notizen erklären
[ ] ApplicationContext ohne Notizen erklären
[ ] @Component und @Bean vergleichen
[ ] @Service und @Repository vergleichen
[ ] Bean Scopes erklären
[ ] Bean Lifecycle erklären
[ ] Profiles erklären
[ ] @ConfigurationProperties erklären
[ ] @SpringBootApplication erklären
[ ] Auto-configuration erklären
[ ] Starters erklären
[ ] Conditional Annotations erklären
[ ] DispatcherServlet erklären
[ ] REST Controller aus dem Kopf bauen
[ ] DTOs erklären
[ ] Validation erklären
[ ] @ControllerAdvice erklären
[ ] JdbcTemplate erklären
[ ] JPA vs. Hibernate erklären
[ ] Spring Data Repositories erklären
[ ] Lazy Loading erklären
[ ] @Transactional erklären
[ ] Rollback Rules erklären
[ ] Propagation erklären
[ ] Isolation erklären
[ ] Self-Invocation erklären
[ ] AOP-Begriffe erklären
[ ] Spring Proxies erklären
[ ] SecurityFilterChain erklären
[ ] Authentication vs. Authorization erklären
[ ] CSRF erklären
[ ] CORS erklären
[ ] Method Security erklären
[ ] @SpringBootTest erklären
[ ] @WebMvcTest erklären
[ ] @DataJpaTest erklären
[ ] MockMvc erklären
[ ] Actuator erklären
[ ] In Mock Exams konstant gute Scores erreichen

Empfohlener nächster Schritt

Starte mit dieser Datei:


01-spring-core-notes.md

Und schreibe deine eigenen Antworten auf diese fünf Fragen:

Welches Problem löst Spring?
Was ist IoC?
Was ist Dependency Injection?
Was ist eine Bean?
Was passiert, wenn eine Spring-Boot-Anwendung startet?

Kopiere keine Antworten aus einem Tutorial. Schreibe sie in deinen eigenen Worten.

Wenn du diese fünf klar erklären kannst, gehe weiter zu Woche 1 Tag 2.

0. Zertifizierungsziel​

1. So nutzt du dieses Curriculum​

2. Wochenstruktur​

3. Tägliche Study-Vorlage​

10-Wochen-Zertifizierungsplan

Woche 1 — Spring-Core Mental Model​

Ziel​

Kernfragen​

Tag 1 — Welches Problem löst Spring?​

Lerninhalt​

Kernidee​

React-Vergleich​

Kleiner Code-Nachweis​

Typische Prüfungsfallen​

Tag 2 — ApplicationContext und BeanFactory​

Lerninhalt​

Das musst du wissen​

Typische Prüfungsfallen​

Kleine Übung​

Tag 3 — Beans und Bean Definitions​

Lerninhalt​

Vergleich​

Prüfungsfalle​

Kleine Übung​

Tag 4 — Dependency Injection​

Lerninhalt​

Warum Constructor Injection am besten ist​

Typische Prüfungsfallen​

Kleiner Code-Nachweis​

Tag 5 — Component Scanning​

Lerninhalt​

Beispiel​

Typische Prüfungsfallen​

Kleine Übung​

Woche-1-Review-Checkliste​

Woche 2 — Configuration, Profiles, Properties, Bean Lifecycle​

Ziel​

Tag 1 — Java Configuration​

Lerninhalt​

Wichtig​

Typische Prüfungsfallen​

Tag 2 — Externe Configuration​

Lerninhalt​

Bevorzugt​

Typische Prüfungsfallen​

Tag 3 — Profiles​

Lerninhalt​

Typische Profile-Anwendungsfälle​

Typische Prüfungsfallen​

Tag 4 — Bean Scopes​

Lerninhalt​

Wichtig​

Prüfungsfalle​

Tag 5 — Bean Lifecycle​

Lerninhalt​

Typische Prüfungsfallen​

Woche-2-Review-Checkliste​

Woche 3 — Spring Boot und Auto-configuration​

Ziel​

Tag 1 — Spring-Boot Mental Model​

Lerninhalt​

Wichtige Annotation​

Prüfungsfalle​

Tag 2 — Starters​

Lerninhalt​

Warum sie existieren​

Typische Prüfungsfallen​

Tag 3 — Auto-configuration​

Lerninhalt​

Häufige Conditional Annotations​

Typische Prüfungsfallen​

Tag 4 — SpringApplication und Runners​

Lerninhalt​

Unterschied​

Tag 5 — Boot Configuration Debugging​

Lerninhalt​

Kleine Übung​

Woche-3-Review-Checkliste​

Woche 4 — Spring MVC und REST​

Ziel​

0. Zertifizierungsziel

1. So nutzt du dieses Curriculum

2. Wochenstruktur

3. Tägliche Study-Vorlage

Woche 1 — Spring-Core Mental Model

Ziel

Kernfragen

Tag 1 — Welches Problem löst Spring?

Lerninhalt

Kernidee

React-Vergleich

Kleiner Code-Nachweis

Typische Prüfungsfallen

Tag 2 — ApplicationContext und BeanFactory

Lerninhalt

Das musst du wissen

Typische Prüfungsfallen

Kleine Übung

Tag 3 — Beans und Bean Definitions

Lerninhalt

Vergleich

Prüfungsfalle

Kleine Übung

Tag 4 — Dependency Injection

Lerninhalt

Warum Constructor Injection am besten ist

Typische Prüfungsfallen

Kleiner Code-Nachweis

Tag 5 — Component Scanning

Lerninhalt

Beispiel

Typische Prüfungsfallen

Kleine Übung

Woche-1-Review-Checkliste

Woche 2 — Configuration, Profiles, Properties, Bean Lifecycle

Ziel

Tag 1 — Java Configuration

Lerninhalt

Wichtig

Typische Prüfungsfallen

Tag 2 — Externe Configuration

Lerninhalt

Bevorzugt

Typische Prüfungsfallen

Tag 3 — Profiles

Lerninhalt

Typische Profile-Anwendungsfälle

Typische Prüfungsfallen

Tag 4 — Bean Scopes

Lerninhalt

Wichtig

Prüfungsfalle

Tag 5 — Bean Lifecycle

Lerninhalt

Typische Prüfungsfallen

Woche-2-Review-Checkliste

Woche 3 — Spring Boot und Auto-configuration

Ziel

Tag 1 — Spring-Boot Mental Model

Lerninhalt

Wichtige Annotation

Prüfungsfalle

Tag 2 — Starters

Lerninhalt

Warum sie existieren

Typische Prüfungsfallen

Tag 3 — Auto-configuration

Lerninhalt

Häufige Conditional Annotations

Typische Prüfungsfallen

Tag 4 — SpringApplication und Runners

Lerninhalt

Unterschied

Tag 5 — Boot Configuration Debugging

Lerninhalt

Kleine Übung

Woche-3-Review-Checkliste

Woche 4 — Spring MVC und REST

Ziel

Tag 1 — DispatcherServlet