【Redis】使用案例

【一】实现排行榜

【1】准备工作

@Configuration
public class RedisRankUtil {
    @Resource(name = "redisTemplate")
    private RedisTemplate redisTemplate;

    // 维度归因分析排名热度
    public final String DIM_VALUE_CONTRIBUTION_RANK_KEY = "DIM_VALUE_CONTRIBUTION_RANK_KEY";

    // 指标市场查询排名热度
    public final String INDEX_MARKET_SEARCH_RANK_KEY = "INDEX_MARKET_SEARCH_RANK_KEY";

    // 过期时间天数
    public final Integer HOT_SEARCH_EXPIRE_TIME = 30;


    public void setExpireTime(String key,Integer expireTime) {
        redisTemplate.expire(key, expireTime, TimeUnit.DAYS);
    }

    /**
     * 获得key数组里面key2元素的索引
     * @param key
     * @param key2
     * @return
     */
    public Long rank(String key, Object key2) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rank(key, key2);
    }


    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 获得key数组里面key2元素的排序值
     * @param key
     * @param key2
     * @return
     */
    public double score(String key, Object key2) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.score(key, key2);
    }

    /**
     * 从高到低的排序集中获取从头(start)到尾(end)内的元素。
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<Object> reverseRange(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.reverseRange(key, start, end);
    }

    public Set<ZSetOperations.TypedTuple<Object>> reverseRangeWithScores(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.reverseRangeWithScores(key, start, end);
    }

    /**
     * 根据分数保留指定个数，其余的元素删除
     * @param key
     * @param number
     * @return
     */
    public Boolean remove(String key, Integer number) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Long size = zset.size(key);
        if (size > number) {
            //获取变量指定区间的元素
            Set<ZSetOperations.TypedTuple<Object>> typedTuples = zset.rangeWithScores(key, 0, (size - 1) - number);
            Set set = new HashSet();
            for (ZSetOperations.TypedTuple<Object> o : typedTuples) {
                set.add(o.getValue());
            }
            for (Object o : set) {
                Long aLong = zset.remove(key, o);
                if (aLong == null) {
                    return false;
                }
            }
            return true;
        }else {
            return true;
        }
    }

    public long sSetAndTime(String key,long time,Object values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if(time>0) {
                redisTemplate.expire(key, time, TimeUnit.DAYS);
            };
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    public Set<Object> sMembers(String key) {
        try {
            Set<Object> members = redisTemplate.opsForSet().members(key);
            return members;
        } catch (Exception e) {
            e.printStackTrace();
            return Sets.newHashSet();
        }
    }


}
    

【2】使用zset实现排行榜

（1）存储

        // 存储归因分析次数
        String key = redisRankUtil.DIM_VALUE_CONTRIBUTION_RANK_KEY;
        Long rank = redisRankUtil.rank(key, indexId);
        if (ObjectUtil.isNull(rank)) {
            redisRankUtil.zAdd(key,indexId,1.0);
            log.info("指标归因分析热度统计：{}-{}",indIndex.getIndexName(),1);
        } else {
            int score = (int)redisRankUtil.score(key, indexId);
            redisRankUtil.zAdd(key,indexId,score+1);
            log.info("指标归因分析热度统计：{}-{}",indIndex.getIndexName(),score+1);
        }

（2）查询

    public ApiResponse<List<IndIndexQueryResponse>> indexContributionPopular(int size) {
        Set<ZSetOperations.TypedTuple<Object>> strSet = redisRankUtil.reverseRangeWithScores(redisRankUtil.DIM_VALUE_CONTRIBUTION_RANK_KEY, 0, size - 1); //正确个数为下标-1
        DomainResponse<List<IndIndex>> listDomainResponse = indIndexService.queryByIds(strSet.stream().map(it->Long.valueOf(it.getValue().toString())).collect(Collectors.toList()));
        List<IndIndexQueryResponse> indIndexQueryResponses = indIndexDTOAssembler.toQueryResponse(listDomainResponse.getData());

        Map<String, IndIndexQueryResponse> indexId2InfoMap = indIndexQueryResponses.stream().collect(Collectors.toMap(it -> it.getId().toString(), it -> it));

        List<IndIndexQueryResponse> result = Lists.newArrayList();
        strSet.forEach(it->{
            if (ObjectUtil.isNotNull(indexId2InfoMap.get(it.getValue().toString()))) {
                IndIndexQueryResponse index = indexId2InfoMap.get(it.getValue().toString());
                index.setRankScore(StrUtil.split(it.getScore().toString(),".").get(0));
                result.add(index);
            }
        });

        return ApiResponse.ok(result);
    }

【3】使用set实现查询近30天热搜词排行榜

（1）存储

// 存储搜索词
        String search = queryRequest.getSearch();
        if (ObjectUtil.isNotEmpty(search)) {
            IndIndexQueryResponse indIndex = new IndIndexQueryResponse();
            indIndex.setIndexName(search);
            indIndex.setCreateDateTime(LocalDateTime.now());
            String key = redisRankUtil.INDEX_MARKET_SEARCH_RANK_KEY;
            redisRankUtil.sSetAndTime(key,redisRankUtil.HOT_SEARCH_EXPIRE_TIME,indIndex);
            log.info("指标市场热搜关键词热度统计：{}",search);
        }

（2）查询

    public ApiResponse<List<IndIndexQueryResponse>> marketSearchPopular() {
        Set<Object> searchNameSet = redisRankUtil.sMembers(redisRankUtil.INDEX_MARKET_SEARCH_RANK_KEY);
        List<IndIndexQueryResponse> result = Lists.newArrayList();
        if (ObjectUtil.isNotEmpty(searchNameSet)) {
            Map<String, Long> indexName2CountMap = searchNameSet.stream().map(it -> (IndIndexQueryResponse) it).collect(Collectors.groupingBy(it -> it.getIndexName(), Collectors.counting()));
            indexName2CountMap.keySet().forEach(it->{
                IndIndexQueryResponse response = new IndIndexQueryResponse();
                response.setIndexName(it);
                response.setRankScore(indexName2CountMap.get(it).toString());
                result.add(response);
            });
        }
        List<IndIndexQueryResponse> finalResult = result.stream().sorted(Comparator.comparing(IndIndexQueryResponse::getRankScore)).collect(Collectors.toList());

        return ApiResponse.ok(finalResult);
    }

【二】实现编码生成器

【1】业务编码生成器

@Repository
public class BizCodeGenerator {
    public static String generateSequenceCode(String bizKey) {
        RedisTemplate redisTemplate = SpringUtil.getBean("redisTemplate", RedisTemplate.class);
        String pure_date = DateUtil.format(new Date(), DatePattern.PURE_DATE_FORMAT);
        String sequenceRedisKey = bizKey + pure_date;
        redisTemplate.opsForValue().setIfAbsent(sequenceRedisKey, 0,1, TimeUnit.DAYS);
        Long increment = redisTemplate.opsForValue().increment(sequenceRedisKey);
        String code = StrUtil.fill(String.valueOf(increment), '0', 6, true);
        return pure_date + code;
    }
}