避免啰嗦，不要多此一举！

避免啰嗦，不要多此一举！

引用

CSDN

1.

https://blog.csdn.net/isea533/article/details/139491184

本文通过一个具体的代码优化案例，展示了如何精简代码、提高代码效率，并探讨了在不同场景下选择合适的设计模式。文章内容主要面向Java开发者，特别是使用MyBatis框架的开发者。

原始代码分析

下面是一段原始代码，其功能是根据不同的比较条件（ccompare）来判断字符串condition是否满足特定条件：

private static boolean comparelogic(String condition, String value, String ccompare) {
    try {
        if ("0".equals(ccompare)) {//包含
            if (condition.contains(value)) {
                return true;
            } else {
                return false;
            }
        }
        if ("1".equals(ccompare)) {//不包含
            if (!condition.contains(value)) {
                return true;
            } else {
                return false;
            }
        }
        //省略2，3，4，5，6，7，8，9
        return false;
    } catch (Exception e) {
        return false;
    }
}

代码优化

第一眼看到下面代码就觉得很啰嗦：

if (condition.contains(value)) {
    return true;
} else {
    return false;
}

可以直接简化为：

return condition.contains(value);

不要判断true时返回true，否则false。你的判断条件和返回结果一致时，直接返回判断条件即可。

除此之外，本来互斥的多个if写成了独立的，连else if都没使用，如果ccompare="9"所有if条件都要判断一遍才能走到最后一个符合条件的if。

另外这么典型的排比句，用switch是最合适的，经过优化后的代码：

private static boolean comparelogic(String condition, String value, String ccompare) {
    try {
        switch (ccompare) {
            case "0": //包含
                return condition.contains(value);
            case "1": //不包含
                return !condition.contains(value);
            case "2": //等于
                return condition.equals(value);
            case "3": //不等于
                return !condition.equals(value);
            case "4": //大于
                return new BigDecimal(condition).compareTo(new BigDecimal(value)) > 0;
            case "5": //大于等于
                return new BigDecimal(condition).compareTo(new BigDecimal(value)) > -1;
            case "6": //小于
                return new BigDecimal(condition).compareTo(new BigDecimal(value)) < 0;
            case "7": //小于等于
                return new BigDecimal(condition).compareTo(new BigDecimal(value)) < 1;
            case "8": //为空
                return StringUtils.isBlank(condition);
            case "9": //不为空
                return StringUtils.isNotBlank(condition);
            default:
                return false;
        }
    } catch (Exception e) {
        return false;
    }
}

这样就足够了，当考虑condition可能扩展更多比较方式时，还可以考虑策略模式，如果不会变化就不要选择策略模式，几乎所有设计模式都会让类的数量爆炸式增长，这里直接给出Copilot的例子：

public interface ComparatorStrategy {
    boolean compare(String condition, String value);
}
public class ContainsComparator implements ComparatorStrategy {
    @Override
    public boolean compare(String condition, String value) {
        return condition.contains(value);
    }
}
public class NotContainsComparator implements ComparatorStrategy {
    @Override
    public boolean compare(String condition, String value) {
        return !condition.contains(value);
    }
}
// ... 其他比较策略的实现
public class CompareLogic {
    private static final Map<String, ComparatorStrategy> strategies = new HashMap<>();
    static {
        strategies.put("0", new ContainsComparator());
        strategies.put("1", new NotContainsComparator());
        // ... 其他比较策略的实例
        // TODO 增加其他实现仍然需要改这里代码
    }
    public static boolean comparelogic(String condition, String value, String ccompare) {
        ComparatorStrategy strategy = strategies.get(ccompare);
        if (strategy == null) {
            return false;
        }
        return strategy.compare(condition, value);
    }
}

上面的方式消除了if或switch，但是别听信哪些为了消除if推荐这么做的文章，如果你有扩展变化的需求，这种方式很方便，附带消除了if。上面这个方案再配合有IOC注入的框架时，下面注册的代码可以去掉，做到完全不需要改动任何代码：

static {
    strategies.put("0", new ContainsComparator());
    strategies.put("1", new NotContainsComparator());
    // ... 其他比较策略的实例
    // TODO 增加其他实现仍然需要改这里代码
}

下面是基于Spring框架实现策略模式的示例代码：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
public class CompareLogic {
    private final Map<String, ComparatorStrategy> strategies;
    @Autowired
    public CompareLogic(ApplicationContext applicationContext) {
        strategies = applicationContext.getBeansOfType(ComparatorStrategy.class);
    }
    public boolean comparelogic(String condition, String value, String ccompare) {
        ComparatorStrategy strategy = strategies.get(ccompare);
        if (strategy == null) {
            return false;
        }
        return strategy.compare(condition, value);
    }
}
//其中一个实现
import org.springframework.stereotype.Component;
@Component("0")
public class ContainsComparator implements ComparatorStrategy {
    @Override
    public boolean compare(String condition, String value) {
        return condition.contains(value);
    }
}
//其中一个实现
import org.springframework.stereotype.Component;
@Component("1")
public class NotContainsComparator implements ComparatorStrategy {
    @Override
    public boolean compare(String condition, String value) {
        return !condition.contains(value);
    }
}

配合IOC使用时，像上面两个实现这样扩展就能增加新的策略，运行时扫描到就会自动注册，做到真正不修改任何代码，直接扩展新策略。

上面这个是Copilot给出的实现，比我常用的方式更简单，我没想到的地方是@Component("1")中指定的名字，使用getBeansOfType可以直接返回名字作为key，实例作为value的Map。我以前会增加一个接口方法来返回策略名称，然后注入List<接口>，遍历放到Map中，没想到Copilot给出了一个更简单的实现！又学到了。