Seminar Micronaut – Intensivseminar: Moderne Anwendungsentwicklung, Native und Migration

Das Intensivformat bündelt Kotlin, KSP, Coroutines, serverseitige Webanwendungen, WebSockets und SSE, CLI und Batch, AOT und Native Image, Spring-Boot-Migration sowie KI-Integrationen mit MCP und LangChain4j. Der Schwerpunkt liegt auf kontrollierter Modernisierung statt auf isolierten Demonstrationen.

Inhaltsübersicht

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

Zielsetzung

• Moderne Java- und Kotlin-Anwendungen mit geeigneten Nebenläufigkeitsmodellen entwickeln
• Web-, Echtzeit-, CLI- und KI-Funktionen in einer wartbaren Architektur verbinden
• AOT und Native Image mit messbaren Kriterien produktionsfähig einsetzen
• Spring-Boot-Anwendungen schrittweise und testgesichert nach Micronaut migrieren

Zielgruppe

Erfahrene Entwickler, technische Leads, Softwarearchitekten und Projektteams mit zusammenhängendem Qualifizierungsbedarf.

Voraussetzungen

Gute JVM-Entwicklungskenntnisse, Erfahrung mit HTTP und Tests sowie grundlegende Micronaut- oder Spring-Boot-Kenntnisse.

Seminarinhalte

1. Schritt 1: Modernisierungsziele und Ausgangslage erfassen

   Anwendungstypen, Laufzeitmodell, Bibliotheken, Deployment, Performanceziele und Migrationsrisiken werden inventarisiert. Messbare Erfolgskriterien werden festgelegt.

2. Schritt 2: Kotlin-Projekt mit KSP aufbauen

   Kotlin-Toolchain, KSP, Nullsicherheit, Datenklassen, Bean-Erzeugung und gemischte Java-Kotlin-Module werden reproduzierbar eingerichtet.

3. Schritt 3: Coroutines kontrolliert einsetzen

   Suspend-Funktionen, Dispatcher, Kontextweitergabe, strukturierte Nebenläufigkeit und Flow werden für HTTP- und Datenzugriffe genutzt.

4. Schritt 4: Serverseitige Views entwickeln

   Templates, View Models, statische Ressourcen, Formulare, Validierung und sichere Fehlerdarstellung werden in eine klassische Webanwendung integriert.

5. Schritt 5: HTMX-Interaktionen ergänzen

   Fragmentantworten, Trigger, progressive Verbesserung, Validierungsfehler und History-Verhalten werden ohne unnötige Client-Komplexität umgesetzt.

6. Schritt 6: WebSockets und SSE auswählen

   Bidirektionale und unidirektionale Echtzeitkommunikation werden nach Verbindungslast, Wiederverbindung, Authentifizierung und Nachrichtenmodell verglichen und implementiert.

7. Schritt 7: CLI, Batch und Scheduling integrieren

   Picocli-Befehle, transaktionale Batchschritte, Cron-Jobs, Exit-Codes und Wiederanlauf nutzen dieselben Fachservices wie die Webanwendung.

8. Schritt 8: AOT-Optimierungen aktivieren

   Build-Zeit-Analyse, generierte Konfiguration und optimierte Startpfade werden aktiviert und anhand einer Messbasis überprüft.

9. Schritt 9: Native Image produktionsfähig bauen

   Reflexion, Ressourcen, Initialisierung, native Tests, Container und CI werden für ein reproduzierbares GraalVM-Artefakt eingerichtet.

10. Schritt 10: Spring-Boot-Anwendung inventarisieren

    Starter, Auto-Konfiguration, Bean-Modell, Web, Data, Security, Actuator und Tests werden nach Migrationsaufwand und Kopplung klassifiziert.

11. Schritt 11: Komponenten schrittweise migrieren

    Konfiguration, DI, Controller, Clients, Persistenz und Tests werden in kleinen, lauffähigen Schritten übertragen. Paralleler Betrieb und Rückfall bleiben möglich.

12. Schritt 12: KI-Anwendungsfall und Grenzen definieren

    Modellzugriff, Datenklassifikation, Kosten, Latenz, Ergebnisrisiko, Freigabe und Protokollierung werden vor der Implementierung festgelegt.

13. Schritt 13: LangChain4j-Integration umsetzen

    Chat-Modell, Prompt-Templates, strukturierte Ausgaben, Tools und ein begrenzter Retrieval-Ablauf werden in Micronaut-Beans integriert.

14. Schritt 14: MCP-Client und MCP-Server entwickeln

    Werkzeuge, Ressourcen, Transport, Berechtigungen und Eingabevalidierung werden für einen kontrollierten Austausch zwischen KI-Anwendung und Fachsystem umgesetzt.

15. Schritt 15: Gesamtlösung messen und absichern

    Tests, Security, Observability, Lastprofil, Native-Build und Migrations-Runbook werden zu einer geprüften Liefer- und Einführungsstrategie zusammengeführt.

Praxisübungen

• Kotlin-Service mit Coroutines
• Weboberfläche mit HTMX und Echtzeitkanal
• Gemeinsamer Fachservice für HTTP, CLI und Scheduler
• Native Build mit Vergleichsmessung
• Teilweise Spring-Boot-Migration
• KI-Funktion mit LangChain4j und MCP

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.