深入实战工厂模式与观察者模式：工厂模式与观察者模式在电商系统中的应用

引言

作为Java高级开发者，我经常需要在Spring Boot项目中应用设计模式来解决复杂的业务问题。今天我将分享工厂模式和观察者模式在电商系统中的实际应用，这些模式比常见的责任链和策略模式更有趣且实用。

1. 工厂模式在支付系统中的应用

在电商系统中，我们经常需要对接多种支付渠道（支付宝、微信支付、银联等），工厂模式非常适合这种场景。

业务场景

我们需要根据用户选择的支付方式创建不同的支付处理器，每种支付方式有不同的验证、处理和通知逻辑。

代码实现

首先定义支付接口：

public interface PaymentService {
PaymentResponse pay(PaymentRequest request);
boolean supports(PaymentType type);
}

然后实现具体的支付服务：

@Service
@RequiredArgsConstructor
public class AlipayService implements PaymentService {
private final AlipayConfig config;

@Override
public PaymentResponse pay(PaymentRequest request) {
// 支付宝特定的支付逻辑
return new PaymentResponse("ALIPAY_SUCCESS", "支付宝支付成功");
}

@Override
public boolean supports(PaymentType type) {
return PaymentType.ALIPAY == type;
}
}

@Service
@RequiredArgsConstructor
public class WechatPayService implements PaymentService {
private final WechatConfig config;

@Override
public PaymentResponse pay(PaymentRequest request) {
// 微信支付特定的支付逻辑
return new PaymentResponse("WECHAT_SUCCESS", "微信支付成功");
}

@Override
public boolean supports(PaymentType type) {
return PaymentType.WECHAT == type;
}
}

创建支付工厂：

@Service
@RequiredArgsConstructor
public class PaymentServiceFactory {
private final List<PaymentService> paymentServices;

public PaymentService getPaymentService(PaymentType type) {
return paymentServices.stream()
.filter(service -> service.supports(type))
.findFirst()
.orElseThrow(() -> new IllegalArgumentException("不支持的支付类型"));
}
}

在控制器中使用：

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/payment")
public class PaymentController {
private final PaymentServiceFactory paymentServiceFactory;

@PostMapping
public PaymentResponse pay(@RequestBody PaymentRequest request) {
PaymentService paymentService = paymentServiceFactory.getPaymentService(request.getType());
return paymentService.pay(request);
}
}

优势分析

2. 观察者模式在订单状态变更中的应用

电商系统中，订单状态变更时需要触发多种操作（发送通知、更新库存、记录日志等），观察者模式非常适合这种一对多的依赖关系。

业务场景

当订单状态发生变化时，需要：

代码实现

定义订单事件：

public class OrderEvent {
private final Order order;
private final OrderStatus oldStatus;
private final OrderStatus newStatus;
private final LocalDateTime eventTime;

// 构造器、getter省略
}

定义事件发布者：

@Service
@RequiredArgsConstructor
public class OrderEventPublisher {
private final ApplicationEventPublisher eventPublisher;

public void publishOrderStatusChange(Order order, OrderStatus oldStatus, OrderStatus newStatus) {
OrderEvent event = new OrderEvent(order, oldStatus, newStatus, LocalDateTime.now());
eventPublisher.publishEvent(event);
}
}

实现观察者（使用Spring的事件机制）：

@Component
@RequiredArgsConstructor
public class OrderNotificationListener {
private final NotificationService notificationService;

@EventListener
@Async
public void handleOrderEvent(OrderEvent event) {
if (event.getNewStatus() == OrderStatus.PAID) {
notificationService.sendPaymentSuccessNotification(event.getOrder());
} else if (event.getNewStatus() == OrderStatus.SHIPPED) {
notificationService.sendShippingNotification(event.getOrder());
}
// 其他状态处理…
}
}

@Component
@RequiredArgsConstructor
public class InventoryUpdateListener {
private final InventoryService inventoryService;

@EventListener
@Async
public void handleOrderCancellation(OrderEvent event) {
if (event.getNewStatus() == OrderStatus.CANCELLED &&
event.getOldStatus() == OrderStatus.PAID) {
// 恢复库存
inventoryService.restoreInventory(event.getOrder().getItems());
}
}
}

@Component
@RequiredArgsConstructor
public class OrderLogListener {
private final OrderLogService logService;

@EventListener
public void logOrderStatusChange(OrderEvent event) {
logService.logStatusChange(
event.getOrder().getId(),
event.getOldStatus(),
event.getNewStatus(),
event.getEventTime()
);
}
}

在订单服务中使用：

@Service
@RequiredArgsConstructor
@Transactional
public class OrderService {
private final OrderRepository orderRepository;
private final OrderEventPublisher eventPublisher;

public void updateOrderStatus(Long orderId, OrderStatus newStatus) {
Order order = orderRepository.findById(orderId)
.orElseThrow(() -> new OrderNotFoundException(orderId));

OrderStatus oldStatus = order.getStatus();
order.setStatus(newStatus);
orderRepository.save(order);

// 发布状态变更事件
eventPublisher.publishOrderStatusChange(order, oldStatus, newStatus);
}
}

优势分析

总结

工厂模式和观察者模式在Spring Boot项目中有着广泛的应用场景：

这两种模式都能显著提高代码的可维护性和扩展性，是Spring Boot开发者工具箱中的重要组成部分。在实际项目中，我们应该根据业务场景灵活选择和应用这些模式，而不是生搬硬套。