【排行榜】1.控制台 2.lettuce版本 3.Redisson

.net core game

已于 2024-07-03 12:27:39 修改

阅读量387

点赞数 8

分类专栏： # redis 文章标签： java 服务器

于 2024-01-20 17:07:35 首次发布

本文链接：https://blog.csdn.net/themagickeyjianan/article/details/135718434

版权

redis 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

背景：

这次游戏中台采用lettuce的zset完成游戏内的本服和跨服排行榜，因此写一下案例。

参考: Redis zset 的一些操作命令-CSDN博客

demo1:先用控制台测试下(lettuce与控制台api是一样的)

// step1:zincrby如果没有数据则相当于zadd(直接设置值), 给这个人分别添加2次分数
127.0.0.1:6379> zincrby warrank 10 jn
"10"
127.0.0.1:6379> zincrby warrank 5 jn
"15"

127.0.0.1:6379> zincrby warrank 20 xx
"20"
127.0.0.1:6379> zincrby warrank 5 jj
"5"

// step2: 查看排行榜列表,并且带上分数(由于需要分数从大到小，因此需要倒序)
127.0.0.1:6379> zrevrange warrank 0 -1 withscores
1) "xx"
2) "20"
3) "jn"
4) "15"
5) "jj"
6) "5"

// step3: 更新一个成员的值
127.0.0.1:6379> zadd warrank 1 jn
(integer) 0

127.0.0.1:6379> zrevrange warrank 0 -1 withscores
1) "xx"
2) "20"
3) "jj"
4) "5"
5) "jn"
6) "1"

// step4: 删除榜单
127.0.0.1:6379> del warrank
(integer) 1
127.0.0.1:6379> zrevrange warrank 0 -1 withscores
(empty list or set)

// step5:查询指定人的排名，注意：是需要+1，redis是从0开始的
127.0.0.1:6379> zrevrank warrank jj
(integer) 2
127.0.0.1:6379> zrevrank warrank xx
(integer) 1

// step6: 获取排行榜中人的数量
127.0.0.1:6379> zcard warrank
(integer) 4

demo2：lettuce版本

pom.xml

    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>30.0-jre</version>
    </dependency>

    <dependency>
      <groupId>io.lettuce</groupId>
      <artifactId>lettuce-core</artifactId>
      <version>6.2.4.RELEASE</version>
<!--      <exclusions>-->
<!--        <exclusion>-->
<!--          <artifactId>netty-common</artifactId>-->
<!--          <groupId>io.netty</groupId>-->
<!--        </exclusion>-->
<!--        <exclusion>-->
<!--          <artifactId>netty-handler</artifactId>-->
<!--          <groupId>io.netty</groupId>-->
<!--        </exclusion>-->
<!--        <exclusion>-->
<!--          <artifactId>netty-transport</artifactId>-->
<!--          <groupId>io.netty</groupId>-->
<!--        </exclusion>-->
<!--      </exclusions>-->
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.4</version>
      <scope>provided</scope>
    </dependency>

RedisManager.java

package org.example.testRank.manager;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.async.RedisAsyncCommands;
import io.lettuce.core.api.sync.RedisCommands;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.time.Duration;

@Slf4j
public class RedisManager {

    private static RedisManager instance = new RedisManager();

    private RedisClient redisClient;
    private StatefulRedisConnection<String, String> connection;

    /*** async */
    @Getter
    private RedisAsyncCommands<String, String> asyncCommands;

    /*** sync*/
    @Getter
    private RedisCommands<String, String> commands;

    public static RedisManager inst() {
        return instance;
    }

    public void init(String host, int port) {
        int dbIndex = 0;
        int timeout = 10;

        try {
            RedisURI uri = RedisURI.builder()
                    .withHost(host)
                    .withPort(port)
                    .withDatabase(dbIndex)
                    .withTimeout(Duration.ofSeconds(timeout)).build();

            redisClient = RedisClient.create(uri);
            connection = redisClient.connect();
            asyncCommands = connection.async();
            commands = connection.sync();
        } catch (Exception e) {
            log.error("redis init error=", e);
        }
    }

    public void close() {
        if (connection != null) {
            connection.close();
        }
        if (redisClient != null) {
            redisClient.close();
        }
    }
}

RankManager.java

package org.example.testRank.manager;

import com.google.common.collect.Lists;
import io.lettuce.core.RedisFuture;
import io.lettuce.core.ScoredValue;
import lombok.extern.slf4j.Slf4j;
import org.example.testRank.model.RankInfo;
import org.example.testRank.model.RankItem;

import java.math.BigDecimal;
import java.util.List;

@Slf4j
public class RankManager {
    private static RankManager instance = new RankManager();

    public static RankManager inst() {
        return instance;
    }

    /**
     * 尝试上榜
     * @param rankKey     排行榜类型
     * @param uid         玩家id
     * @param num         得分
     * @param increment   是否是增加 false的话直接设置为得分
     */
    public void updateRank(String rankKey, long uid, double num, boolean increment) {
        RedisFuture<Double> future = RedisManager.inst().getAsyncCommands().zscore(rankKey, uid + "");
        future.whenCompleteAsync((v, e) -> {
            if (increment && v != null) {
                RedisManager.inst().getAsyncCommands().zadd(rankKey, addNumAndGetScoreWithTime(v.doubleValue(), num), String.valueOf(uid));
            } else {
                RedisManager.inst().getAsyncCommands().zadd(rankKey, getScoreWithTime(num), String.valueOf(uid));
            }
        });
    }


    /**
     * 获取排行榜列表 + 自己的排名
     */
    public RankInfo getRankInfo(String rankKey, int start, int end, long selfUid) {
        RankInfo rankInfo = new RankInfo();

        List<RankItem> rankItems = Lists.newArrayList();

        List<ScoredValue<String>> list = RedisManager.inst().getCommands().zrevrangeWithScores(rankKey, start, end);

        int userRank = start;
        for (ScoredValue<String> scoredValue : list) {
            userRank++;
            String uid = scoredValue.getValue();
            double score = getRealScore(scoredValue.getScore());
            rankItems.add(new RankItem(uid, userRank, (long) score));
        }

        rankInfo.setRankItems(rankItems);

        Long selfRankObj = RedisManager.inst().getCommands().zrevrank(rankKey, selfUid + "");
        Double selfScoreObj = RedisManager.inst().getCommands().zscore(rankKey, selfUid + "");

        rankInfo.setSelfRankItem(new RankItem(selfUid + "", selfRankObj == null ? 0 : selfRankObj.intValue()+1, selfScoreObj == null ? 0 : selfScoreObj.longValue()));

        return rankInfo;
    }

    private double getScoreWithTime(double score) {
        return score + (1 - Double.parseDouble("0." + System.currentTimeMillis()));
    }

    private double getRealScore(double score) {
        BigDecimal bigDecimal = new BigDecimal(score);
        String realScore = String.valueOf(bigDecimal).split("\\.")[0];
        return Double.parseDouble(realScore);
    }

    private double addNumAndGetScoreWithTime(double score, double addNum) {
        double num = getRealScore(score) + addNum;
        return getScoreWithTime(num);
    }
}

RankItem.java

package org.example.testRank.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;

@Data
@AllArgsConstructor
@ToString
public class RankItem {
    private String uid;
    private int rank;
    private long score;
}

RankInfo.java

package org.example.testRank.model;

import lombok.Data;
import lombok.ToString;

import java.util.List;

@Data
@ToString
public class RankInfo {
    private List<RankItem> rankItems;
    private RankItem selfRankItem;
}

Main.java

package org.example.testRank;

import lombok.extern.slf4j.Slf4j;
import org.example.testRank.manager.RankManager;
import org.example.testRank.manager.RedisManager;
import org.example.testRank.model.RankInfo;

@Slf4j
public class Main {
    public static String rankKey = "power_rank";

    public static void main(String[] args) {
        RedisManager.inst().init("localhost", 6379);


//        RankManager.inst().updateRank(rankKey, 1002, 10, true);
//
//        RankManager.inst().updateRank(rankKey, 1001, 10, true);

//        RankManager.inst().updateRank(rankKey, 1003, 100, true);

        RankInfo rankInfo = RankManager.inst().getRankInfo(rankKey, 0, -1, 1002);


        log.info("{}", rankInfo);
    }
}

/*
RankInfo(rankItems=[RankItem(uid=1003, rank=1, score=100), RankItem(uid=1001, rank=2, score=30), RankItem(uid=1002, rank=3, score=10)], selfRankItem=RankItem(uid=1002, rank=3, score=10))
 */

redis中查看下

demo3:测试下lettuce排行榜(创建，加积分，打印排行内容，删除排行榜)

package lettuce;

import io.lettuce.core.ScoredValue;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        // 连接redis
        RedisManager.inst().init("localhost", 6379);

        // 排行榜唯一标识
        String RANK_KEY = "warrank";

        // 为某个人加一个积分（排行榜不存在则相当于创建了排行榜）
        RedisManager.inst().getCommands().zincrby(RANK_KEY, 15, "1001");

        // 打印排行榜内容(其他信息需要根据uid进行组装)
        List<ScoredValue<String>> warrankList = RedisManager.inst().getCommands().zrevrangeWithScores(RANK_KEY, 0, -1);
        for (ScoredValue<String> scoredValue : warrankList) {
            String uid = scoredValue.getValue();
            double score = scoredValue.getScore();

            System.out.println("uid:" + uid + " score:" + score);
        }

        // 查询指定人在排行榜的排名（判空，且从0开始需要+1）
        Long rank = RedisManager.inst().getCommands().zrevrank(RANK_KEY, "1001");
        System.out.println("rank:" + (rank == null ? -1 : (rank + 1)));

        // 排行榜item的数量（判空）
        Long count = RedisManager.inst().getCommands().zcard("warrank");
        System.out.println("count:" + (count == null ? 0 : count));

        //删除排行榜
        RedisManager.inst().getCommands().del(RANK_KEY);
    }
}

总结：可见lettuce基本上和控制台版本的api保持一致

demo4：Redisson RScoredSortedSet版本

RankManager.java

package org.example.testRank;

import org.redisson.Redisson;
import org.redisson.api.RScoredSortedSet;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.ScoredEntry;
import org.redisson.config.Config;

import java.util.Collection;

public class RankManager {
    /*** 排行榜类型*/
    public static final String RANK_KEY = "RANK_KEY";

    private RScoredSortedSet<String> rank;

    public static RankManager instance = new RankManager();

    public static RankManager inst() {
        return instance;
    }

    public void init() {
        Config config = new Config();
        config.useSingleServer()
                .setAddress("redis://127.0.0.1:6379");

        RedissonClient redisson = Redisson.create(config);

        // 使用String类型编解码器
        rank = redisson.getScoredSortedSet(RANK_KEY, new StringCodec());
    }

    public void addOrUpdateRank(String rid, int score) {
        rank.add(score, rid);

        // 只保留前2名数据
        if (rank.size() > 2) {
            rank.pollFirst();
        }
    }

    public Collection<ScoredEntry<String>> getRanks() {
        return rank.entryRangeReversed(0, -1);
    }
}

Main.java

package org.example.testRank;

import org.redisson.client.protocol.ScoredEntry;

import java.util.Collection;

public class Main {
    public static void main(String[] args) {
        RankManager rankManager = RankManager.inst();
        rankManager.init();

        rankManager.addOrUpdateRank("1001", 100);
        rankManager.addOrUpdateRank("1002", 80);
        rankManager.addOrUpdateRank("1003", 90);
        rankManager.addOrUpdateRank("1005", 60);

        // 模拟此人分数提高了
        rankManager.addOrUpdateRank("1002", 200);
        rankManager.addOrUpdateRank("1005", 666);


        Collection<ScoredEntry<String>> ranks = rankManager.getRanks();
        for (ScoredEntry<String> entry : ranks) {
            String value = entry.getValue();
            Double score = entry.getScore();
            System.out.println("rid=" + value + " score=" + score);
        }

    }
}

/*
rid=1005 score=666.0
rid=1002 score=200.0
 */

总结：

1.虽然Redisson中支持泛型，但是排行榜中人家已经指定了必须通过Score进行排名，因此不可能让我们重写一个JavaBean的方式重新制定排序规则。

2.也就是使用redis实现排行榜，只能获取到uid和score，其它的摘要则要从数据库根据uid获取，然后组装好数据统一发给客户端。