基于哈希生成HashMap键：数据库分页缓存服务实现咨询

嘿，针对你要给数据库查询缓存生成键的需求，我整理了几个实用的方案，都是围绕正确处理哈希和对象相等性来设计的，适配你提到的参数类型：

因为你有多个不同类型的参数，直接用组合对象当HashMap的键是最稳妥的方式——只要正确实现equals()和hashCode()方法，就能保证相同参数生成的键完全一致，不同参数生成的键不会冲突。

实现步骤： #

1. 创建一个包含三个字段的类：两个Map<String, String[]>和一个DocMaintainer实例
2. 重写equals()方法，分别深度比较三个字段的相等性：
   • 对于Map，要处理String[]的深比较（默认数组是引用比较，得用Arrays.equals()）
   • 对于DocMaintainer，你已经重写了equals()，直接复用即可
3. 重写hashCode()方法，组合三个字段的哈希值，确保相同内容生成相同哈希

代码示例： #

import java.util.Arrays;
import java.util.Map;
import java.util.Objects;

public class CacheKey {
    private final Map<String, String[]> paramMap1;
    private final Map<String, String[]> paramMap2;
    private final DocMaintainer maintainer;

    public CacheKey(Map<String, String[]> paramMap1, Map<String, String[]> paramMap2, DocMaintainer maintainer) {
        this.paramMap1 = paramMap1;
        this.paramMap2 = paramMap2;
        this.maintainer = maintainer;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CacheKey cacheKey = (CacheKey) o;
        return mapsEqual(this.paramMap1, cacheKey.paramMap1) &&
               mapsEqual(this.paramMap2, cacheKey.paramMap2) &&
               Objects.equals(this.maintainer, cacheKey.maintainer);
    }

    @Override
    public int hashCode() {
        return Objects.hash(
                mapHashCode(paramMap1),
                mapHashCode(paramMap2),
                maintainer
        );
    }

    // 辅助方法：深度比较两个String[]类型的Map
    private boolean mapsEqual(Map<String, String[]> m1, Map<String, String[]> m2) {
        if (Objects.equals(m1, m2)) return true;
        if (m1 == null || m2 == null || m1.size() != m2.size()) return false;
        for (Map.Entry<String, String[]> entry : m1.entrySet()) {
            String key = entry.getKey();
            String[] val1 = entry.getValue();
            String[] val2 = m2.get(key);
            if (!Arrays.equals(val1, val2)) {
                return false;
            }
        }
        return true;
    }

    // 辅助方法：计算String[]类型Map的哈希值（基于数组元素的哈希）
    private int mapHashCode(Map<String, String[]> map) {
        if (map == null) return 0;
        int hash = 0;
        for (Map.Entry<String, String[]> entry : map.entrySet()) {
            hash += Objects.hash(entry.getKey(), Arrays.hashCode(entry.getValue()));
        }
        return hash;
    }
}

使用方式： #

// 假设你有三个请求参数：map1, map2, maintainer
CacheKey cacheKey = new CacheKey(map1, map2, maintainer);
HashMap<CacheKey, YourQueryResultType> cache = new HashMap<>();

// 存入缓存
cache.put(cacheKey, queryResult);
// 查询缓存
YourQueryResultType result = cache.get(cacheKey);

如果不想写自定义类，可以把所有参数的关键信息拼接成一个唯一字符串当键。这种方式实现快，但要注意几个细节：

• 必须处理参数为空的情况
• 数组元素要按固定顺序拼接，避免键因参数顺序不同而失效
• 要选不会出现在参数值里的分隔符（比如|||这类特殊组合）

代码示例： #

import java.util.Arrays;
import java.util.Map;
import java.util.Objects;

public class CacheKeyGenerator {
    public static String generateKey(Map<String, String[]> map1, Map<String, String[]> map2, DocMaintainer maintainer) {
        StringBuilder sb = new StringBuilder();
        // 处理第一个Map（按key排序保证顺序一致）
        appendMapToString(sb, map1);
        sb.append("|||");
        // 处理第二个Map
        appendMapToString(sb, map2);
        sb.append("|||");
        // 处理DocMaintainer
        if (maintainer != null) {
            sb.append(maintainer.creator != null ? maintainer.creator.hashCode() : 0);
            sb.append("|");
            sb.append(maintainer.lastChange != null ? maintainer.lastChange.hashCode() : 0);
        } else {
            sb.append("null");
        }
        return sb.toString();
    }

    private static void appendMapToString(StringBuilder sb, Map<String, String[]> map) {
        if (map == null) {
            sb.append("null");
            return;
        }
        map.keySet().stream().sorted().forEach(key -> {
            sb.append(key).append(":");
            String[] vals = map.get(key);
            sb.append(vals == null ? "null" : Arrays.toString(vals));
            sb.append(",");
        });
    }
}

使用方式： #

String cacheKey = CacheKeyGenerator.generateKey(map1, map2, maintainer);
HashMap<String, YourQueryResultType> cache = new HashMap<>();

cache.put(cacheKey, queryResult);
YourQueryResultType result = cache.get(cacheKey);

• 数组的深比较：默认String[]的equals()是引用比较，必须用Arrays.equals()做内容比较，否则两个内容相同但引用不同的数组会被认为是不同的键，导致缓存失效或重复缓存。
• DocMaintainer的可靠性：要确保你重写的DocMaintainer.equals()能正确比较creator和lastChange字段——如果Manipulator类没有正确实现equals()和hashCode()，缓存键的相等性会出问题。
• 哈希值的稳定性：hashCode()的结果必须稳定，不能依赖随机数或可变状态的字段，否则相同参数可能生成不同的哈希值，导致缓存无法命中。

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