Seminar Micronaut – Architektur, Dependency Injection und AOP

Micronaut verlagert wesentliche Framework-Arbeit in die Kompilierung. Das Seminar untersucht die daraus entstehende Architektur und zeigt, wie Beans, Scopes, Qualifier, Konfiguration, Ereignisse und AOP-Interceptors ohne undurchsichtige Laufzeitmechanismen sauber aufgebaut werden.

Inhaltsübersicht

• Zielsetzung
• Zielgruppe
• Voraussetzungen
• Seminarinhalte
• Praxisübungen
• Methodik

Zielsetzung

• Kompilierungsbasierte Bean-Metadaten und den Anwendungsstart nachvollziehen
• Beans mit passenden Scopes, Qualifiern, Factories und Bedingungen modellieren
• Konfiguration, Ereignisse und Lebenszyklusmethoden kontrolliert verwenden
• Querschnittsfunktionen mit AOP und eigenen Interceptors testbar umsetzen

Zielgruppe

Java- und Kotlin-Entwickler, Backend-Entwickler, technische Consultants und Softwarearchitekten.

Voraussetzungen

Sichere Java- oder Kotlin-Grundkenntnisse, objektorientierte Programmierung, HTTP-Grundlagen und Erfahrung mit Gradle oder Maven.

Seminarinhalte

1. Schritt 1: Kompilierungsmodell analysieren

   Annotation Processing beziehungsweise KSP, generierte Bean-Definitionen und der Unterschied zu reflektionslastigen Laufzeitcontainern werden anhand eines Minimalprojekts untersucht.

2. Schritt 2: Bean-Erzeugung strukturieren

   Konstruktorinjektion, Bean-Definitionen, Abhängigkeiten und zyklische Referenzen werden geprüft. Fachlogik wird von Erzeugungs- und Integrationslogik getrennt.

3. Schritt 3: Scopes passend auswählen

   Singleton, Prototype, Request und weitere Gültigkeitsbereiche werden nach Zustand, Nebenläufigkeit und Ressourcenverbrauch bewertet.

4. Schritt 4: Qualifier und Mehrfachimplementierungen beherrschen

   Benannte Beans, eigene Qualifier und priorisierte Implementierungen werden eingesetzt, ohne Typauflösung und Tests unnötig zu verkomplizieren.

5. Schritt 5: Factories und bedingte Beans erstellen

   Externe Bibliotheken, Clients und infrastrukturelle Komponenten werden über Factories bereitgestellt. Bedingungen nach Klasse, Eigenschaft und Umgebung steuern die Aktivierung.

6. Schritt 6: Konfiguration typsicher binden

   Eigenschaftshierarchien, Konfigurationsklassen, Validierung, Standardwerte und sensible Werte werden in klar abgegrenzte Konfigurationsobjekte überführt.

7. Schritt 7: Lebenszyklus und Ereignisse verwenden

   Initialisierung, Aufräumen, Anwendungsereignisse und Listener werden so eingesetzt, dass Reihenfolge und Fehlerverhalten nachvollziehbar bleiben.

8. Schritt 8: AOP-Interceptors entwickeln

   Around- und Introduction-Advice, Bindungsannotation, Interceptor-Reihenfolge und Kontextdaten werden für Protokollierung, Messung oder fachübergreifende Regeln umgesetzt.

9. Schritt 9: Architektur mit Tests absichern

   Bean-Auflösung, Bedingungen, Scopes, Konfiguration und Interceptors werden in fokussierten Tests geprüft. Fehlkonfigurationen werden als erwartete Testfälle modelliert.

Praxisübungen

• Analyse generierter Bean-Definitionen
• Mehrere Implementierungen mit eigenen Qualifiern
• Bedingte Factory für eine externe Komponente
• Eigener AOP-Interceptor mit Test

Methodik

Kurze fachliche Einordnungen wechseln mit Demonstrationen und schrittweisen Übungen. Jeder Arbeitsstand wird gebaut, ausgeführt und durch automatisierte oder betriebliche Prüfungen abgesichert. Fehlerfälle werden bewusst einbezogen, damit Diagnose und Wiederanlauf nicht erst im Produktivbetrieb entstehen.