如何简化Java Web项目中if else语句的重复代码？

这种重复的if-else确实是Web开发里的常见痛点，维护起来越改越烦，尤其是字段多的时候。这里有几种实用的简化方案，你可以根据自己的场景选择：

方案1：枚举+策略模式（最推荐） #

把每个条件对应的赋值逻辑封装成枚举的实现，这样新增条件只需要加枚举值，完全不用碰原来的判断逻辑，符合开闭原则。

先补全一下你的业务场景代码，方便理解：

// 原有的重复if-else写法
public ViewObject foo(Entity entity, String condition){
    ViewObject vo = new ViewObject();
    if("aRelated".equals(condition)){
        vo.setValue1(entity.getA());
        vo.setValue2(entity.getAExt());
    } else if("bRelated".equals(condition)){
        vo.setValue1(entity.getB());
        vo.setValue2(entity.getBExt());
    } else if("cRelated".equals(condition)){
        vo.setValue1(entity.getC());
        vo.setValue2(entity.getCExt());
    }
    // 更多else if...
    return vo;
}

现在用枚举重构：

enum FieldMappingStrategy {
    A_RELATED("aRelated") {
        @Override
        public void fillViewObject(Entity entity, ViewObject vo) {
            vo.setValue1(entity.getA());
            vo.setValue2(entity.getAExt());
        }
    },
    B_RELATED("bRelated") {
        @Override
        public void fillViewObject(Entity entity, ViewObject vo) {
            vo.setValue1(entity.getB());
            vo.setValue2(entity.getBExt());
        }
    },
    C_RELATED("cRelated") {
        @Override
        public void fillViewObject(Entity entity, ViewObject vo) {
            vo.setValue1(entity.getC());
            vo.setValue2(entity.getCExt());
        }
    };

    private final String conditionKey;

    FieldMappingStrategy(String conditionKey) {
        this.conditionKey = conditionKey;
    }

    // 根据条件字符串匹配对应的策略枚举
    public static FieldMappingStrategy matchCondition(String condition) {
        for (FieldMappingStrategy strategy : values()) {
            if (strategy.conditionKey.equals(condition)) {
                return strategy;
            }
        }
        // 这里可以根据业务需求抛异常或者返回默认策略
        throw new IllegalArgumentException("Unsupported condition: " + condition);
    }

    // 抽象方法，每个枚举值实现自己的赋值逻辑
    public abstract void fillViewObject(Entity entity, ViewObject vo);
}

然后你的foo方法就可以简化成一行核心逻辑：

public ViewObject foo(Entity entity, String condition){
    ViewObject vo = new ViewObject();
    FieldMappingStrategy.matchCondition(condition).fillViewObject(entity, vo);
    return vo;
}

优点：

• 结构清晰，每个条件的逻辑独立封装，可读性强
• 新增条件只需要加枚举值，不用修改原有判断代码，符合开闭原则
• 编译时检查，避免字符串拼写错误
• 没有反射，性能优异

缺点：如果字段极多，枚举类会比较长，但比一堆if-else好维护得多。

方案2：Map+函数式接口（简洁快速） #

用HashMap把条件字符串和对应的赋值逻辑（用Lambda表达式）绑定起来，代码更简洁，适合快速实现简单场景。

先在你的类里初始化一个静态Map（放在类的静态代码块里）：

// 静态初始化条件与处理逻辑的映射
private static final Map<String, BiConsumer<Entity, ViewObject>> CONDITION_HANDLERS = new HashMap<>();

static {
    CONDITION_HANDLERS.put("aRelated", (entity, vo) -> {
        vo.setValue1(entity.getA());
        vo.setValue2(entity.getAExt());
    });
    CONDITION_HANDLERS.put("bRelated", (entity, vo) -> {
        vo.setValue1(entity.getB());
        vo.setValue2(entity.getBExt());
    });
    CONDITION_HANDLERS.put("cRelated", (entity, vo) -> {
        vo.setValue1(entity.getC());
        vo.setValue2(entity.getCExt());
    });
    // 新增条件只需要在这里加一行
}

然后简化foo方法：

public ViewObject foo(Entity entity, String condition){
    ViewObject vo = new ViewObject();
    BiConsumer<Entity, ViewObject> handler = CONDITION_HANDLERS.get(condition);
    if (handler == null) {
        // 处理未知条件，比如抛异常或设置默认值
        throw new IllegalArgumentException("Unsupported condition: " + condition);
    }
    handler.accept(entity, vo);
    return vo;
}

优点：

• 代码非常简洁，Lambda表达式写起来快
• 新增条件只需要在Map里加一行，改动极小
• 灵活性高，甚至可以动态添加处理逻辑（如果业务需要）

缺点：

• 条件字符串是硬编码，没有编译时检查，容易出现拼写错误
• 如果赋值逻辑复杂，Lambda会显得臃肿，可读性不如枚举

方案3：反射（谨慎使用） #

如果你的字段命名有严格规律（比如a对应aExt，b对应bExt），可以用反射动态获取字段值，不用写重复的赋值代码。但反射性能较差，且依赖字段命名规则，所以只适合特殊场景。

示例代码：

public ViewObject foo(Entity entity, String condition){
    ViewObject vo = new ViewObject();
    // 从condition中提取字段前缀，比如"aRelated" -> "a"
    String fieldPrefix = condition.replace("Related", "").toLowerCase();
    
    try {
        // 获取主字段（比如a）的值
        Field mainField = Entity.class.getDeclaredField(fieldPrefix);
        mainField.setAccessible(true);
        String mainValue = (String) mainField.get(entity);
        
        // 获取扩展字段（比如aExt）的值
        Field extField = Entity.class.getDeclaredField(fieldPrefix + "Ext");
        extField.setAccessible(true);
        String extValue = (String) extField.get(entity);
        
        // 赋值给ViewObject
        vo.setValue1(mainValue);
        vo.setValue2(extValue);
    } catch (NoSuchFieldException | IllegalAccessException e) {
        throw new RuntimeException("Failed to fill VO for condition: " + condition, e);
    }
    
    return vo;
}

优点：

• 代码量最少，不管多少字段都不用重复写赋值逻辑
• 适合字段极多且命名严格规范的场景

缺点：

• 反射性能差，高频调用场景不建议使用（可以缓存Field对象优化，但还是不如直接调用方法快）
• 依赖字段命名规则，一旦字段名修改，代码会出错，且没有编译时检查
• 反射需要处理异常，代码复杂度有所上升

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