Refactoring von Legacy-Code in Java: Schritt-für-Schritt-Anleitung von A bis Z

Refactoring von Legacy-Code in Java: von A bis Z

Die Arbeit mit vererbtem (Legacy) Code in Java ist eine Herausforderung, der jeder Entwickler begegnet. Alter Code enthält oft keine Tests, verwendet veraltete Muster und ist schwer zu ändern. Eine vollständige Neuschreibung des Projekts ist jedoch nicht immer die beste Lösung. In diesem Artikel betrachten wir einen bewährten Ansatz für das Refactoring von Legacy-Code: von der Analyse bis zur Implementierung von Änderungen, mit konkreten Beispielen in Java.

1. Diagnose und Vorbereitung: Bevor Sie den Code berühren

Der erste und wichtigste Schritt ist zu verstehen, womit Sie es zu tun haben. Beginnen Sie das Refactoring nicht mit chaotischen Korrekturen von Zeilen. Stattdessen:

• Abhängigkeitskarte: Visualisieren Sie, welche Klassen von welchen abhängen. Verwenden Sie Tools wie IntelliJ IDEA Dependency Viewer oder JDepend.
• Test-Wrapper (Characterization Tests): Schreiben Sie Tests, die das aktuelle Verhalten des Codes festhalten. Das ist Ihr Sicherheitsnetz.
• Einstiegspunkte identifizieren: Bestimmen Sie, welche Methoden am häufigsten aufgerufen werden und wo die wichtigsten Änderungen stattfinden.

Beispiel eines einfachen Characterization-Tests für eine Methode, die refactored werden soll:

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();        // Aktuelles Verhalten festhalten        int result = calc.calculate(10, 5, "add");        assertEquals(15, result, "Aktuelles Verhalten: Addition");                result = calc.calculate(10, 5, "sub");        assertEquals(5, result, "Aktuelles Verhalten: Subtraktion");    }}

Ein solcher Test prüft nicht die Korrektheit der Logik im absoluten Sinne – er hält lediglich fest, was der Code derzeit tut. Nach dem Refactoring muss der Test bestehen, sonst haben Sie das Verhalten geändert.

2. Strategie des "chirurgischen" Refactorings: Methode für Methode

Der Versuch, eine ganze Klasse auf einmal zu refactoren, ist der sichere Weg zu Bugs. Verwenden Sie den Ansatz der "Kampfarchäologie" (Combat Archaeology):

• Wählen Sie eine Methode oder eine kleine Gruppe zusammenhängender Methoden aus.
• Schreiben Sie Characterization-Tests dafür (falls nicht vorhanden).
• Wenden Sie eine einzelne Refactoring-Technik an (z.B. Extract Method oder Rename Variable).
• Führen Sie die Tests aus. Sie müssen bestehen.
• Committen Sie die Änderungen mit einer verständlichen Beschreibung.

Beispiel: Refactoring einer Methode mit "magischen Zahlen" und einer langen Parameterliste.

Ursprünglicher Code (schlecht):

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

Nach dem Refactoring (verbessert):

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