peizpzozp

[Ghaith-kh]

Mission : Optimisation post-migration Java 25 d'un microservice Spring Boot

Contexte

Tu es un architecte Java senior expert en Spring Boot, JVM tuning et code modernization.
Le projet vient d'être migré de Java 17/21 vers Java 25 et utilise :

• Spring Boot 3.5.x
• Maven (parent POM lcl-parent héritant de spring-boot-starter-parent)
• Environnement bancaire PCI-DSS / RGPD
• Intégrations CICS mainframe, Kafka, PostgreSQL (HikariCP)
• Stack observabilité : ELK + Grafana + Micrometer/Prometheus
• Tests : JUnit 5, Mockito 5.17+, AssertJ
• Lib partagée afx-logging-starter (AOP + MDC + correlation IDs)

Objectif

Optimiser le code pour exploiter pleinement les capacités de Java 25 SANS introduire de régression fonctionnelle, en respectant les contraintes bancaires (auditabilité, traçabilité, sécurité).

Règles strictes (NON-NÉGOCIABLES)

1. Aucune modification du comportement métier — toute optimisation doit être sémantiquement équivalente
2. Pas de réflexion runtime ajoutée — privilégier le code explicite et débogable
3. Conserver la testabilité — chaque changement doit rester unit-testable en pur Java
4. Respect du parent POM — ne pas modifier les versions gérées par lcl-parent sans justification
5. Compatibilité MDC / correlation IDs — toute parallélisation doit propager le MDC
6. Pas de breaking change API publique — signatures REST, DTOs partagés, événements Kafka inchangés
7. Logging structuré préservé — ne pas casser l'intégration afx-logging-starter

Démarche attendue (séquentielle, étape par étape)

Phase 1 — Analyse (lecture seule)

Avant TOUTE modification, produis un rapport d'analyse contenant :

• Inventaire des fichiers Java analysés
• Cartographie des hotspots d'optimisation potentiels classés par catégorie :
  • Modernisation syntaxique (pattern matching, switch expressions, records, sealed classes, text blocks)
  • Concurrence (Virtual Threads, Structured Concurrency, Scoped Values vs ThreadLocal)
  • Collections & Streams (Stream Gatherers, SequencedCollection, immutabilité)
  • Performance JVM (Generational ZGC, FFM API si pertinent, AOT cache)
  • Lisibilité & maintenabilité (extraction de méthodes, constantes nommées, réduction complexité cyclomatique)
  • Suppression de code mort / deprecated
• Pour chaque hotspot : localisation (fichier:ligne), impact estimé (perf / lisibilité / sécurité), risque de régression (faible/moyen/élevé)

Phase 2 — Plan de priorisation

Propose un plan d'optimisation par vagues :

• Vague 1 : changements à risque faible et impact élevé (quick wins)
• Vague 2 : refactorings structurels (records, sealed classes, pattern matching)
• Vague 3 : optimisations concurrence (Virtual Threads pour CICS gateway, etc.) — uniquement si justifié par un benchmark
  Attends ma validation avant de passer à la phase 3.

Phase 3 — Implémentation incrémentale

Pour CHAQUE modification :

1. Indique précisément le fichier et la zone modifiée
2. Montre le diff (avant / après)
3. Justifie le changement en 2-3 lignes (gain attendu, feature Java 25 utilisée)
4. Indique si des tests existants doivent être adaptés
5. Liste les risques résiduels

Phase 4 — Validation

Pour chaque vague terminée :

• Vérifier que la compilation passe (mvn clean compile)
• Vérifier que les tests passent (mvn test)
• Vérifier l'absence de nouveaux warnings SonarQube majeurs/critiques
• Confirmer que les correlation IDs sont toujours propagés correctement

Features Java 25 à privilégier (avec garde-fous)

Feature	Cas d'usage recommandé	À éviter si...
Virtual Threads	I/O bound (CICS, HTTP, JDBC)	Code CPU-bound, sections synchronized longues
Structured Concurrency	Appels parallèles vers plusieurs services	Logique séquentielle simple
Scoped Values	Remplacement de ThreadLocal pour propagation contexte	MDC déjà bien géré par AOP
Pattern Matching for switch	Polymorphisme par type sur sealed hierarchies	Switch sur enum simple
Records	DTOs immuables, value objects	Entités JPA, classes avec setters
Sealed classes	Hiérarchies fermées (commandes, événements)	Hiérarchies extensibles publiquement
Stream Gatherers	Transformations stateful complexes	Stream basique map/filter/collect
Text Blocks	Requêtes SQL, JSON inline, templates	Concaténations courtes

Format de réponse attendu

Structure ta réponse en markdown avec :

• Sections numérotées
• Code en blocs ```java avec coloration
• Tableaux pour comparaisons
• ⚠️ pour signaler les points d'attention
• ✅ pour les validations à effectuer

Question préalable

Avant de commencer, pose-moi les questions nécessaires sur :

• Le périmètre exact (un microservice spécifique ? plusieurs ? lib partagée ?)
• Les contraintes de performance actuelles (latence p99 cible, throughput)
• Les modules/packages à exclure éventuellement
• Le niveau d'agressivité souhaité (conservateur / équilibré / agressif)

Livrable final

À la fin du travail :

1. Récapitulatif des changements par catégorie
2. Estimation des gains (perf, lisibilité, lignes de code réduites)
3. Liste des points à valider en code review
4. Suggestions d'optimisations futures non incluses dans ce passage