Legacy-Methode
  -> Validierung extrahieren
  -> Preisregeln extrahieren
  -> Versand extrahieren
  -> Steuer extrahieren
  -> Nebenwirkungen hinter Ports legen
  -> neuen Application Service parallel betreiben
  -> Parity Tests gegen Legacy-Verhalten laufen lassen

if (request.segment() == CustomerSegment.BLOCKED) return "REJECTED|CUSTOMER_BLOCKED";
if (request.lines().isEmpty()) return "REJECTED|EMPTY_ORDER";

if (afterDiscount.amount().compareTo(new BigDecimal("250.00")) >= 0 && request.shippingCountry() != Country.US) shipping = Money.eur("0");
if (weight > 10_000) shipping = shipping.add(Money.eur("12.00"));

ValidationResult validation = validationService.validate(request);
if (!validation.ok()) {
    auditPort.record(request.orderId(), "ORDER_REJECTED", validation.violations().toString());
    return OrderProcessingResult.rejected(request.orderId(), validation.violations());
}

public interface DiscountPolicy {
    Money discountFor(PricingContext context);
    String name();
}

public final class VipDiscountPolicy implements DiscountPolicy {
    @Override public Money discountFor(PricingContext context) {
        if (context.segment() != CustomerSegment.VIP) return Money.eur("0");
        return context.subtotal().multiply(new BigDecimal("0.10"));
    }
}

public Money calculate(OrderRequest request, Money afterDiscount) {
    int weight = request.lines().stream().mapToInt(OrderLine::totalWeight).sum();
    boolean onlyDigital = request.lines().stream().allMatch(OrderLine::digital);
    if (onlyDigital) return Money.eur("0");
    ...
}

public interface PaymentPort {
    PaymentDecision authorize(String orderId, String customerId, Money amount);
}

ValidationResult validation = validationService.validate(request);
PriceBreakdown price = pricingEngine.calculate(request);
PaymentDecision payment = paymentPort.authorize(request.orderId(), request.customerId(), price.total());
String invoiceId = invoicePort.createInvoice(request.orderId(), price);

public record ParitySnapshot(String scenarioId, String legacyResult, String refactoredResult) {
    public boolean equivalentEnough() {
        boolean legacyAccepted = legacyResult.startsWith("ACCEPTED");
        boolean refAccepted = refactoredResult.startsWith("true|");
        if (legacyAccepted != refAccepted) return false;
        if (legacyAccepted) return legacyResult.contains(scenarioId) && refactoredResult.contains(scenarioId);
        return true;
    }
}

long forbidden = Files.walk(root)
.filter(p -> p.toString().endsWith(".java"))
.filter(p -> !p.getFileName().toString().contains("LegacyOrderProcessor"))
.filter(p -> Files.readString(p).contains("new LegacyOrderProcessor"))
.count();

package com.example.legacy.Kapitel;
import java.math.BigDecimal;
// Absichtlich unangenehmer Legacy-Code: mehrere Verantwortungen, Seiteneffekte und fachliche Regeln in einer Methode.
public final class LegacyOrderProcessor {
    public String process(OrderRequest request) {
        if (request.segment() == CustomerSegment.BLOCKED) return "REJECTED|CUSTOMER_BLOCKED";
        if (request.lines().isEmpty()) return "REJECTED|EMPTY_ORDER";
        if (request.segment() == CustomerSegment.B2B && request.shippingCountry() != Country.US && (request.vatId() == null || request.vatId().isBlank())) {
            return "REJECTED|VAT_ID_REQUIRED";
        }
    Money subtotal = Money.eur("0");
    int weight = 0;
    boolean onlyDigital = true;
    for (OrderLine line : request.lines()) {
        if (line.quantity() > 100) return "REJECTED|LINE_QTY_LIMIT";
        subtotal = subtotal.add(line.lineTotal());
        weight += line.totalWeight();
        onlyDigital = onlyDigital && line.digital();
    }
Money discount = Money.eur("0");
if (request.segment() == CustomerSegment.VIP) discount = discount.add(subtotal.multiply(new BigDecimal("0.10")));
if (request.couponCode() != null && request.channel() != OrderChannel.PARTNER_PORTAL) {
    if (request.couponCode().equals("SAVE5")) discount = discount.add(Money.eur("5"));
    if (request.couponCode().equals("WELCOME15")) discount = discount.add(subtotal.multiply(new BigDecimal("0.15")));
}
if (request.segment() == CustomerSegment.B2B && subtotal.amount().compareTo(new BigDecimal("1000.00")) >= 0) {
    discount = discount.add(subtotal.multiply(new BigDecimal("0.07")));
}
if (discount.greaterThan(subtotal)) discount = subtotal;
Money afterDiscount = subtotal.subtract(discount);
Money shipping = Money.eur("0");
if (!onlyDigital) {
    shipping = switch (request.shippingCountry()) {
        case AT, DE -> Money.eur("6.90");
        case CH -> Money.eur("14.90");
        case US -> Money.eur("29.90");
    };
if (afterDiscount.amount().compareTo(new BigDecimal("250.00")) >= 0 && request.shippingCountry() != Country.US) shipping = Money.eur("0");
if (weight > 10_000) shipping = shipping.add(Money.eur("12.00"));
}
Money taxableBase = afterDiscount.add(shipping);
Money tax;
if (request.segment() == CustomerSegment.B2B && request.vatId() != null && request.shippingCountry() != Country.AT) tax = Money.eur("0");
else {
    BigDecimal rate = switch (request.shippingCountry()) {
        case AT -> new BigDecimal("0.20");
        case DE -> new BigDecimal("0.19");
        case CH -> new BigDecimal("0.081");
        case US -> BigDecimal.ZERO;
    };
tax = taxableBase.multiply(rate);
}
Money total = taxableBase.add(tax);
if (total.amount().compareTo(new BigDecimal("2000.00")) > 0) return "REJECTED|LIMIT_EXCEEDED|" + total;
return "ACCEPTED|" + request.orderId() + "|" + total + "|INV-" + request.orderId();
}
}

package com.example.legacy.Kapitel;
// Pattern: Service Layer - kapselt fachliche Validierung ausserhalb der Monster-Methode.
public final class OrderValidationService {
    public ValidationResult validate(OrderRequest request) {
        ValidationResult result = new ValidationResult();
        if (request.segment() == CustomerSegment.BLOCKED) result.add("CUSTOMER_BLOCKED", "blocked customers cannot order");
        if (request.lines().isEmpty()) result.add("EMPTY_ORDER", "order must contain at least one line");
        if (request.lines().size() > 50) result.add("TOO_MANY_LINES", "manual review required for more than 50 lines");
        if (request.channel() == OrderChannel.PARTNER_PORTAL && request.couponCode() != null) {
            result.add("PARTNER_COUPON_NOT_ALLOWED", "partner orders cannot use retail coupons");
        }
    if (request.segment() == CustomerSegment.B2B && request.shippingCountry() != Country.US && blank(request.vatId())) {
        result.add("VAT_ID_REQUIRED", "B2B orders in EU/CH require a VAT id");
    }
for (OrderLine line : request.lines()) {
    if (line.quantity() > 100) result.add("LINE_QTY_LIMIT", "line quantity too high for " + line.sku());
    if (!line.unitPrice().isPositive()) result.add("PRICE_NOT_POSITIVE", "unit price must be positive for " + line.sku());
}
return result;
}
private static boolean blank(String s) {
    return s == null || s.isBlank();
}
}

package com.example.legacy.Kapitel;
import java.util.List;
// Pattern: Composite Strategy - kombiniert mehrere Rabattstrategien kontrolliert.
public final class PricingEngine {
    private final List<DiscountPolicy> policies;
    private final ShippingCalculator shippingCalculator;
    private final TaxCalculator taxCalculator;
    public PricingEngine(List<DiscountPolicy> policies, ShippingCalculator shippingCalculator, TaxCalculator taxCalculator) {
        this.policies = List.copyOf(policies);
        this.shippingCalculator = shippingCalculator;
        this.taxCalculator = taxCalculator;
    }
public PriceBreakdown calculate(OrderRequest request) {
    Money subtotal = request.lines().stream().map(OrderLine::lineTotal).reduce(Money.eur("0"), Money::add);
    PricingContext context = new PricingContext(request.segment(), request.channel(), request.shippingCountry(), request.couponCode(), subtotal);
    Money discount = policies.stream().map(p -> p.discountFor(context)).reduce(Money.eur("0"), Money::add);
    if (discount.greaterThan(subtotal)) discount = subtotal;
    Money shipping = shippingCalculator.calculate(request, subtotal.subtract(discount));
    Money taxableBase = subtotal.subtract(discount).add(shipping);
    Money tax = taxCalculator.calculate(request, taxableBase);
    Money total = taxableBase.add(tax);
    return new PriceBreakdown(subtotal, discount, shipping, tax, total);
}
}

package com.example.legacy.Kapitel;
// Pattern: Facade/Application Service - orchestriert extrahierte Verantwortungen ohne fachliche Details zu mischen.
public final class RefactoredOrderApplicationService {
    private final OrderValidationService validationService;
    private final PricingEngine pricingEngine;
    private final PaymentPort paymentPort;
    private final InvoicePort invoicePort;
    private final AuditPort auditPort;
    public RefactoredOrderApplicationService(OrderValidationService validationService, PricingEngine pricingEngine, PaymentPort paymentPort, InvoicePort invoicePort, AuditPort auditPort) {
        this.validationService = validationService;
        this.pricingEngine = pricingEngine;
        this.paymentPort = paymentPort;
        this.invoicePort = invoicePort;
        this.auditPort = auditPort;
    }
public OrderProcessingResult process(OrderRequest request) {
    ValidationResult validation = validationService.validate(request);
    if (!validation.ok()) {
        auditPort.record(request.orderId(), "ORDER_REJECTED", validation.violations().toString());
        return OrderProcessingResult.rejected(request.orderId(), validation.violations());
    }
PriceBreakdown price = pricingEngine.calculate(request);
PaymentDecision payment = paymentPort.authorize(request.orderId(), request.customerId(), price.total());
if (!payment.approved()) {
    auditPort.record(request.orderId(), "PAYMENT_DECLINED", payment.reason());
    return OrderProcessingResult.paymentDeclined(request.orderId(), price, payment.reason());
}
String invoiceId = invoicePort.createInvoice(request.orderId(), price);
auditPort.record(request.orderId(), "ORDER_ACCEPTED", invoiceId + " " + price.compact());
return OrderProcessingResult.accepted(request.orderId(), price, invoiceId);
}
}

package com.example.legacy.Kapitel;
import java.util.ArrayList;
import java.util.List;
public final class ResponsibilityRefactoringTestRunner {
    public static void main(String[] args) {
        LegacyOrderProcessor legacy = new LegacyOrderProcessor();
        List<ParitySnapshot> snapshots = new ArrayList<>();
        for (OrderRequest request : OrderScenarioCatalog.scenarios()) {
            FakeInvoiceAdapter invoice = new FakeInvoiceAdapter();
            CollectingAuditAdapter audit = new CollectingAuditAdapter();
            RefactoredOrderApplicationService service = RefactoringFactory.create(invoice, audit);
            String legacyResult = legacy.process(request);
            String refactored = service.process(request).compact();
            ParitySnapshot snapshot = new ParitySnapshot(request.orderId(), legacyResult, refactored);
            snapshots.add(snapshot);
            if (!snapshot.equivalentEnough()) throw new AssertionError("parity failed: " + snapshot);
        }
    testValidationService();
    testPricingBreakdown();
    testShippingAndTax();
    System.out.println("Kapitel snapshots=" + snapshots.size());
}
private static void testValidationService() {
    ValidationResult result = new OrderValidationService().validate(OrderScenarioCatalog.blockedCustomer());
    if (result.ok()) throw new AssertionError("blocked customer must be rejected");
}
private static void testPricingBreakdown() {
    PricingEngine engine = new PricingEngine(java.util.List.of(new VipDiscountPolicy(), new CouponDiscountPolicy(), new B2BVolumeDiscountPolicy()), new ShippingCalculator(), new TaxCalculator());
    PriceBreakdown price = engine.calculate(OrderScenarioCatalog.webVipWithCoupon());
    if (!price.discount().isPositive()) throw new AssertionError("VIP/coupon discount expected");
    if (!price.total().isPositive()) throw new AssertionError("total expected");
}
private static void testShippingAndTax() {
    PricingEngine engine = new PricingEngine(java.util.List.of(), new ShippingCalculator(), new TaxCalculator());
    PriceBreakdown price = engine.calculate(OrderScenarioCatalog.heavySwissShipment());
    if (!price.tax().isPositive()) throw new AssertionError("CH tax expected");
    if (!price.total().isPositive()) throw new AssertionError("CH total expected");
}
}