通过redis 有序集合(sorted set) 实现排行榜

1.业务背景

因公司业务需要，要实现某段时间内的实时榜单。如果实时count mysql数据库，用户流量一大，数据库肯定承受不住，而恰好redis提供了有序集合这个数据类型。

2.代码实践

1.Redis工具类

 
@Component
public class RedisComponent {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    /**
     * 添加一个元素, zset与set最大的区别就是每个元素都有一个score，因此有个排序的辅助功能;  zadd
     *
     * @param key
     * @param value
     * @param score
     */
    public void add(String key, String value, double score) {
        redisTemplate.opsForZSet().add(key, value, score);
    }
 
    /**
     * 删除元素 zrem
     *
     * @param key
     * @param value
     */
    public void remove(String key, String value) {
        redisTemplate.opsForZSet().remove(key, value);
    }
 
    /**
     * score的增加or减少 zincrby
     *
     * @param key
     * @param value
     * @param score
     */
    public Double incrScore(String key, String value, double score) {
        return redisTemplate.opsForZSet().incrementScore(key, value, score);
    }
 
    /**
     * 查询value对应的score   zscore
     *
     * @param key
     * @param value
     * @return
     */
    public Double score(String key, String value) {
        return redisTemplate.opsForZSet().score(key, value);
    }
 
    /**
     * 判断value在zset中的排名  zrank
     *
     * 积分小的在前面
     *
     * @param key
     * @param value
     * @return
     */
    public Long rank(String key, String value) {
        return redisTemplate.opsForZSet().rank(key, value);
    }
 
    /**
     * 查询集合中指定顺序的值， 0 -1 表示获取全部的集合内容  zrange
     *
     * 返回有序的集合，score小的在前面
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<String> range(String key, long start, long end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }
 
    /**
     * 查询集合中指定顺序的值和score，0, -1 表示获取全部的集合内容
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<ZSetOperations.TypedTuple<String>> rangeWithScore(String key, long start, long end) {
        return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }
 
    /**
     * 查询集合中指定顺序的值  zrevrange
     *
     * 返回有序的集合中，score大的在前面
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<String> revRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }
 
    /**
     * 根据score的值，来获取满足条件的集合  zrangebyscore
     *
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Set<String> sortRange(String key, long min, long max) {
        return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    }
 
    /**
     * 返回集合的长度
     *
     * @param key
     * @return
     */
    public Long size(String key) {
        return redisTemplate.opsForZSet().zCard(key);
    }
 
}

2.具体实现类

@Component
public class RankListService {
 
    @Autowired
    private RedisComponent redisComponent;
 
    private List<RankVo> buildRedisRankToBizDO(Set<ZSetOperations.TypedTuple<String>> result, long offset) {
        List<RankVo> rankList = new ArrayList<>(result.size());
        long rank = offset;
        for (ZSetOperations.TypedTuple<String> sub : result) {
            rankList.add(new RankVo(rank++, Math.abs(sub.getScore()), Long.parseLong(sub.getValue())));
        }
        return rankList;
    }
 
    /**
     * 获取前n名的排行榜数据
     * @param key
     * @param n
     * @return
     */
    public List<RankVo> getTopNRanks(String key ,int n) {
        Set<ZSetOperations.TypedTuple<String>> result = redisComponent.rangeWithScore(key, 0, n - 1);
        return buildRedisRankToBizDO(result, 1);
    }
 
 
 
 
    /**
     * 获取用户的排行榜位置
     * @param key
     * @param userId
     * @return
     */
    public RankVo getRank(String key, Long userId) {
        // 获取排行， 因为默认是0为开头，因此实际的排名需要+1
        Long rank = redisComponent.rank(key, String.valueOf(userId));
        if (rank == null) {
            // 没有排行时，直接返回一个默认的
            return new RankVo(-1L, 0D, userId);
        }
 
        // 获取积分
        Double score = redisComponent.score(key, String.valueOf(userId));
        return new RankVo(rank + 1, Math.abs(score), userId);
    }
 

    /**
     * 用户积分自增
     * @param key
     * @param userId
     * @param score
     * @return
     */
    public RankVo incrRank(String key, Long userId, Double score) {
        redisComponent.incrScore(key, String.valueOf(userId), -score);
        Long rank = redisComponent.rank(key, String.valueOf(userId));
        Double score1 = redisComponent.score(key, String.valueOf(userId));
        return new RankVo(rank + 1, score1, userId);
    }
 
}

3.vo类

@AllArgsConstructor
@Data
public class RankVo implements Serializable {

    private static final long serialVersionUID = 4804922606006935590L;
 
    /**
     * 排名
     */
    private Long rank;
 
    /**
     * 积分
     */
    private Double score;
 
    /**
     * 用户id
     */
    private Long userId;
}

4.测试方法

@Test
public void testRank() {
    String key = "rank_key";
    //模拟业务场景
    for (int i = 1; i <= 50 ; i++) {
        rankListService.incrRank(key, Long.valueOf(i), Double.valueOf(i));
    }
    //取出前20名
    List<RankVo> topNRanks = rankListService.getTopNRanks(key, 20);
    System.out.println("前20名榜单：" + JSON.toJSONString(topNRanks));
    //取值指定用户的位置
    RankVo rank = rankListService.getRank(key, 1L);
    System.out.println("用户：1在榜单的位置：" + JSON.toJSONString(rank));
}

运行结果：

前20名榜单：[{"rank":1,"score":50.0,"userId":50},{"rank":2,"score":49.0,"userId":49},{"rank":3,"score":48.0,"userId":48},{"rank":4,"score":47.0,"userId":47},{"rank":5,"score":46.0,"userId":46},{"rank":6,"score":45.0,"userId":45},{"rank":7,"score":44.0,"userId":44},{"rank":8,"score":43.0,"userId":43},{"rank":9,"score":42.0,"userId":42},{"rank":10,"score":41.0,"userId":41},{"rank":11,"score":40.0,"userId":40},{"rank":12,"score":39.0,"userId":39},{"rank":13,"score":38.0,"userId":38},{"rank":14,"score":37.0,"userId":37},{"rank":15,"score":36.0,"userId":36},{"rank":16,"score":35.0,"userId":35},{"rank":17,"score":34.0,"userId":34},{"rank":18,"score":33.0,"userId":33},{"rank":19,"score":32.0,"userId":32},{"rank":20,"score":31.0,"userId":31}]
用户：1在榜单的位置：{"rank":50,"score":1.0,"userId":1}

redis存储结构：

有没有发现score最小的排在前面，所以赋值的时候就要注意这一点