设计模式的应用

在酒店系统模板配置的场景中，使用设计模式确实可以提升代码的可维护性和扩展性。以下是几种适合该场景的设计模式及具体实现方案：

---

一、策略模式（Strategy Pattern）

适用场景：当需要根据配置动态切换不同算法或行为时（如不同积分策略、不同同步方式）。

1. 定义策略接口

public interface OrderCompleteStrategy {
    void execute(Order order);
}

// 积分赠送策略
@Component
public class PointsRewardStrategy implements OrderCompleteStrategy {
    @Autowired UserPointsService pointsService;
    
    @Override
    public void execute(Order order) {
        pointsService.addPoints(order.getUserId(), order.getAmount());
    }
}

// 第三方系统同步策略
@Component
public class SyncSystemStrategy implements OrderCompleteStrategy {
    @Autowired RestTemplate restTemplate;
    
    @Override
    public void execute(Order order) {
        String url = configService.getOutSystemUrl();
        restTemplate.postForEntity(url, order, String.class);
    }
}

2. 策略上下文管理

@Service
public class OrderStrategyContext {
    @Autowired private SystemConfigService configService;
    @Autowired private PointsRewardStrategy pointsStrategy;
    @Autowired private SyncSystemStrategy syncStrategy;

    public void applyStrategies(Order order) {
        if (configService.needGiveOrderPoints()) {
            pointsStrategy.execute(order);
        }
        if (configService.needSyncOutSystem()) {
            syncStrategy.execute(order);
        }
    }
}

3. 业务层调用

@Service
public class OrderService {
    @Autowired private OrderStrategyContext strategyContext;

    public void completeOrder(Order order) {
        // 订单完成逻辑...
        strategyContext.applyStrategies(order);
    }
}

---

二、模板方法模式（Template Method Pattern）

适用场景：当需要固定处理流程但允许动态控制步骤执行时。

1. 定义抽象模板

public abstract class OrderProcessTemplate {
    @Autowired SystemConfigService configService;

    public final void processOrder(Order order) {
        completeOrder(order);
        if (shouldGivePoints()) {
            givePoints(order);
        }
        if (shouldSyncSystem()) {
            syncSystem(order);
        }
    }

    protected abstract void completeOrder(Order order);
    
    protected boolean shouldGivePoints() {
        return configService.needGiveOrderPoints();
    }

    protected void givePoints(Order order) {
        // 积分赠送默认实现
    }

    protected boolean shouldSyncSystem() {
        return configService.needSyncOutSystem();
    }

    protected void syncSystem(Order order) {
        // 同步系统默认实现
    }
}

2. 具体实现类

@Service
public class HotelOrderProcessor extends OrderProcessTemplate {
    @Override
    protected void completeOrder(Order order) {
        // 酒店订单完成逻辑
    }
}

---

三、责任链模式（Chain of Responsibility）

适用场景：当需要按顺序执行多个可配置的校验或处理步骤时。

1. 定义处理器接口

public interface OrderHandler {
    void handle(Order order);
    boolean isEnabled();
}

// 积分处理器
@Component
public class PointsHandler implements OrderHandler {
    @Autowired SystemConfigService configService;
    @Autowired UserPointsService pointsService;

    @Override
    public boolean isEnabled() {
        return configService.needGiveOrderPoints();
    }

    @Override
    public void handle(Order order) {
        pointsService.addPoints(order.getUserId(), order.getAmount());
    }
}

// 同步处理器
@Component
public class SyncHandler implements OrderHandler {
    @Autowired SystemConfigService configService;
    @Autowired RestTemplate restTemplate;

    @Override
    public boolean isEnabled() {
        return configService.needSyncOutSystem();
    }

    @Override
    public void handle(Order order) {
        String url = configService.getOutSystemUrl();
        restTemplate.postForEntity(url, order, String.class);
    }
}

2. 责任链管理器

@Service
public class OrderHandlerChain {
    @Autowired private List<OrderHandler> handlers;

    public void process(Order order) {
        for (OrderHandler handler : handlers) {
            if (handler.isEnabled()) {
                handler.handle(order);
            }
        }
    }
}

3. 业务层调用

@Service
public class OrderService {
    @Autowired private OrderHandlerChain handlerChain;

    public void completeOrder(Order order) {
        // 订单完成逻辑...
        handlerChain.process(order);
    }
}

---

四、观察者模式（Observer Pattern）

适用场景：当需要解耦事件触发与后续操作时（如订单完成触发多个行为）。

1. 定义订单完成事件

public class OrderCompletedEvent extends ApplicationEvent {
    public OrderCompletedEvent(Order source) {
        super(source);
    }
}

2. 定义事件监听器

@Component
public class PointsListener {
    @Autowired SystemConfigService configService;
    @Autowired UserPointsService pointsService;

    @EventListener
    public void handleOrderComplete(OrderCompletedEvent event) {
        if (configService.needGiveOrderPoints()) {
            Order order = (Order) event.getSource();
            pointsService.addPoints(order.getUserId(), order.getAmount());
        }
    }
}

@Component
public class SyncListener {
    @Autowired SystemConfigService configService;
    @Autowired RestTemplate restTemplate;

    @EventListener
    public void handleOrderComplete(OrderCompletedEvent event) {
        if (configService.needSyncOutSystem()) {
            Order order = (Order) event.getSource();
            String url = configService.getOutSystemUrl();
            restTemplate.postForEntity(url, order, String.class);
        }
    }
}

3. 触发事件

@Service
public class OrderService {
    @Autowired ApplicationEventPublisher eventPublisher;

    public void completeOrder(Order order) {
        // 订单完成逻辑...
        eventPublisher.publishEvent(new OrderCompletedEvent(order));
    }
}

---

模式选择建议

模式	适用场景	优势
策略模式	需要动态切换具体实现（如不同积分规则）	算法独立，易于扩展新策略
责任链模式	多个可配置的独立处理步骤（如校验链）	解耦处理逻辑，支持动态排序
观察者模式	事件驱动场景（如订单完成后触发多个操作）	天然解耦，支持异步处理
模板方法模式	有固定流程但需控制步骤执行（如订单标准处理流程）	流程标准化，子类只需关注差异

---

最终推荐方案

1. 核心功能：使用 责任链模式 或 观察者模式

   • 责任链模式适合需要明确控制执行顺序的场景
   • 观察者模式天然适合事件驱动的架构

2. 扩展功能：结合 策略模式

   • 如果未来需要支持不同的积分计算规则或同步方式（如切换微信/支付宝支付），可以通过策略模式实现

3. 代码示例（责任链模式 + Spring自动注入）：

// 注册所有处理器
@Bean
public OrderHandlerChain orderHandlerChain(List<OrderHandler> handlers) {
    return new OrderHandlerChain(handlers);
}

---

通过合理使用设计模式，可以显著提升代码的可读性和可维护性，特别是在需要频繁修改配置逻辑或新增功能时，新模式只需添加新类而无需修改原有代码。