Redis学习系列（三）——实时排行榜

实时排行榜

环境：SpringBoot2.0

依赖

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

---

实例

  /**
     * 排行榜的KEY
     */
    public String KEY_DD="test:countMoney";
    public String KEY_DD1="countMoney1";
    public String KEY_DD2="countMoney2";
    public String KEY_DD3="countMoney3";

    /**
     * 初始数据
     */

    public void init() {
        ZSetOperations<String, User> zSet = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<User>> users = new HashSet<>();
        for (int i = 0; i < 50; i++) {
            //为用户初始化数据
            User user = new User(i, "sjy" + i, "https://www.baidu.com?" + i);
            users1.add(user);
            DefaultTypedTuple<User> tuple = new DefaultTypedTuple<User>( user, 0d);
            users.add(tuple);
        }
        // 批量新增
        zSet.add(KEY_DD, users);
    }

    /**
     * 随机人随机加分
     */
    public void addSource() {
        Random random = new Random();
        for (int j = 0; j < 100; j++) {
            int i = random.nextInt(50);
            ZSetOperations<String, User> zSet = redisTemplate.opsForZSet();
            int i1 = new Random().nextInt(6);
            // 加法运算  i1是正增量
            zSet.incrementScore(KEY_DD,users1.get(i),i1 );
            //更新 替换
            //zSet.add(KEY_DD,users1.get(i),i1 );
        }
    }

    /**
     * 查询集合中所有的成员
     */

    public Set<User> all(){
        ZSetOperations<String, User> zSet = redisTemplate.opsForZSet();
        return zSet.reverseRange(KEY_DD, 0, -1);
    }
    /**
     * 查看前十名
     */
    public Set<ZSetOperations.TypedTuple<User>> top10(){
        ZSetOperations<String, User> zSet = redisTemplate.opsForZSet();

        // 获取分数前十名的用户
        Set<User> userSet = zSet.reverseRange(KEY_DD, 0, 9);

        assert userSet != null;
        System.out.println(userSet.size());
        for (Serializable serializable : userSet) {
            System.out.print(serializable.toString()+", ");
        }
        // 获取分数前十名的用户以及对应的分数
        Set<ZSetOperations.TypedTuple<User>> scores = zSet.reverseRangeWithScores(KEY_DD, 0, 10);

        System.out.println();
        assert scores != null;
        System.out.println(scores.size());
        for (ZSetOperations.TypedTuple<User> score : scores) {
            System.out.print(score.getValue()+" : "+(score.getScore().intValue())+", ");
        }
        return scores;

    }

    /**
     * 分数之间的用户人数
     */
    public void limitNum1toNum2Count(){

        Long count = redisTemplate.opsForZSet().count(KEY_DD, 0, 10);

    }


    public void intersectAndStore(){

        // KEY_DD1集合与KEY_DD2集合，共同的交集元素存到KEY_DD3（复制），返回元素个数
        redisTemplate.opsForZSet().intersectAndStore(KEY_DD1,KEY_DD2,KEY_DD3);

        // KEY_DD1集合与KEY_DD2集合，共同的并集元素存到KEY_DD3（复制），返回元素个数
        redisTemplate.opsForZSet().unionAndStore(KEY_DD1,KEY_DD2,KEY_DD3);
    }

    /**
     * 删除集合中的元素
     */
    public void remove(){

        //删除集合
        redisTemplate.opsForZSet().remove(KEY_DD,users1.get(0));
        //删除数组中0<=~<=2索引的元素 数据是倒叙的所以删除的是最小的三个值
        //redisTemplate.opsForZSet().removeRange(KEY_DD,0,2);
        // 删除集合中分数是0<=~<=10的元素
        // redisTemplate.opsForZSet().removeRangeByScore(KEY_DD, 0, 9);

    }
    }
    

    class User implements Serializable {

        private static  final  long serialVersionUID=0L;

        private Integer id; //id
        private String name; //姓名
        private String url; //地址

        public User() {
        }

        public User(Integer id, String name, String url) {
            this.id = id;
            this.name = name;
            this.url = url;
        }

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getUrl() {
            return url;
        }

        public void setUrl(String url) {
            this.url = url;
        }

总结

 1. 添加
	//添加
	Boolean add(K var1, V var2, double var3);
	
	//批量添加
    Long add(K var1, Set<ZSetOperations.TypedTuple<V>> var2);
    
 2. 删除
	//删除
    Long remove(K var1, Object... var2);
    
 3. 运算
	//加减运算  var3是增量
    Double incrementScore(K var1, V var2, double var3);
    
 4. 检索

    //返回元素在集合的排名,有序集合时按照元素的score值由小到大排列
    Long rank(K var1, Object var2);

    //返回元素在集合的排名,按元素的score值由大到小排列
    Long reverseRank(K var1, Object var2);

    //获取集合的元素, 从小到大排序, start开始位置, end结束位置
    Set<V> range(K var1, long var2, long var4);

    //获取集合元素, 并且把score值也获取,
    Set<ZSetOperations.TypedTuple<V>> rangeWithScores(K var1, long var2, long var4);

    //根据Score值查询集合元素的值, 从小到大排序
    Set<V> rangeByScore(K var1, double var2, double var4);

    //根据Score值查询集合元素, 从小到大排序
    Set<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K var1, double var2, double var4);

    //根据Score值查询集合元素的值, 从小到大排序
    Set<V> rangeByScore(K var1, double var2, double var4, long var6, long var8);

    //根据Score值查询集合元素, 从小到大排序
    Set<ZSetOperations.TypedTuple<V>> rangeByScoreWithScores(K var1, double var2, double var4, long var6, long var8);

    
    Set<V> reverseRange(K var1, long var2, long var4);

    
    Set<ZSetOperations.TypedTuple<V>> reverseRangeWithScores(K var1, long var2, long var4);

    // 根据Score值查询集合元素, 从大到小排序
    Set<V> reverseRangeByScore(K var1, double var2, double var4);

    // 根据Score值查询集合元素,并且把score值也获取 从大到小排序
    Set<ZSetOperations.TypedTuple<V>> reverseRangeByScoreWithScores(K var1, double var2, double var4);

    //据score值获取集合元素数量
    Long count(K var1, double var2, double var4);

    //获取集合大小
    Long size(K var1);

    //获取集合大小
    Long zCard(K var1);

    //获取集合中value元素的score值
    Double score(K var1, Object var2);

    //移除指定索引位置的成员
    Long removeRange(K var1, long var2, long var4);

	//根据指定的score值的范围来移除成员
    Long removeRangeByScore(K var1, double var2, double var4);

    //获取var1和var2的并集并存储在var3中
    Long unionAndStore(K var1, K var2, K var3);
   

    // KEY_DD1集合与KEY_DD2集合，共同的交集元素存到KEY_DD3（复制），返回元素个数
    Long intersectAndStore(K var1, K var2, K var3);