Réusinage de code legacy en Java : guide pas à pas de A à Z

Réusinage de code legacy en Java : de A à Z

Travailler avec du code hérité (legacy) en Java est un défi que chaque développeur rencontre. L'ancien code manque souvent de tests, contient des modèles obsolètes et est difficile à modifier. Cependant, réécrire entièrement le projet n'est pas toujours la meilleure solution. Dans cet article, nous allons détailler une approche éprouvée pour le réusinage de code legacy : de l'analyse à la mise en œuvre des modifications, avec des exemples concrets en Java.

1. Diagnostic et préparation : avant de toucher au code

La première et la plus importante étape est de comprendre ce que vous avez. Ne commencez pas le réusinage par des corrections chaotiques de lignes. Au lieu de cela :

• Cartographie des dépendances : visualisez quelles classes dépendent de quoi. Utilisez des outils comme IntelliJ IDEA Dependency Viewer ou JDepend.
• Tests de caractérisation (Characterization Tests) : écrivez des tests qui figent le comportement actuel du code. C'est votre filet de sécurité.
• Identifiez les points d'entrée : déterminez quelles méthodes sont appelées le plus souvent et où se produisent les principales modifications.

Exemple d'un test de caractérisation simple pour une méthode à réusiner :

import org.junit.jupiter.api.Test;import static org.junit.jupiter.api.Assertions.assertEquals;

public class LegacyCalculatorTest {

    @Test    public void testLegacyCalculate() {        LegacyCalculator calc = new LegacyCalculator();        // Figer le comportement actuel        int result = calc.calculate(10, 5, "add");        assertEquals(15, result, "Comportement actuel : addition");                result = calc.calculate(10, 5, "sub");        assertEquals(5, result, "Comportement actuel : soustraction");    }}

Un tel test ne vérifie pas la justesse de la logique dans un sens absolu — il fige simplement ce que le code fait actuellement. Après le réusinage, le test doit réussir, sinon vous avez modifié le comportement.

2. Stratégie de réusinage "chirurgical" : méthode par méthode

Essayer de réusiner toute une classe d'un coup est un moyen sûr d'introduire des bogues. Utilisez l'approche "fouille archéologique" (Combat Archaeology) :

• Choisissez une méthode ou un petit groupe de méthodes liées.
• Écrivez des tests de caractérisation pour elles (s'ils n'existent pas).
• Appliquez une technique de réusinage (par exemple, Extract Method ou Rename Variable).
• Exécutez les tests. Ils doivent réussir.
• Validez les modifications avec une description claire.

Exemple : réusinage d'une méthode avec des "nombres magiques" et une longue liste de paramètres.

Code source (mauvais) :

public class OrderProcessor {    public double process(double amount, int type, double discount) {        double result;        if (type == 1) {            result = amount * 1.2; // 20% de majoration            if (discount > 0.1) {                result = result - result * 0.05; // 5% de remise            }        } else if (type == 2) {            result = amount * 1.5; // 50% de majoration        } else {            result = amount;        }        return result;    }}

Après réusinage (amélioré) :

public class OrderProcessor {    private static final double PREMIUM_MARKUP = 1.2;    private static final double STANDARD_MARKUP = 1.5;    private static final double LOYALTY_DISCOUNT = 0.05;    private static final double DISCOUNT_THRESHOLD = 0.1;

    public double process(OrderType type, double amount, double discount) {        double basePrice = applyMarkup(amount, type);        return applyLoyaltyDiscount(basePrice, discount);    }

    private double applyMarkup(double amount, OrderType type) {        return switch (type) {            case PREMIUM -> amount * PREMIUM_MARKUP;            case STANDARD -> amount * STANDARD_MARKUP;            case BASIC