以下是一个 Spring Boot 中 if 嵌套过多的示例代码，以及优化后的代码：

优化之前：普通代码样例

@Service
public class OrderService {

    public void processOrder(Order order) {
        if (order.getStatus() == OrderStatus.PENDING) {
            if (order.getAmount() > 1000) {
                // 执行一些逻辑
                System.out.println("High amount pending order");
            } else {
                // 执行其他逻辑
                System.out.println("Low amount pending order");
            }
        } else if (order.getStatus() == OrderStatus.COMPLETED) {
            if (order.getCustomerRating() > 4) {
                // 执行一些逻辑
                System.out.println("High rated completed order");
            } else {
                // 执行其他逻辑
                System.out.println("Low rated completed order");
            }
        }
    }
}

优化之后：代码结构

创建一个策略接口：

interface OrderProcessingStrategy {
    void process(Order order);
}

针对不同状态和条件创建具体的策略实现类：

class PendingOrderWithHighAmountStrategy implements OrderProcessingStrategy {
    @Override
    public void process(Order order) {
        System.out.println("High amount pending order");
    }
}

class PendingOrderWithLowAmountStrategy implements OrderProcessingStrategy {
    @Override
    public void process(Order order) {
        System.out.println("Low amount pending order");
    }
}

class CompletedOrderWithHighRatingStrategy implements OrderProcessingStrategy {
    @Override
    public void process(Order order) {
        System.out.println("High rated completed order");
    }
}

class CompletedOrderWithLowRatingStrategy implements OrderProcessingStrategy {
    @Override
    public void process(Order order) {
        System.out.println("Low rated completed order");
    }
}

在服务类中使用策略模式：

@Service
public class OrderService {

    private Map<OrderStatus, Map<Boolean, OrderProcessingStrategy>> strategyMap;

    @Autowired
    public OrderService(List<OrderProcessingStrategy> strategies) {
        strategyMap = new HashMap<>();
        for (OrderProcessingStrategy strategy : strategies) {
            if (strategy instanceof PendingOrderWithHighAmountStrategy) {
                strategyMap.computeIfAbsent(OrderStatus.PENDING, k -> new HashMap<>()).put(true, strategy);
            } else if (strategy instanceof PendingOrderWithLowAmountStrategy) {
                strategyMap.computeIfAbsent(OrderStatus.PENDING, k -> new HashMap<>()).put(false, strategy);
            } else if (strategy instanceof CompletedOrderWithHighRatingStrategy) {
                strategyMap.computeIfAbsent(OrderStatus.COMPLETED, k -> new HashMap<>()).put(true, strategy);
            } else if (strategy instanceof CompletedOrderWithLowRatingStrategy) {
                strategyMap.computeIfAbsent(OrderStatus.COMPLETED, k -> new HashMap<>()).put(false, strategy);
            }
        }
    }

    public void processOrder(Order order) {
        Map<Boolean, OrderProcessingStrategy> subMap = strategyMap.get(order.getStatus());
        if (subMap!= null) {
            boolean condition = (order.getStatus() == OrderStatus.PENDING)? order.getAmount() > 1000 : order.getCustomerRating() > 4;
            OrderProcessingStrategy strategy = subMap.get(condition);
            if (strategy!= null) {
                strategy.process(order);
            }
        }
    }
}

这样通过策略模式将复杂的条件判断和处理逻辑分离，减少了 if 嵌套，使代码更具可读性和可维护性。