架构-设计模式应用规范
大约 4 分钟
架构-设计模式应用规范
业务驱动的设计模式实战
电商订单系统中的模式应用场景
以电商订单处理为核心场景，展示设计模式在实际业务中的应用：
1. 策略模式 - 支付方式处理
/**
* 支付策略接口
* 支持多种支付方式的统一抽象
*/
public interface PaymentStrategy {
PaymentResult processPayment(PaymentRequest request);
boolean supports(PaymentType type);
}
/**
* 微信支付实现
*/
@Component
public class WeChatPaymentStrategy implements PaymentStrategy {
@Override
public PaymentResult processPayment(PaymentRequest request) {
// 微信支付具体实现
return new PaymentResult(true, "微信支付成功");
}
@Override
public boolean supports(PaymentType type) {
return PaymentType.WECHAT == type;
}
}
/**
* 支付上下文 - 策略模式核心
*/
@Service
public class PaymentContext {
private final List<PaymentStrategy> strategies;
public PaymentContext(List<PaymentStrategy> strategies) {
this.strategies = strategies;
}
public PaymentResult executePayment(PaymentRequest request) {
PaymentStrategy strategy = strategies.stream()
.filter(s -> s.supports(request.getPaymentType()))
.findFirst()
.orElseThrow(() -> new UnsupportedPaymentException(
"不支持的支付方式: " + request.getPaymentType()));
return strategy.processPayment(request);
}
}2. 工厂模式 - 订单创建器
/**
* 订单工厂 - 根据业务场景创建不同类型订单
*/
@Component
public class OrderFactory {
public Order createOrder(OrderType type, CreateOrderRequest request) {
return switch (type) {
case NORMAL -> createNormalOrder(request);
case GROUP_BUYING -> createGroupBuyingOrder(request);
case PRE_SALE -> createPreSaleOrder(request);
case FLASH_SALE -> createFlashSaleOrder(request);
};
}
private Order createNormalOrder(CreateOrderRequest request) {
return Order.builder()
.type(OrderType.NORMAL)
.items(request.getItems())
.deliveryInfo(request.getDeliveryInfo())
.build();
}
private Order createFlashSaleOrder(CreateOrderRequest request) {
// 秒杀订单特殊处理：库存锁定、限购检查等
return Order.builder()
.type(OrderType.FLASH_SALE)
.items(validateFlashSaleItems(request.getItems()))
.priority(OrderPriority.HIGH)
.build();
}
}3. 观察者模式 - 订单状态变更通知
/**
* 订单事件观察者接口
*/
public interface OrderEventObserver {
void handleOrderEvent(OrderEvent event);
boolean supports(OrderEventType eventType);
}
/**
* 库存更新观察者
*/
@Component
public class InventoryUpdateObserver implements OrderEventObserver {
private final InventoryService inventoryService;
@Override
public void handleOrderEvent(OrderEvent event) {
if (event.getType() == OrderEventType.ORDER_CANCELLED) {
// 订单取消时释放库存
inventoryService.releaseInventory(event.getOrderItems());
}
}
@Override
public boolean supports(OrderEventType eventType) {
return eventType == OrderEventType.ORDER_CANCELLED
|| eventType == OrderEventType.ORDER_CONFIRMED;
}
}
/**
* 订单事件发布器
*/
@Service
public class OrderEventPublisher {
private final List<OrderEventObserver> observers;
public void publishOrderEvent(OrderEvent event) {
observers.stream()
.filter(observer -> observer.supports(event.getType()))
.forEach(observer -> observer.handleOrderEvent(event));
}
}现代设计模式最佳实践
1. 函数式编程与传统模式结合
/**
* 现代化的责任链模式 - 使用函数式接口
*/
@FunctionalInterface
public interface OrderValidationRule {
ValidationResult validate(Order order);
// 默认方法支持链式调用
default OrderValidationRule and(OrderValidationRule other) {
return order -> {
ValidationResult result = this.validate(order);
return result.isValid() ? other.validate(order) : result;
};
}
}
/**
* 订单验证服务 - 组合多个验证规则
*/
@Service
public class OrderValidationService {
// 使用函数式接口构建验证链
private final OrderValidationRule validationChain =
this::validateBasicInfo
.and(this::validateInventory)
.and(this::validatePayment)
.and(this::validateDelivery);
public ValidationResult validateOrder(Order order) {
return validationChain.validate(order);
}
private ValidationResult validateBasicInfo(Order order) {
// 基础信息验证
return ValidationResult.success();
}
private ValidationResult validateInventory(Order order) {
// 库存验证
return ValidationResult.success();
}
}2. 建造者模式的现代化应用
/**
* 复杂订单构建器 - 支持流式API
*/
public class ComplexOrderBuilder {
private Order order;
private ComplexOrderBuilder() {
this.order = new Order();
}
public static ComplexOrderBuilder newOrder() {
return new ComplexOrderBuilder();
}
public ComplexOrderBuilder withCustomer(Customer customer) {
order.setCustomer(customer);
return this;
}
public ComplexOrderBuilder addItem(Product product, int quantity) {
order.addItem(new OrderItem(product, quantity));
return this;
}
public ComplexOrderBuilder withDelivery(DeliveryInfo delivery) {
order.setDeliveryInfo(delivery);
return this;
}
public ComplexOrderBuilder applyDiscount(DiscountRule rule) {
order.applyDiscount(rule);
return this;
}
// 构建最终对象，包含业务验证
public Order build() {
validateOrder();
return order.clone(); // 防御性复制
}
private void validateOrder() {
if (order.getCustomer() == null) {
throw new IllegalStateException("订单必须指定客户");
}
if (order.getItems().isEmpty()) {
throw new IllegalStateException("订单必须包含商品");
}
}
}
// 使用示例
Order complexOrder = ComplexOrderBuilder.newOrder()
.withCustomer(customer)
.addItem(product1, 2)
.addItem(product2, 1)
.withDelivery(deliveryInfo)
.applyDiscount(vipDiscount)
.build();模式应用指导原则
1. 业务复杂度驱动模式选择
- 简单场景: 避免过度设计，直接实现
- 中等复杂度: 选择单一设计模式解决核心问题
- 高复杂度: 组合多种模式，构建清晰的架构层次
2. 团队协作中的模式使用
- 统一团队对设计模式的理解和应用标准
- 在代码审查中重点关注模式使用的合理性
- 建立模式使用文档和最佳实践库
3. 避免常见反模式
// ❌ 错误：过度使用单例模式
public class OverusedSingleton {
private static OverusedSingleton instance;
// 所有业务逻辑都放在单例中，导致测试困难
}
// ✅ 正确：使用依赖注入管理对象生命周期
@Service
public class WellDesignedService {
// Spring管理生命周期，易于测试和扩展
}总结
设计模式应该是解决实际问题的工具，而不是炫技的手段。在电商业务场景中：
核心价值：
- 提升代码可维护性和扩展性
- 促进团队协作和知识传承
- 降低系统变更成本
实施建议：
- 从业务需求出发选择合适的模式
- 结合现代Java特性优化模式实现
- 建立团队级别的模式使用规范
- 定期评估和重构现有模式应用
优秀的设计不是复杂的模式堆砌，而是恰到好处地解决业务问题。