Bereitschafts-Checkliste

Dein Scoreboard für die Zertifizierung.

Pro Punkt:

1. Laut antworten — ohne abzulesen.
2. Musterantwort erst danach öffnen.
3. Klingt die Musterantwort fremd? → Lernlinks unten.

Spring Core

• Ich kann IoC erklären — ohne „Magie“ als Erklärung.
• Ich kann Dependency Injection erklären und sage, warum Constructor Injection bevorzugt wird.
• Ich weiß, was eine Spring Bean ist.
• Ich weiß, was ApplicationContext macht.
• Ich kann BeanDefinition und Bean unterscheiden.
• Ich weiß, wann @Primary und @Qualifier zum Einsatz kommen.

Musterantworten

IoC: Spring steuert Objekterstellung und Verdrahtung — der Anwendungscode erzeugt nicht alles selbst.

Dependency Injection: Abhängigkeiten kommen von außen. Constructor Injection macht Pflicht-Dependencies sichtbar, erlaubt final und einfache Tests.

Eine Spring Bean wird vom IoC-Container verwaltet.

ApplicationContext ist der Hauptcontainer — er erzeugt, verdrahtet, konfiguriert und verwaltet Beans.

BeanDefinition = Rezept/Metadaten. Die Bean = das daraus erzeugte Objekt.

@Primary = Default bei mehreren Kandidaten. @Qualifier = gezielte Auswahl.

Lernlinks:

• Spring Core und Dependency Injection
• What Problem Does Spring Solve?
• ApplicationContext and BeanFactory
• Beans and Bean Definitions
• Dependency Injection Deep Dive

Konfiguration

• Ich kann @Configuration und @Bean erklären.
• Ich weiß, wann @Component, wann @Bean.
• Ich kann Profile erklären.
• Ich kann Singleton vs. Prototype erklären.
• Ich kenne die Hauptphasen des Bean-Lifecycles.
• Ich kenne die Falle: Prototype in Singleton injiziert.

Musterantworten

@Configuration = Klasse mit Bean-Definitionen. @Bean = Methoden-Rückgabewert wird Bean.

@Component für eigene Klassen per Scanning. @Bean für Drittanbieter-Klassen, eigene Fabriklogik oder nicht annotierbare Typen.

Profile schalten umgebungsspezifische Beans/Config frei (dev, test, prod).

Singleton = eine Instanz pro Container. Prototype = neue Instanz bei jeder Anforderung.

Lifecycle: Objekt erzeugen → injizieren → Aware/Post-Processor → initialisieren → nutzen → ggf. zerstören.

Prototype in Singleton: meist eine Prototype-Instanz beim Singleton-Start. Frische Instanz? Provider oder Lookup-Pattern.

Lernlinks:

• Konfiguration, Profile, Scopes und Lifecycle
• Java Configuration, @Configuration, and @Bean
• External Configuration
• Spring Profiles
• Bean Scopes
• Bean Lifecycle

Spring Boot

• Ich weiß, was in @SpringBootApplication steckt.
• Ich kann Starter erklären.
• Ich kann Auto-Konfiguration, Conditions und Back-off erklären.
• Ich kann nachvollziehen, warum Auto-Konfiguration (nicht) greift.
• Ich kenne den Zweck des Actuator.

Musterantworten

@SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan.

Starter = Dependency-Bündel für ein Feature (Web, JPA, Security, Actuator).

Auto-Konfiguration nach Classpath, Properties und fehlenden User-Beans. Back-off = keine Default-Bean, wenn du schon eine definierst.

Prüfen: Conditions-Report, Debug-Log, Actuator /conditions.

Actuator: Health, Info, Metrics, Beans, Mappings, Scheduled Tasks, Conditions — Betriebsdiagnose.

Lernlinks:

• Spring Boot und Auto-Konfiguration
• Spring Boot Mental Model
• Starters and Dependency Management
• Auto-Configuration Deep Dive
• Spring Boot Actuator

MVC und REST

• Ich kann DispatcherServlet erklären.
• Ich kenne @Controller vs. @RestController.
• Ich kenne @RequestParam, @PathVariable, @RequestBody.
• Ich weiß, wie Validierung ausgelöst wird.
• Ich weiß, wie @ControllerAdvice Fehler behandelt.

Musterantworten

DispatcherServlet = Front Controller: Request annehmen, Mapping, Binding, Validierung, Controller, Response.

@Controller → Views. @RestController = @Controller + @ResponseBody.

@RequestParam = Query/Form. @PathVariable = URI-Template. @RequestBody = HTTP-Body.

Validierung: @Valid / @Validated am Parameter.

@ControllerAdvice = querschnittlich für mehrere Controller; mit @ExceptionHandler für einheitliche API-Fehler.

Lernlinks:

• Spring MVC und REST
• Spring MVC Mental Model
• Request Mapping Deep Dive
• Request and Response Bodies
• Exception Handling
• Validation

Daten und Transaktionen

• Ich weiß, was Spring-Data-JPA-Repositories liefern.
• Ich kann Query Methods erklären.
• Ich weiß, wo @Transactional üblicherweise hingehört.
• Ich kenne die Rollback-Defaults.
• Ich weiß, warum Self-Invocation Transaktionen durchkreuzt.
• Ich kann Lazy Loading und N+1 grob erklären.

Musterantworten

Spring Data JPA erzeugt Repository-Implementierungen zur Laufzeit — CRUD und Queries aus dem Interface.

Query Methods: Spring leitet die Query aus dem Methodennamen ab (findByEmail).

@Transactional meist auf Services — dort liegen Use Cases und Transaktionsgrenzen.

Rollback bei unchecked Exceptions/Errors. Checked nur mit Konfiguration.

Self-Invocation: Aufruf innerhalb derselben Instanz — kein Proxy, kein @Transactional.

Lazy = Nachladen beim Zugriff. N+1 = eine Query für Eltern, dann pro Kind eine weitere.

Lernlinks:

• Datenzugriff und Transaktionen
• Spring Data JPA Mental Model
• Repository Query Methods
• Transactions Deep Dive
• Entity Relationships
• JPA Performance

Security

• Ich kann Authentication vs. Authorization erklären.
• Ich weiß, dass Security per Filter vor den Controllern läuft.
• Ich weiß, warum Passwörter einen PasswordEncoder brauchen.
• Ich verstehe 401 vs. 403.
• Ich weiß, wovor CSRF schützt.
• Ich weiß, was CORS regelt.

Musterantworten

Authentication = wer. Authorization = was erlaubt.

Security = Servlet-Filter-Kette vor dem Controller.

PasswordEncoder → Hashes statt Klartext, sichere Prüfung beim Login.

401 = nicht eingeloggt. 403 = eingeloggt, aber verboten.

CSRF = ungewollte state-changing Requests von anderen Sites bei Cookie-Auth.

CORS = welche Browser-Origins die API cross-origin aufrufen dürfen — Browser-Regel, keine Auth.

Lernlinks:

• Spring Security
• Spring Security Mental Model
• Users, Passwords, and Authentication Flow
• Authorization Deep Dive
• CSRF, CORS, Sessions, Stateless APIs, and JWT
• Security Testing

Testing

• Ich kenne Unit vs. Slice vs. Integration.
• Ich weiß, wann @WebMvcTest.
• Ich weiß, wann @DataJpaTest.
• Ich weiß, wann @SpringBootTest.
• Ich weiß, was MockMvc macht.
• Ich weiß, was @MockBean / @MockitoBean macht.

Musterantworten

Unit = eine Klasse ohne Spring. Slice = ein Ausschnitt (MVC, JPA). Integration = mehrere Schichten zusammen.

@WebMvcTest für Controller, Routing, Binding, Validierung, JSON, Fehlerantworten.

@DataJpaTest für Repositories, Mappings, Queries, Persistenz.

@SpringBootTest wenn voller Context oder mehrere Schichten nötig.

MockMvc = HTTP-ähnliche MVC-Requests ohne echten Server.

@MockBean / @MockitoBean = Context-Bean durch Mockito-Mock ersetzen.

Lernlinks:

• Testing
• Spring Boot Testing Mental Model
• Unit Testing Services
• Web Layer Testing
• Integration Testing Review

AOP und Proxies

• Ich kann erklären, was ein Aspect ist.
• Ich kenne Advice, Pointcut, Join Point.
• Ich weiß, dass Spring AOP proxy-basiert ist.
• Ich kenne JDK-Proxy vs. CGLIB.
• Ich weiß, warum Self-Invocation wichtig ist.

Musterantworten

Aspect = gebündelte Querschnittslogik (Logging, Transaktionen, Security, Cache).

Advice = Code. Pointcut = wo. Join Point = möglicher Einhängepunkt.

Proxy-basiert: Advice nur über den Spring-Proxy.

JDK = Interfaces. CGLIB = Subklassen.

Self-Invocation = Aufruf auf derselben Instanz — Proxy umgangen, @Transactional & Co. fehlen.

Lernlinks:

• AOP und Proxies
• Spring AOP Mental Model
• Transactions Deep Dive
• Scheduling and Async

Abschluss-Themen

• Ich weiß: Spring Events sind standardmäßig synchron.
• Ich kenne @TransactionalEventListener(AFTER_COMMIT).
• Ich kenne fixedRate vs. fixedDelay.
• Ich weiß: @Async ist proxy-basiert.
• Ich weiß: Actuator-Endpunkte müssen abgesichert werden.

Musterantworten

Synchron: Publisher wartet auf Listener (ohne Async-Konfiguration).

AFTER_COMMIT: Listener erst nach erfolgreichem Commit.

fixedRate = Start-zu-Start. fixedDelay = Ende-zu-nächstem-Start.

@Async nur über Proxy — Self-Invocation umgeht Async.

Actuator kann sensible Betriebsdaten zeigen — in Produktion begrenzen und absichern.

Lernlinks:

• Events, Scheduling, Async und Observability
• Spring Events
• Scheduling and Async
• Spring Boot Actuator
• Final Actuator and Observability Review

Wann du wirklich bereit bist

Kannst du einen angehakten Punkt nicht in zwei bis drei Sätzen erklären? Haken raus — ein verlinktes Kapitel nacharbeiten, nicht das ganze Buch von vorn.