关于缓存细粒度化后的查询优化

1
Map<Long, DemoDTO> list(Set<Long> idSet);

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 结合MYSQL的管道查询
 *
 * @param targetSet         目标集合
 * @param dbResultMapGetter 未命中缓存时，从MYSQL获取数据映射
 * @param cacheKeyPrefix    缓存前缀
 * @param <K>               map result key
 * @param <V>               map result value
 * @return 最终查询结果映射
 */
<K, V> Map<K, V> pGetCombineDb(Set<K> targetSet, Function<Set<K>, Map<K, V>> dbResultMapGetter, String cacheKeyPrefix);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
    @SuppressWarnings("unchecked")
    @Override
    public <K, V> Map<K, V> pGetCombineDb(Set<K> targetSet, Function<Set<K>, Map<K, V>> dbResultMapGetter, String cacheKeyPrefix) {
        List<String> keys = targetSet.stream().map(e ->
                RedisUtils.mergeKey(cacheKeyPrefix, e))
                .collect(Collectors.toList());
        List<V> cacheResult = (List<V>) pGet(keys);
        Map<K, V> resultMap = new HashMap<>(targetSet.size());
        Map<K, V> dbResultMap = new HashMap<>();
        boolean allHitCache = putCacheResult(new ArrayList<>(targetSet), cacheResult, resultMap, dbResultMap);
        if (allHitCache) {
            return resultMap;
        }
        // 更新真实的Mysql查询结果
        dbResultMap.putAll(dbResultMapGetter.apply(dbResultMap.keySet()));
        resultMap.putAll(dbResultMap);
        // 缓存mysql查询结果
        List<Tuple2<String, Object>> setCommands = new ArrayList<>(dbResultMap.size());
        dbResultMap.forEach((k, v) -> setCommands.add(new Tuple2<>(
                // 缓存参数拼接策略，一般以:隔开
                RedisUtils.mergeKey(cacheKeyPrefix, k), v)));
        pSet(setCommands);
        return resultMap;
    }

    /**
     * @param targetSet   查询目前列表
     * @param cacheResult 管道查询缓存结果有序列表
     * @param resultMap   最终查询结果
     * @param dbResultMap mysql查询结果
     * @param <K>         map result key
     * @param <V>         map result value
     * @return 是否全部命中缓存
     */
    private <K, V> boolean putCacheResult(List<K> targetSet, List<V> cacheResult, Map<K, V> resultMap,
                                          Map<K, V> dbResultMap) {
        for (int i = 0; i < targetSet.size(); i++) {
            if (cacheResult.get(i) == null) {
                // mysql查询的各个结果先视为空
                dbResultMap.put(targetSet.get(i), null);
            } else {
                resultMap.put(targetSet.get(i), cacheResult.get(i));
            }
        }
        return dbResultMap.keySet().size() == 0;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    public List<Object> pGet(List<String> keys) {
        return stringRedisTemplate.executePipelined((RedisCallback<Object>) redisConnection -> {
            for (String key : keys) {
                redisConnection.get(serializeKey(key));
            }
            return null;
        }, RedisSerializer.json());
    }


    public void pSet(List<Tuple2<String, Object>> kvs) {
        stringRedisTemplate.executePipelined((RedisCallback<Object>) redisConnection -> {
            for (Tuple2<String, Object> kv : kvs) {
                byte[] value = RedisSerializer.json().serialize(kv.getSecond());
                if (value == null) {
                    continue;
                }
                redisConnection.set(serializeKey(getRealKey(kv.getFirst())), value,
                        Expiration.milliseconds(24 * 3600 * 1000L +
                                // 避免同一时间过期较多缓存
                                RandomUtils.nextLong(1, 6 * 3600 * 1000L)),
                        RedisStringCommands.SetOption.UPSERT);
            }
            return null;
        }, RedisSerializer.json());
    }

1
2
3
4
5
6
7
8
    @Override
    public Map<Long, DemoDTO> list(Set<Long> idSet) {
        return redisExtendService.pGetCombineDb(idSet, dbSearching ->         {
            // 用IN查询之类的把未命中缓存的数据查询出来
            List<DemoDTO> dbResult = demoDao.findAll(dbSearching);
            return dbResult.stream().collect(Collectors.toMap(DemoDTO::getId,demo-> demo));
        }, "demo");
    }