ZYZ/game-server/app/services/redisService.ts

import { RoleModel } from "../db/Role";
import * as redis from 'redis';
import {REDIS_KEY} from '../consts/consts'

let redisArr = 'r-8vb4i2kgl91886fkxd.redis.zhangbei.rds.aliyuncs.com';
if(process.env.NODE_ENV == 'local') {
    redisArr = '127.0.0.1';
}
// 创建 redis 连接
const client = redis.createClient(6379, redisArr, {detect_buffers: true});
client.auth('zyz_2020', (err, reply) => {
    if (err) {
        console.log('redis err', err);
    } else {
        console.log('redis suc');
    }
})
client.set('hello', 'redis', redis.print);

/**
 * 在服务重新启动时，将信息存入redis
 */
export async function initRank() {
    await redisDel(REDIS_KEY.TOWER_RANK); // 清空天梯排行榜(ZSet)
    await redisDel(REDIS_KEY.USER_INFO); // 清空用户缓存信息
    let ranks = await RoleModel.getRank('tower', ['roleId', 'roleName', 'towerLv', 'lv', 'vLv']);
    for(let {towerLv, roleId, roleName, lv, vLv, towerUpTime} of ranks) {
        await redisZadd(REDIS_KEY.TOWER_RANK, encodeScoreWithTime(towerLv, towerUpTime?towerUpTime.getTime():0), roleId);
        await redisUserInfoAdd(roleId, {roleName, lv, vLv, guildName:"", head: "zhaoyun"});
    }
}

// 更新玩家信息
export async function redisUserInfoUpdate(roleId: string, arr: Array<{field: string, value:(string|number)}>) {
    let params = await redisHget(REDIS_KEY.USER_INFO, roleId);
    if(params) {
        let obj = JSON.parse(params);
        for(let {field, value} of arr) {
            obj[field] = value;
        }
        return await redisHset(REDIS_KEY.USER_INFO, roleId, JSON.stringify(obj));
    }
}

// 添加玩家信息缓存
export async function redisUserInfoAdd(roleId: string, params: {roleName: string, lv: number, vLv: number, guildName: string, head: string}) {
    let value = JSON.stringify(params);
    return await redisHset(REDIS_KEY.USER_INFO, roleId, value);
}

// 更新排行榜
export async function setRank(key: string, roleId: string, score: number, timestamp: number, params: {roleName: string, lv: number, vLv: number, guildName: string, head: string}) {
    // 更新分数
    const _score = encodeScoreWithTime(score, timestamp);
    await redisZadd(key, _score, roleId);
    // 移除100名以外
    await redisZremRangeByRank(key, 0, 100);
    // 如果没有信息，更新玩家信息
    const hasCurUser = await redisHexists(REDIS_KEY.USER_INFO, roleId);
    if(!hasCurUser) {
        await redisUserInfoAdd(roleId, params);
    }
    return true;
}

// 获取排行榜
export async function getRank(key: string, roleId: string) {
    let ranks = [], myRank = null;
    const rankFromDb = await redisZrevrangeByScore(key, '+inf', '-inf', true, 100);
    for(let ii = 0; ii < rankFromDb.length; ii+=2) {
        const _roleId = rankFromDb[ii];
        const _score = decodeScoreWithTime(rankFromDb[ii + 1]);
        const userInfo = await redisHget(REDIS_KEY.USER_INFO, _roleId);
        const _userInfo = JSON.parse(userInfo);
        const tmp = {..._userInfo, roleId: _roleId, num: _score, rank: ii%2+1}
        ranks.push(tmp);
        if(roleId == _roleId) myRank = tmp;
    }
    return {ranks, myRank}
}

// 有序排行综合时间和得分排序
function encodeScoreWithTime(score: number, timestamp: number): number {
    // value = score * Math.power(10, 14) + max_time - timestamp
    let timelen = 13;
    let pow = Math.pow(10, timelen + 1);
    return score * pow + pow - 1 - timestamp
}

function decodeScoreWithTime(num: string): number {
    let timelen = 13;
    let pow = Math.pow(10, timelen + 1);
    let _num = parseInt(num);
    return Math.floor(_num/pow);
}


////// redis方法

//// key

// 在 key 存在时删除 key。
export async function redisDel(key: string) {
    return await createPromise('del', [key]);
}

//// 有序集合

// 返回有序集中指定分数区间内的成员，分数从高到低排序
export async function redisZrevrangeByScore(key: string, max: (number|string), min: (number|string), withscores: boolean, limit?:number, offset=0): Promise<Array<string>> {
    let param = [key, max, min];
    if(withscores) param.push('WITHSCORES');
    if(limit) param.push('LIMIT', offset, limit);
    return await createPromise('zrevrangebyscore', param);
}

// 向有序集合添加一个或多个成员，或者更新已存在成员的分数
export async function redisZadd(key: string, field: number, value: string) {
    return await createPromise('zadd', [key, field, value]);
}

// 获取有序集合的成员数
export async function redisZcard(key: string) {
    return await createPromise('zcard', [key]);
}

// 移除有序集合中给定的排名区间的所有成员
export async function redisZremRangeByRank(key: string, start: number, stop: number) {
    return await createPromise('zremrangebyrank', [key, start, stop]);
}

//// 哈希

// 将哈希表 key 中的字段 field 的值设为 value
export async function redisHset(key: string, field: string, value: string) {
    return await createPromise('hset', [key, field, value]);
}

// 获取存储在哈希表中指定字段的值。
export async function redisHget(key: string, field: string) {
    return await createPromise('hget', [key, field]);
}

// 获取存储在哈希表中指定字段的值。
export async function redisHexists(key: string, field: string) {
    return await createPromise('hexists', [key, field]);
}

///// 封装promise
function createPromise(type: string, params: Array<string|number|any>):Promise<any> {
    return new Promise((resolve, reject) => {
        const cb = function(err: Error, result: any) {
            if(err) {
                reject(err);
            } else {
                resolve(result);
            }
        };
        client[type].apply(client, [...params, cb]);
    });
}