备考设计模式考试：求Separated Interface与Remote Facade结合实例

模式核心意图 #

• Separated Interface：剥离业务能力的接口定义与具体实现，让依赖方仅对接抽象接口，实现逻辑解耦，同时支持针对不同场景提供多实现适配。
• Remote Facade：针对跨进程（含同一机器内）的调用场景，提供粗粒度的服务入口，封装内部细粒度操作，减少跨边界调用次数，降低通信开销与复杂度。

具体场景与落地实现 #

假设电商系统中，**订单履约服务（独立进程A）需要调用库存服务（独立进程B）**的能力，两者运行在同一机器的不同进程中，符合教授定义的Remote Facade适用场景。

1. 定义Separated Interface #

先为库存核心能力定义独立的抽象接口，仅声明适配跨进程调用的粗粒度操作：

// 库存操作抽象接口（Separated Interface）
public interface InventoryService {
    // 粗粒度操作：批量锁定订单所需库存
    boolean lockBatchStock(List<StockLockRequest> requests);
    // 粗粒度操作：批量释放已锁定库存
    void releaseBatchStock(List<String> lockIds);
}

接口仅聚焦对外暴露的能力，不包含任何业务逻辑实现。

2. 实现Remote Facade #

在库存服务（进程B）内，基于上述接口实现Remote Facade，封装内部细粒度的库存操作：

// 库存服务的Remote Facade实现（进程B内部）
public class RemoteInventoryFacade implements InventoryService {
    // 依赖进程B内部的细粒度业务组件
    private final StockManager stockManager;
    private final LockRecordRepository lockRecordRepo;

    @Override
    public boolean lockBatchStock(List<StockLockRequest> requests) {
        // 封装多个内部细粒度操作：批量校验库存、生成锁记录、扣减可用库存
        try {
            // 先批量校验所有SKU的库存充足性
            boolean allStockAvailable = requests.stream()
                    .allMatch(req -> stockManager.checkAvailableStock(req.getSkuId(), req.getQuantity()));
            if (!allStockAvailable) {
                return false;
            }
            // 批量生成库存锁记录
            List<StockLockRecord> lockRecords = requests.stream()
                    .map(req -> new StockLockRecord(UUID.randomUUID().toString(), req.getSkuId(), req.getQuantity()))
                    .toList();
            lockRecordRepo.saveBatch(lockRecords);
            // 批量扣减对应SKU的可用库存
            stockManager.deductBatchStock(lockRecords);
            return true;
        } catch (Exception e) {
            // 异常回滚：恢复已操作的库存状态
            stockManager.rollbackStockChanges();
            return false;
        }
    }

    @Override
    public void releaseBatchStock(List<String> lockIds) {
        // 封装内部操作：查询锁记录、恢复库存、删除锁记录
        List<StockLockRecord> lockRecords = lockRecordRepo.findByIds(lockIds);
        stockManager.restoreBatchStock(lockRecords);
        lockRecordRepo.deleteBatch(lockIds);
    }
}

该Facade作为进程B对外的唯一入口，所有跨进程调用都通过这两个粗粒度方法完成，避免外部服务直接接触库存服务的内部核心逻辑。

3. 客户端（订单履约服务）对接 #

订单履约服务（进程A）仅依赖InventoryService抽象接口，通过进程间通信代理（如本地Socket封装的客户端）获取接口实现：

// 订单履约服务（进程A）中的业务逻辑
public class OrderFulfillmentService {
    // 仅依赖Separated Interface，不耦合具体实现
    private final InventoryService inventoryService;

    public boolean processOrderFulfillment(Order order) {
        // 组装批量锁库存请求
        List<StockLockRequest> lockRequests = order.getItems().stream()
                .map(item -> new StockLockRequest(item.getSkuId(), item.getQuantity()))
                .toList();
        // 跨进程调用库存服务
        boolean lockSuccess = inventoryService.lockBatchStock(lockRequests);
        if (lockSuccess) {
            // 执行后续履约逻辑：通知仓库发货、更新订单状态等
            return true;
        } else {
            // 库存不足，触发订单取消流程
            cancelOrder(order);
            return false;
        }
    }
}

模式结合的核心价值 #

• Separated Interface的作用：订单履约服务仅依赖抽象接口，无需关心库存服务的内部实现细节。若后续库存服务优化锁库存逻辑或替换实现类，只要接口不变，履约服务无需任何修改；同时库存服务可为同进程调用场景提供另一个实现类，复用同一接口。
• Remote Facade的作用：将原本需要多次调用的细粒度操作（单个SKU库存校验、单个SKU库存扣减等）合并为两次粗粒度调用，大幅减少进程间的通信次数，降低延迟与出错概率，同时封装了库存服务的内部复杂度，避免外部服务直接操作核心库存数据。

内容的提问来源于stack exchange，提问作者Camila Alegre