Réusinage de code legacy en Java : guide étape par étape

Réfactorisation du code legacy en Java : par où commencer et comment ne pas casser le projet

Tout développeur Java est tôt ou tard confronté à du code legacy. Cela peut être une application monolithique écrite il y a dix ans, ou un projet avec des patterns obsolètes, un manque de tests et des « nombres magiques ». La refactorisation d'un tel code n'est pas une tâche facile, mais elle est absolument nécessaire pour maintenir la viabilité du système.

Dans cet article, nous allons analyser les principales stratégies de refactorisation du code legacy en Java, montrer des exemples concrets et donner des conseils pratiques qui vous aideront à améliorer le code sans risquer de casser la production.

Pourquoi le code legacy nécessite-t-il une refactorisation ?

Le code legacy n'est pas simplement du « vieux code ». C'est un code qui :

• Est difficile à maintenir et à étendre
• N'a pas une couverture de tests suffisante
• Contient des duplications et des « odeurs » (code smells)
• Utilise des bibliothèques et des approches obsolètes

La refactorisation permet d'améliorer la lisibilité, les performances et la testabilité du code. Cependant, la règle principale est de ne pas modifier le comportement externe du système. Chaque changement doit être sûr et contrôlé.

Stratégies de refactorisation du code legacy en Java

1. Création d'un filet de sécurité avec des tests

Avant de toucher au code, écrivez des tests. Cela peut être difficile si le code est mal testable. Utilisez l'approche des Characterization Tests (tests basés sur le comportement actuel).

Exemple : vous avez une méthode qui traite les commandes :

public class OrderProcessor {    public double calculateTotal(Order order) {        double total = 0;        for (Item item : order.getItems()) {            if (item.getPrice() > 100) {                total += item.getPrice() * 0.9; // remise de 10%            } else {                total += item.getPrice();            }        }        if (order.isPremium()) {            total *= 0.95; // remise supplémentaire de 5%        }        return total;    }}

Nous écrivons un test qui fige le comportement actuel :

@Testpublic void testCalculateTotal_WithPremiumAndExpensiveItems() {    Order order = new Order();    order.addItem(new Item(\"Laptop\", 1000));    order.addItem(new Item(\"Mouse\", 50));    order.setPremium(true);        double expected = (1000 * 0.9 + 50) * 0.95; // 902.5    assertEquals(expected, new OrderProcessor().calculateTotal(order), 0.001);}

Vous avez maintenant un « filet de sécurité ». Vous pouvez refactoriser sans craindre de modifier la logique.

2. Division des grandes méthodes (Extract Method)

L'un des problèmes les plus fréquents du code legacy est celui des méthodes « monstres » de plusieurs centaines de lignes. Divisez-les en petites méthodes bien nommées.

Avant la refactorisation :

public void processInvoice(Invoice invoice) {    // 50 lignes de vérification    if (invoice.getCustomer() == null) throw new IllegalArgumentException();    if (invoice.getItems().isEmpty()) throw new IllegalStateException();    // ... encore 20 lignes de vérifications        // 100 lignes de calcul des remises et taxes        // 80 lignes d'envoi d'email et de sauvegarde en BDD}

Après la refactorisation :

public void processInvoice(Invoice invoice) {    validateInvoice(invoice);    double total = calculateTotal(invoice);    saveInvoice(invoice, total);    sendConfirmationEmail(invoice);}

private void validateInvoice(Invoice invoice) {    if (invoice.getCustomer() == null) throw new IllegalArgumentException();    if (invoice.getItems().isEmpty()) throw new IllegalStateException();}

private double calculateTotal(Invoice invoice) {    // logique de calcul    return invoice.getItems().stream()            .mapToDouble(Item::getPrice)            .sum();}

private void saveInvoice(Invoice invoice, double total) {    // sauvegarde}

private void sendConfirma