Question

我的目的是为数据库结果创建一个缓存服务，我可以根据客户的请求进行不同的分页。

因此，在（搜索）请求中，我正在创建一个由参数组成的密钥，这些参数的形式为两个Map<String, String[]>和一个：

public class DocMaintainer {
    public Manipulator creator;
    public Manipulator lastChange;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        DocMaintainer that = (DocMaintainer) o;
        return Objects.equals(creator, that.creator) &&
                Objects.equals(lastChange, that.lastChange);
    }

    @Override
    public int hashCode() {

        return Objects.hash(creator, lastChange);
    }
}


public class Manipulator {
    public Date fromDate;
    public Date toDate;
    public String userId;
    public String system;

    public Manipulator() {
        this.userId = "";
        this.system = "";
        this._fromJoda = new DateTime(Long.MIN_VALUE);
        this._toJoda = new DateTime(Long.MAX_VALUE - DateTimeConstants.MILLIS_PER_WEEK);
    }

    private DateTime _fromJoda;
    private DateTime _toJoda;

    public DateTime get_fromJoda() {
        _fromJoda = fromDate != null ? new DateTime(fromDate) : _fromJoda;
        return _fromJoda;
    }

    public DateTime get_toJoda() {
        _toJoda = toDate != null ? new DateTime(toDate) : _toJoda;
        try {
            _toJoda = _toJoda.plusDays(1);
        } catch (Exception e) {
            System.out.println(e);
        }

        return _toJoda;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Manipulator that = (Manipulator) o;
        return Objects.equals(fromDate, that.fromDate) &&
                Objects.equals(toDate, that.toDate) &&
                Objects.equals(userId, that.userId) &&
                Objects.equals(system, that.system);
    }

    @Override
    public int hashCode() {

        return Objects.hash(fromDate, toDate, userId, system);
    }
}

正如您所见，我打算使用哈希来创建一个＆＃34;密钥＆＃34;：

public class SearchKey {
    public int conjunctionHash;
    public int disjunctionHash;
    public int maintainerHash;

    public SearchKey(int conjunctionHash, int disjunctionHash, int maintainerHash) {
        this.conjunctionHash = conjunctionHash;
        this.disjunctionHash = disjunctionHash;
        this.maintainerHash = maintainerHash;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        SearchKey searchKey = (SearchKey) o;
        return conjunctionHash == searchKey.conjunctionHash &&
                disjunctionHash == searchKey.disjunctionHash &&
                maintainerHash == searchKey.maintainerHash;
    }

    @Override
    public int hashCode() {

        return Objects.hash(conjunctionHash, disjunctionHash, maintainerHash);
    }
}

密钥对象直接用作单例服务中的缓存密钥：

@Named
@Singleton
public class SearchCacheSrv {

    private Map<SearchKey, ValidMainteinersList<FindDTO>> cache = new HashMap<>();

    public ValidMainteinersList<FindDTO> getCached(SearchKey searchKey) {
        if (cache.containsKey(searchKey))
            return cache.get(searchKey);
        else
            return new ValidMainteinersList<FindDTO>();
    }

    public SearchKey makeAkey(Map<String, String[]> conjunction,
                              Map<String, String[]> disjunction,
                              DocMaintainer maintainer) {
        return new SearchKey(conjunction.hashCode(), disjunction.hashCode(), maintainer.hashCode());
    }

    public ValidMainteinersList<FindDTO> cache(SearchKey searchKey, ValidMainteinersList<FindDTO> findDTOS) {
        return cache.put(searchKey, findDTOS);
    }

    public void clearCache() {
        cache.clear();
    }
}

不幸的是，这不符合我的预期，并且我为相同的参数生成了不同的哈希/密钥。

自然问题是为什么？

Answer 1

这里的问题是数组does not depend on the contents, but on the reference的hashCode。这意味着如果你有两个相等的连接/分离键，但是包含的数组不是相同的对象，那么键的哈希码将是不同的。

可能花费最少的解决方案是使用ArrayList替换数组，这些数据基于content上的hashCode。

Answer 2

我实际上没有看到将conj.hashCode（），...传递给你的SearchKey构造函数;我从来没有这样做过，但这可能是我的错。尝试将实际值传递给SearchKey类，而不是hashCodes，因此hashCode方法总是返回一致的值。

基于散列的{HavMap密钥生成

2 个答案: