使用策略模式与函数式接口重构多分支泛型比较方法-java教程-PHP中文网

使用策略模式与函数式接口重构多分支泛型比较方法

本文介绍如何通过策略模式结合函数式接口，将包含大量 switch-case 的泛型比较方法解耦为可扩展、低认知复杂度的模块化设计，避免未来新增条件导致代码腐化。

本文介绍如何通过策略模式结合函数式接口，将包含大量 switch-case 的泛型比较方法解耦为可扩展、低认知复杂度的模块化设计，避免未来新增条件导致代码腐化。

在 Java 项目中，当一个泛型比较方法（如 compareValues）持续增长 switch-case 分支时，不仅违反开闭原则，还会显著推高 SonarQube 认知复杂度（Cognitive Complexity），降低可维护性与可测试性。原始实现中硬编码的 6 种比较逻辑（EQUALS/NOT_EQUALS/LIKE/NOT_LIKE/IN/NOT_IN）已显臃肿，且字符串类型特殊处理（trim + case-insensitive）与泛型约束 Comparable 存在语义冲突——String 虽实现 Comparable，但其自然排序与业务语义（如忽略空格和大小写）并不等价。

推荐采用策略模式 + 函数式接口 + 静态不可变映射进行重构。核心思路是：将每种比较行为抽象为独立的 TriPredicate 实例，通过 Map> 统一注册与查找，彻底消除 switch-case 结构。

以下是重构后的完整实现（兼容 Java 14+，若需 Java 8 支持可替换 Map.of() 为 ImmutableMap.builder()）：

Java Maven Code Review

审查Java Maven项目（ZIP压缩包或GitLab仓库URL），检查代码规范、命名、模块边界、可维护性问题以及重复代码。

下载

@FunctionalInterface
interface TriPredicate<t extends comparable>> {
    boolean test(T lookupValue, T actualValue, List<t> lookupValues);
}

private static final Map<string tripredicate>> COMPARATORS = Map.of(
        "EQUALS",     (TriPredicate<object>) (lookup, actual, _) -> 
            compareAsStrings(lookup, actual) || Objects.equals(lookup, actual),
        "NOT_EQUALS", (TriPredicate<object>) (lookup, actual, _) -> 
            !((TriPredicate<object>) COMPARATORS.get("EQUALS")).test(lookup, actual, null),
        "LIKE",       (TriPredicate<object>) (lookup, actual, _) -> 
            StringUtils.containsIgnoreCase(String.valueOf(actual), String.valueOf(lookup)),
        "NOT_LIKE",   (TriPredicate<object>) (lookup, actual, _) -> 
            !((TriPredicate<object>) COMPARATORS.get("LIKE")).test(lookup, actual, null),
        "IN",         (TriPredicate<object>) (_, actual, lookupList) -> 
            listContains(actual, lookupList),
        "NOT_IN",     (TriPredicate<object>) (_, actual, lookupList) -> 
            !listContains(actual, lookupList)
);

protected static <t extends comparable>> boolean compareValues(
        T lookupValue, T actualValue, String comparisonCondition, List<t> lookupValues) {

    String key = Objects.requireNonNull(comparisonCondition, "comparisonCondition must not be null")
                      .toUpperCase().trim();

    @SuppressWarnings("unchecked")
    TriPredicate<t> predicate = (TriPredicate<t>) COMPARATORS.getOrDefault(key, (l, a, ls) -> false);

    boolean result = predicate.test(lookupValue, actualValue, lookupValues);

    if (LOGGER.isDebugEnabled()) {
        String lookupStr = lookupValue != null ? String.valueOf(lookupValue) :
                lookupValues != null ? lookupValues.stream()
                        .map(Object::toString)
                        .collect(Collectors.joining(WhlProcessingConstants.SPLIT_COMMA))
                        : "null";
        LOGGER.debug("Comparing value '{}' with '{}' using comparison condition '{}'.{}Result: {}",
                actualValue, lookupStr, key, LINE_SEPARATOR, result);
    }

    return result;
}

// 辅助方法：统一字符串比较逻辑（trim + ignoreCase）
private static boolean compareAsStrings(Object a, Object b) {
    if (a instanceof String && b instanceof String) {
        return ((String) a).trim().equalsIgnoreCase(((String) b).trim());
    }
    return false;
}

// 辅助方法：安全遍历 lookupValues，兼容 String 特殊比较
private static <t extends comparable>> boolean listContains(T actual, List<t> lookupList) {
    if (lookupList == null || lookupList.isEmpty()) return false;
    return lookupList.stream().anyMatch(lookup -> 
        compareAsStrings(lookup, actual) || 
        Objects.equals(lookup, actual) ||
        (lookup != null && actual != null && lookup.compareTo(actual) == 0)
    );
}</t></t></t></t></t></t></object></object></object></object></object></object></object></object></string></t></t>

关键优化点说明：

✅ 零 switch-case：完全移除 switch，认知复杂度从 O(n) 降为 O(1)；
✅ 开闭原则友好：新增比较类型（如 BETWEEN, STARTS_WITH）仅需向 COMPARATORS 映射添加新键值对，无需修改主方法；
✅ 泛型安全增强：使用 @SuppressWarnings("unchecked") + 类型擦除安全封装，避免原始方案中 TriPredicate 泛型无法直接用于 Map> 的编译问题；
✅ 复用与正交：NOT_* 逻辑复用对应 * 策略取反，避免重复实现；compareAsStrings 提取公共字符串处理；
✅ 健壮性提升：增加 Objects.requireNonNull 和空值防御，日志中 lookupStr 构建更清晰；