Java业务解耦案例如何优化

本文目录导读：

1. 事件驱动模式解耦
2. 策略模式解耦支付
3. 模板方法模式解耦审批流程
4. 使用Spring事件机制（推荐）
5. 核心优化原则

我来分享几个Java业务解耦的实战案例及优化方案。

事件驱动模式解耦

优化前：硬编码调用

@Service
public class OrderService {
    @Autowired
    private NotificationService notificationService;
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private CouponService couponService;
    public void createOrder(Order order) {
        // 业务逻辑
        notificationService.sendNotification(order);
        inventoryService.deductStock(order);
        couponService.useCoupon(order);
        // 后续新增业务还需要改这里
    }
}

优化后：事件驱动

// 定义事件
public class OrderCreatedEvent {
    private Order order;
    // getter/setter
}
// 事件发布器
@Component
public class EventBus {
    private List<EventHandler> handlers = new ArrayList<>();
    public void register(EventHandler handler) {
        handlers.add(handler);
    }
    public void publish(OrderCreatedEvent event) {
        handlers.forEach(handler -> handler.handle(event));
    }
}
// 事件处理器接口
public interface EventHandler {
    void handle(OrderCreatedEvent event);
}
// 各自实现
@Component
public class NotificationHandler implements EventHandler {
    @Override
    public void handle(OrderCreatedEvent event) {
        // 发送通知逻辑
    }
}
@Component
public class InventoryHandler implements EventHandler {
    @Override
    public void handle(OrderCreatedEvent event) {
        // 扣减库存逻辑
    }
}
// 业务代码
@Service
public class OrderService {
    @Autowired
    private EventBus eventBus;
    public void createOrder(Order order) {
        // 核心业务逻辑
        eventBus.publish(new OrderCreatedEvent(order));
    }
}

策略模式解耦支付

优化前：大量if-else

@Service
public class PaymentService {
    public void pay(String channel, Order order) {
        if ("alipay".equals(channel)) {
            // 支付宝支付逻辑
        } else if ("wechat".equals(channel)) {
            // 微信支付逻辑
        } else if ("union".equals(channel)) {
            // 银联支付逻辑
        }
        // 新增支付方式还要加else if
    }
}

优化后：策略模式

// 支付策略接口
public interface PaymentStrategy {
    boolean support(String channel);
    void pay(Order order);
}
// 支付宝实现
@Component
public class AliPayStrategy implements PaymentStrategy {
    @Override
    public boolean support(String channel) {
        return "alipay".equals(channel);
    }
    @Override
    public void pay(Order order) {
        // 支付宝支付
    }
}
// 微信实现
@Component
public class WechatPayStrategy implements PaymentStrategy {
    @Override
    public boolean support(String channel) {
        return "wechat".equals(channel);
    }
    @Override
    public void pay(Order order) {
        // 微信支付
    }
}
// 策略选择器
@Component
public class PaymentStrategySelector {
    @Autowired
    private List<PaymentStrategy> strategies;
    public PaymentStrategy select(String channel) {
        return strategies.stream()
            .filter(s -> s.support(channel))
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("不支持的支付渠道"));
    }
}
// 业务代码
@Service
public class PaymentService {
    @Autowired
    private PaymentStrategySelector selector;
    public void pay(String channel, Order order) {
        PaymentStrategy strategy = selector.select(channel);
        strategy.pay(order);
    }
}

模板方法模式解耦审批流程

// 审批模板
public abstract class ApprovalTemplate {
    // 模板方法，定义流程骨架
    public final void process(ApprovalContext context) {
        // 1. 校验数据
        validate(context);
        // 2. 具体审批逻辑（子类实现）
        doApprove(context);
        // 3. 发送通知
        notify(context);
        // 4. 记录日志
        log(context);
    }
    protected abstract void validate(ApprovalContext context);
    protected abstract void doApprove(ApprovalContext context);
    private void notify(ApprovalContext context) {
        // 通用通知逻辑
    }
    private void log(ApprovalContext context) {
        // 通用日志记录
    }
}
// 具体审批实现
@Component
public class LeaveApproval extends ApprovalTemplate {
    @Override
    protected void validate(ApprovalContext context) {
        // 请假审批校验
    }
    @Override
    protected void doApprove(ApprovalContext context) {
        // 请假审批逻辑
    }
}

使用Spring事件机制（推荐）

// 事件定义
public class OrderCreatedEvent extends ApplicationEvent {
    private Order order;
    public OrderCreatedEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }
}
// 发布事件
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;
    @Transactional
    public void createOrder(Order order) {
        // 核心业务
        publisher.publishEvent(new OrderCreatedEvent(this, order));
    }
}
// 监听事件（可以放在不同模块）
@Component
public class OrderEventListener {
    @EventListener
    @Async  // 异步处理
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 处理通知、库存等
    }
    @EventListener
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleAfterCommit(OrderCreatedEvent event) {
        // 事务提交后的处理
    }
}

核心优化原则

1. 单一职责：每个类只负责一个功能
2. 开闭原则：对扩展开放，对修改关闭
3. 依赖倒置：面向接口编程
4. 最少知识：类之间减少直接依赖

通过这些模式,可以显著提升代码的可维护性和可扩展性，根据实际业务场景选择合适的解耦方式。