如何用设计模式优雅实现多客户端微小差异的服务逻辑？

这种到处散落小分支的情况我太熟悉了——核心逻辑明明通用，却被各种客户端专属的小判断拆得七零八落，单独做子类或者Factory又觉得小题大做，完全没必要。

其实你可以试试策略模式（Strategy Pattern）结合默认方法的方案，把所有客户端的差异化逻辑封装成一个个轻量的行为类，而不是给每个分支都新建服务子类。这样既能消除Service里的分支判断，又不会导致类爆炸。

具体实现步骤： #

1. 定义客户端行为接口，用默认方法处理通用逻辑

首先创建一个ClientBehavior接口，把所有零散的差异化点抽象成方法，并用默认方法实现通用的默认逻辑——这样客户端专属的实现类只需要覆盖自己有差异的部分即可，不用重复写通用代码。

interface ClientBehavior {
    // 默认无操作，只有需要的客户端才覆盖
    default void doStuff() {}
    
    // 默认返回通用名称
    default String getName() {
        return "default_name";
    }
    
    // 默认用降序排序
    default void sort() {
        sortdesc();
    }
    
    // 默认无额外处理
    default void processExtra() {}

    // 把通用的工具方法放在接口里（或者单独工具类）
    static void sortasc() { 
        // 升序排序实现
    }
    static void sortdesc() { 
        // 降序排序实现
    }
}

2. 为每个客户端实现专属行为类

针对每个客户端，只需要实现它有差异的方法即可，其他通用逻辑直接继承接口的默认实现：

// Client1专属行为
class Client1Behavior implements ClientBehavior {
    @Override
    public void doStuff() {
        doStuff1(); // Client1的专属操作
    }

    @Override
    public String getName() {
        return "xyz";
    }

    @Override
    public void sort() {
        sortasc(); // Client1用升序
    }
}

// Client2专属行为
class Client2Behavior implements ClientBehavior {
    @Override
    public void doStuff() {
        doStuff2(); // Client2的专属操作
    }

    @Override
    public String getName() {
        return "abc";
    }

    @Override
    public void processExtra() {
        processx(); // Client2的额外处理
    }
}

// Client3专属行为
class Client3Behavior implements ClientBehavior {
    @Override
    public void processExtra() {
        processy(); // Client3的额外处理
    }
}

3. 改造原Service类，注入行为策略

把原来的Service类改成依赖ClientBehavior接口，所有差异化逻辑都委托给这个接口实现，彻底消除分支判断：

class Service {
    private final ClientBehavior clientBehavior;

    // 通过构造注入获取对应客户端的行为实例
    public Service(ClientBehavior clientBehavior) {
        this.clientBehavior = clientBehavior;
    }

    void process() {
        //.... 通用逻辑部分保持不变
        clientBehavior.doStuff();
        //.... 通用逻辑部分保持不变
        String name = clientBehavior.getName();
        //.... 通用逻辑部分保持不变
        clientBehavior.sort();
        //.... 通用逻辑部分保持不变
        clientBehavior.processExtra();
    }

    // 原来的客户端专属工具方法可以保留在这里，或者移到接口
    private void doStuff1() { /* 实现 */ }
    private void doStuff2() { /* 实现 */ }
    private void processx() { /* 实现 */ }
    private void processy() { /* 实现 */ }
}

4. 用简单工厂获取对应行为实例（可选）

如果需要根据客户端类型动态获取行为实例，可以加一个轻量的工厂类：

class ClientBehaviorFactory {
    public static ClientBehavior getBehavior(String clientType) {
        return switch(clientType) {
            case "client1" -> new Client1Behavior();
            case "client2" -> new Client2Behavior();
            case "client3" -> new Client3Behavior();
            default -> throw new IllegalArgumentException("Unknown client type: " + clientType);
        };
    }
}

使用的时候就像这样：

// 根据客户端类型获取行为，创建Service实例
Service service = new Service(ClientBehaviorFactory.getBehavior("client1"));
service.process();

这个方案的优势： #

• 彻底消除分支判断：原Service类回归纯核心逻辑，代码更干净易维护。
• 轻量化扩展：新增客户端只需要新增一个ClientBehavior实现类，不用修改核心Service，符合开闭原则。
• 避免类爆炸：不用为每个小分支创建服务子类，而是把差异化逻辑聚合到行为类中，每个行为类只关注自己的差异化点。
• 灵活复用：如果多个客户端有相同的差异化逻辑，还可以提取公共的行为抽象类，进一步减少重复代码。

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