含公共逻辑的多分支条件判断代码优化设计模式咨询

核心思路：用策略模式消除重复条件判断 #

原代码的问题在于重复判断同一个condition，当分支逻辑变复杂或新增分支时，会导致代码冗余、难以维护。最优方案是采用策略模式，把不同分支的差异化逻辑封装成独立的策略类，通过多态替代条件判断，同时保留公共流程的复用。

具体实现步骤 #

1. 定义策略接口 #

先把分支里的差异化行为抽象成接口，包含创建对象和后续操作的核心方法：

interface OperationStrategy {
    Object createObject(); // 对应原代码的创建对象逻辑
    void doSpecificThing(); // 对应原代码的分支操作逻辑
}

2. 实现具体策略类 #

分别实现两种条件下的逻辑，把差异化代码封装到独立类中：

class StrategyA implements OperationStrategy {
    @Override
    public Object createObject() {
        // 创建第一个对象的具体逻辑
        return new ObjectA();
    }

    @Override
    public void doSpecificThing() {
        // 执行第一种操作的具体逻辑
        System.out.println("执行策略A的专属操作");
    }
}

class StrategyB implements OperationStrategy {
    @Override
    public Object createObject() {
        // 创建第二个对象的具体逻辑
        return new ObjectB();
    }

    @Override
    public void doSpecificThing() {
        // 执行第二种操作的具体逻辑
        System.out.println("执行策略B的专属操作");
    }
}

3. 封装公共流程，注入策略 #

把公共的oneCommonMethod()和anotherCommonMethod()放在统一流程里，根据条件获取对应策略后执行：

public class BusinessHandler {
    public void handle(boolean condition) {
        // 根据条件获取对应的策略实例
        OperationStrategy strategy = condition ? new StrategyA() : new StrategyB();
        
        // 执行分支创建逻辑
        Object obj = strategy.createObject();
        // 若需要使用创建的对象，可在此处处理
        
        // 执行公共方法
        oneCommonMethod();
        
        // 执行分支操作逻辑
        strategy.doSpecificThing();
        
        // 执行另一个公共方法
        anotherCommonMethod();
    }

    private void oneCommonMethod() {
        // 原公共逻辑代码
    }

    private void anotherCommonMethod() {
        // 原公共逻辑代码
    }
}

为什么这是最优方案？ #

• 彻底消除了重复的condition判断，代码结构更简洁
• 新增分支时，只需新增一个OperationStrategy的实现类，无需修改原有流程代码，符合开闭原则
• 差异化逻辑被封装到独立类中，职责单一，便于单独维护和测试
• 如果分支间存在共享逻辑，还可以通过抽象策略类提取公共代码，进一步提升复用性

补充：简单场景的简化实现 #

如果分支逻辑非常简单，也可以用Java 8+的Lambda表达式简化，避免创建过多类：

public class SimpleHandler {
    public void handle(boolean condition) {
        // 用Supplier封装对象创建逻辑
        Supplier<Object> objectCreator = condition 
            ? () -> new ObjectA() 
            : () -> new ObjectB();
        
        // 用Runnable封装分支操作逻辑
        Runnable action = condition 
            ? () -> System.out.println("执行A操作") 
            : () -> System.out.println("执行B操作");
        
        Object obj = objectCreator.get();
        oneCommonMethod();
        action.run();
        anotherCommonMethod();
    }

    // 公共方法省略...
}

这种方式适合逻辑简单的场景，代码更紧凑，但复杂场景下还是策略模式的可扩展性更强。

内容的提问来源于stack exchange，提问作者Jose Robles Villares