📖  《代码重构的独孤九剑：如何优雅改造祖传屎山代码》

// 示例：通过自定义规则识别典型问题代码
public class LegacyCodeDetector {
    void detectSmells(Project project) {
        new LongMethodRule().apply(project);  // 方法过长检测
        new CyclomaticComplexityRule().apply(project); // 圈复杂度检测
    }
}

// 重构前：贫血模型的Service类
public class OrderService {
    public void createOrder(OrderDTO dto) {
        // 校验逻辑（200行）
        // 库存计算（300行）
        // 优惠券核销（400行） 
    }
}

// 重构后：领域模型显性化
public class Order {
    private OrderId id;
    private List<OrderItem> items;
    private Coupon coupon;

    public void applyCoupon(Coupon coupon) {
        if (!coupon.isValid(items)) { 
            throw new InvalidCouponException();
        }
        this.coupon = coupon;
    }
    
    @DomainService
    public class OrderCalculator {
        public Money calculateTotal() {
            return items.stream()
                .map(item -> item.getPrice().multiply(item.getQuantity()))
                .reduce(Money.ZERO, Money::add)
                .subtract(coupon.getDiscount());
        }
    }
}

graph LR
    A[旧系统] -->|原始数据| B(防腐层Adapter)
    B -->|领域对象| C[新领域模型]
    C -->|标准化数据| D[基础设施层]

// 重构前：直接调用下游服务（紧耦合）
public class UserService {
    private OrderService orderService; // 直接依赖
    
    public List<Order> getOrders(Long userId) {
        return orderService.queryByUser(userId); // 跨领域调用
    }
}

// 重构后：依赖倒置+事件驱动
public interface UserEventPublisher {
    void publishUserAction(UserEvent event); // 抽象接口
}

@Service
public class OrderEventHandler {
    @EventListener // Spring事件监听
    public void handleUserAction(UserEvent event) {
        // 解耦后的处理逻辑
    }
}

graph TD
    A[核心领域] --> B(通用工具包)
    A --> C(第三方适配层)
    B --> D[基础设施]
    C -->|防腐处理| E((外部API))

<!-- ArchUnit 依赖约束示例 -->
<dependencyCheck>
    <rule>禁止基础设施层反向调用领域层</rule>
    <rule>限界上下文之间只能通过API通信</rule>
</dependencyCheck>

public class PaymentService {
    public boolean pay(User user, BigDecimal amount) {
        // 200行混合逻辑：风控校验+支付渠道路由+记账
        if (user.getBalance().subtract(amount).doubleValue() < 0) {
            throw new RuntimeException("余额不足"); // 直接抛RuntimeException
        }
        // 直接调用第三方支付API（无Mock）
    }
}

class PaymentServiceTest {
    @Mock PaymentGateway gateway;
    @InjectMocks PaymentService service;

    @Test
    @DisplayName("当用户余额充足时，支付成功")
    void should_succeed_when_balance_enough() {
        User user = User.builder().balance(new BigDecimal("100.00")).build();
        service.pay(user, new BigDecimal("50.00"));
        verify(gateway).execute(any()); // 验证支付网关调用
    }

    @Test
    @DisplayName("当余额不足时，抛出BusinessException")
    void should_throw_exception_when_balance_insufficient() {
        User user = User.builder().balance(new BigDecimal("30.00")).build();
        assertThrows(BusinessException.class, 
            () -> service.pay(user, new BigDecimal("50.00")));
    }
}

// 重构后的领域对象
public class Payment {
    public void validateBalance(BigDecimal amount) {
        if (this.balance.compareTo(amount) < 0) {
            throw new BusinessException("INSUFFICIENT_BALANCE"); // 明确业务异常
        }
    }
}

测试金字塔资源配比
▲
│                 
│        ╭┈┈┈ E2E(10%) ┈┈┈╮
│     ╭┈┈ Integration(20%) ┈╮
│  ╭┈┈┈┈┈ Unit Tests(70%) ┈┈┈╮
└──────────────────────────────▶

@Test  
@DisplayName("Given用户有未支付订单 When尝试再次下单 Then抛出重复订单异常")  
void should_throw_duplicate_order_exception() { ... }  

工具化重构五步流
┌────────────────┐
│ 1. IDE全局搜索   │
│   'new Date()'  │
└───────┬─────────┘
        ↓
┌────────────────┐
│ 2. 创建迁移类    │
│   DateUtils    │
└───────┬─────────┘
        ↓
┌────────────────┐
│ 3. 自动替换     │
│   Alt+Enter    │
└───────┬─────────┘
        ↓
┌────────────────┐
│ 4. 静态分析     │
│   时区风险检测  │
└───────┬─────────┘
        ↓
┌────────────────┐
│ 5. 补充测试     │
│   单元测试覆盖  │
└────────────────┘

// 重构前：脆弱的Date使用
public class Order {
    private Date createTime; // 可序列化问题
    
    public boolean isExpired() {
        return new Date().after(this.createTime); // 隐式系统时区
    }
}

// 重构后：线程安全的时间处理
public class DateUtils {
    public static LocalDateTime now() {
        return LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
    }
}

public class Order {
    private LocalDateTime createTime;
    
    public boolean isExpired() {
        return DateUtils.now().isAfter(createTime);
    }
}