一种游戏排行榜的实现方案

// rank item
type RankItem struct {
    PlayerID string
    Socre    int
    Ts       int64
}
// Value used to get a float64 to set into Redis
func (i RankItem) Value() float64 {
    return float64(i.Score)
}

// interface
Set(item *RankItem) error
Get() ([]RankItem, error)
Del(maxRanksNum int64) (int64, error)

func (c RedisCache)Set(item *RankItem) error{
    if err := c.client.Ping().Err(); err != nil {
        // add log ,failed to ping redis
		return err
	}
    // if key $item.PlayerID is already exist, it will replace it with the new value
	err := c.client.ZAdd(pveStarRankRedisKey,
		redis.Z{Score: item.Value(), Member: item.PlayerID}).Err()
	if err != nil {
		// todo : add log, failed to set
	}
	return err
}

func (c RedisCache)Get() ([]RankItem, error) {
    if err := c.client.Ping().Err(); err != nil {
		// add log, failed to ping redis
		return nil, err
	}

    // get 0-99 in zset(key = pveStarRankRedisKey)
	results, err := c.client.ZRevRangeWithScores(pveStarRankRedisKey, 0, 99).Result()
	if err != nil {
		// add log
		return nil, err
	}
	items := make([]model.RankItem, 0, len(results))
	for _, v := range results {
		playerID := v.Member.(string)
		value := int(v.Score)
		items = append(items, model.RankItem{
			PlayerID: playerID,
			Score:    value,
		})
	}
	return items, nil
}

func (c RedisCache)Del(maxRanksNum int64) (int64, error){
    if err := c.client.Ping().Err(); err != nil {
		// add log
		return 0, err
	}

	num, err := c.client.ZCard(dbKey).Result()
	if err != nil {
		// add log
		return 0, err
	}
	availDeleteNum := num - maxRanksNum
	if availDeleteNum <= 0 {
		return 0, nil
	}
	return c.client.ZRemRangeByRank(dbKey, 0, availDeleteNum-1).Result()
}

type Rank struct {
    rankRedisCache RedisCache
    rankData       atomic.Value
}

func (p *Rank) loopRanks() {
    // get data from redis in 10 second
	var ticker = time.NewTicker(10 * time.Second)
	defer ticker.Stop()

	for range ticker.C {
		p.loadRanksFromRedis()
	}
}

func (p *Rank) loadRanksFromRedis() {
	items, err := p.rankRedisCache.Get()
	if err != nil {
        // add log
		return
	}
	if len(items) > 0 {
		p.rankData.Store(items)
	}
}

// get rank data form atomic value
func (p *Rank) GetRankData() []RankItem {
    val, _ := p.rankData.Load().([]RankItem)
	return val
}