5 erreurs courantes lors de la migration d'EJB vers Spring Boot

Introduction

Au cours de la dernière décennie, j'ai guidé des dizaines d'organisations à travers des migrations d'EJB vers Spring Boot. Bien que chaque système legacy ait ses particularités, je vois les mêmes erreurs se répéter dans différentes entreprises. Cet article partage les cinq pièges les plus courants et comment les éviter.

Erreur #1 : Commencer sans comprendre les dépendances

Le problème : Les équipes plongent dans le code sans cartographier comment leurs EJBs interagissent. Trois mois plus tard, elles découvrent que leur service utilisateur « simple » appelle 47 autres EJBs à travers des chaînes de dépendances complexes.

Ce qui se passe : La migration stagne. Le module « facile » s'avère fortement couplé avec la moitié de l'application. La direction perd confiance.

La solution : Avant d'écrire le moindre code Spring Boot :

1. Générez un graphe de dépendances de vos EJBs
2. Identifiez les nœuds feuilles (EJBs sans dépendances)
3. Commencez avec des modules isolés
4. Remontez progressivement l'arbre de dépendances

Exemple réel : Un client voulait migrer son service de reporting en premier parce que « c'est critique ». L'analyse a révélé qu'il dépendait de plus de 30 autres EJBs. Nous avons commencé avec le service de notification email à la place—zéro dépendances, haute valeur, complété en 2 semaines.

Erreur #2 : Le traiter comme une refonte

Le problème : Les équipes voient la migration comme une opportunité de « bien faire cette fois » et commencent à reconcevoir l'architecture, refactoriser la logique métier et ajouter de nouvelles fonctionnalités.

Ce qui se passe : Le périmètre s'élargit. Les délais explosent. La migration devient un projet pluriannuel. Finalement annulé.

La solution : La migration et l'amélioration sont des activités séparées :

1. Migrez d'abord : Déplacez la logique d'EJB vers Spring Boot en préservant le comportement
2. Testez minutieusement : Assurez-vous que rien n'est cassé
3. Puis améliorez : Refactorisez, optimisez, ajoutez des fonctionnalités

Gardez-les séparées ou vous ne finirez jamais.

Exemple réel : Une équipe a décidé de migrer son système de traitement des commandes ET d'implémenter l'event sourcing ET d'ajouter des analyses en temps réel. Dix-huit mois plus tard, rien n'était en production. Nous avons fait marche arrière, effectué une simple migration lift-and-shift en 3 mois, puis ajouté des améliorations de manière incrémentale.

Erreur #3 : Ignorer les frontières transactionnelles

Le problème : Les transactions gérées par conteneur EJB sont implicites. Les développeurs ne réalisent pas que l'ancien code s'appuyait sur des frontières transactionnelles qu'ils n'avaient jamais explicitement définies.

Ce qui se passe : Corruption de données. Conditions de course. Des bugs mystérieux qui n'apparaissent qu'en production sous charge.

La solution :

1. Documentez les frontières transactionnelles existantes avant de migrer
2. Utilisez @Transactional explicitement dans Spring Boot
3. Comprenez les niveaux de propagation (REQUIRED, REQUIRES_NEW, etc.)
4. Testez minutieusement le comportement transactionnel

Exemple de code :

// Ancien EJB - transaction implicite
@Stateless
public class OrderService {
    public void createOrder(Order order) {
        // Transaction automatiquement démarrée par le conteneur
        em.persist(order);
        notificationService.sendEmail(order);
        // Transaction commitée automatiquement
    }
}

// Spring Boot - rendez-le explicite
@Service
public class OrderService {
    @Transactional  // N'oubliez pas ça !
    public void createOrder(Order order) {
        orderRepository.save(order);
        notificationService.sendEmail(order);
    }
}

Erreur #4 : Tout convertir en APIs REST

Le problème : Les équipes supposent que « moderne = APIs REST partout » et convertissent tous les appels distants EJB en appels HTTP.

Ce qui se passe :

• Les appels réseau bavards détruisent les performances
• La surcharge de sérialisation ralentit tout
• Cauchemars de transactions distribuées
• Le débogage devient incroyablement difficile

La solution : Ce n'est pas parce que vous pouvez en faire du REST que vous devez :

1. Même JVM : Utilisez des appels de méthode directs (Spring @Service)
2. JVMs différentes : Considérez RMI initialement, migrez vers REST plus tard
3. Clients externes : REST/GraphQL a du sens

Ne distribuez pas prématurément votre monolithe.

Exemple réel : Un client a converti plus de 200 interfaces distantes EJB en endpoints REST. Les performances ont chuté de 70%. Nous avons reconsolidé 80% en appels de service directs et gardé REST uniquement pour les vraies APIs externes.

Erreur #5 : Sauter l'infrastructure de test

Le problème : Les applications EJB legacy ont souvent des tests automatisés minimaux. Les équipes migrent sans corriger cela d'abord.

Ce qui se passe : Chaque changement est terrifiant. Aucune confiance dans la migration. Les bugs glissent en production.

La solution : Construisez l'infrastructure de test AVANT de migrer :

1. Tests d'intégration d'abord : Testez le comportement EJB existant
2. Capturez le comportement actuel : Même s'il est bogué, documentez-le
3. Tests parallèles : Exécutez les mêmes tests contre EJB et Spring Boot
4. Ajoutez progressivement des tests unitaires : Au fur et à mesure que vous migrez les modules

Stratégie de test :

// Testez LES DEUX implémentations pendant la migration
@SpringBootTest
class UserServiceMigrationTest {

    @Test
    void testSameBehavior() {
        // Test contre l'ancien EJB
        User ejbResult = legacyUserEJB.getUser(123);

        // Test contre le nouveau service Spring Boot
        User springResult = userService.getUser(123);

        // Vérifiez qu'ils se comportent de manière identique
        assertEquals(ejbResult, springResult);
    }
}

Erreur bonus : Oublier les opérations

Votre équipe ops sait comment surveiller WebLogic. Elle ne connaît pas les actuators Spring Boot, les métriques micrometer ou le tuning Tomcat embarqué. Incluez-les tôt ou le déploiement sera douloureux.

Conclusion

La migration d'EJB vers Spring Boot est réalisable, mais ce n'est pas juste un exercice de traduction de code. Elle nécessite :

• Comprendre l'architecture de votre système
• Maintenir la continuité métier
• Respecter les frontières transactionnelles
• Prendre des décisions de distribution réfléchies
• Construire des tests complets

Évitez ces erreurs et votre migration sera plus rapide, moins chère et moins risquée.

Vous planifiez une migration EJB ? Obtenez une évaluation d'expert pour éviter ces erreurs coûteuses.