面试题：基于Java和SOLID原则优化复杂业务逻辑系统

重构前的问题

假设核心业务模块是订单处理模块。在重构前，该模块代码可能存在以下问题：

单一职责原则（SRP）违背：一个类可能既负责订单数据的验证，又负责订单状态的更新，还处理与支付系统的交互，导致类的职责过多，代码臃肿且难以维护。例如：

public class OrderProcessor {
    public void processOrder(Order order) {
        // 订单数据验证
        if (!isValid(order)) {
            throw new IllegalArgumentException("订单数据无效");
        }
        // 更新订单状态
        updateOrderStatus(order, "PROCESSING");
        // 调用支付系统
        PaymentSystem.processPayment(order.getAmount());
    }

    private boolean isValid(Order order) {
        // 验证逻辑
        return true;
    }

    private void updateOrderStatus(Order order, String status) {
        // 更新状态逻辑
    }
}

开闭原则（OCP）违背：如果要添加新的订单处理逻辑，比如订单处理前需要记录日志，可能需要直接修改 processOrder 方法，不符合开闭原则。
依赖倒置原则（DIP）违背：订单处理模块可能直接依赖具体的支付系统实现类，使得代码难以测试和替换支付系统。例如直接使用 PaymentSystem 类，而不是通过接口。

重构思路

单一职责原则（SRP）：将不同职责分离到不同的类中。订单数据验证、订单状态更新、支付处理分别放到不同类中。
开闭原则（OCP）：通过抽象和接口，使得新的订单处理逻辑可以通过实现接口来添加，而不修改原有代码。
依赖倒置原则（DIP）：依赖抽象接口，而不是具体实现类。例如，支付处理依赖支付接口，而不是具体的支付系统实现类。

重构后的代码结构

订单验证类

public class OrderValidator {
    public boolean isValid(Order order) {
        // 验证逻辑
        return true;
    }
}

订单状态更新类

public class OrderStatusUpdater {
    public void updateOrderStatus(Order order, String status) {
        // 更新状态逻辑
    }
}

支付接口和实现类

public interface PaymentProcessor {
    void processPayment(double amount);
}

public class DefaultPaymentProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // 支付处理逻辑
    }
}

订单处理类

public class OrderProcessor {
    private OrderValidator validator;
    private OrderStatusUpdater updater;
    private PaymentProcessor paymentProcessor;

    public OrderProcessor(OrderValidator validator, OrderStatusUpdater updater, PaymentProcessor paymentProcessor) {
        this.validator = validator;
        this.updater = updater;
        this.paymentProcessor = paymentProcessor;
    }

    public void processOrder(Order order) {
        if (!validator.isValid(order)) {
            throw new IllegalArgumentException("订单数据无效");
        }
        updater.updateOrderStatus(order, "PROCESSING");
        paymentProcessor.processPayment(order.getAmount());
    }
}

使用示例

public class Main {
    public static void main(String[] args) {
        OrderValidator validator = new OrderValidator();
        OrderStatusUpdater updater = new OrderStatusUpdater();
        PaymentProcessor paymentProcessor = new DefaultPaymentProcessor();
        OrderProcessor processor = new OrderProcessor(validator, updater, paymentProcessor);
        Order order = new Order();
        processor.processOrder(order);
    }
}

这样重构后，每个类职责单一，符合开闭原则和依赖倒置原则，提高了代码的可维护性、可扩展性和可读性。

星途面试题库

面试题：基于Java和SOLID原则优化复杂业务逻辑系统

知识考点

面试题答案

重构前的问题

重构思路

重构后的代码结构