漫谈生死狙击页游排行榜服务的迭代演进

1
/**
2
    * 实时排行榜排序.
3
    * 从排行榜最后一名开始向前检查并更新排名。
4
    * <p>1. 当var1等于null时, 比最后一名优秀, 排行榜一定变更</p>
5
    * <p>2. 当排行榜的length为0时, 排行榜一定变更， 第一名入榜</p>
6
    * <p>3. 当var1排序在bean右侧时, 玩家刷新个人记录，排行榜可能变更. 否则玩家排名不变</p>
7
    *
8
    * @param bean     新纪录
9
    * @param var0     旧记录
10
    * @param copyRank 排行榜列表
11
    */
12
protected boolean sortRank0(final B bean, final B var0, List<B> copyRank) {
13
    B var1 = var0;
14
    int endIndex;
15
    boolean isDirty = false;
16
    if (var1 == null) {
17
        var1 = bean;
18
        endIndex = copyRank.size() - 1;
19
        isDirty = true;
20
    } else {
21
        if (var1.isChanged(bean)) {
22
            var1.updateInfo(bean);
23
            setChanged(true);
24
        }
25
        if (var1.compareTo(bean) > 0) {
26
            var1.updateValue(bean);
27
            setChanged(true);
28
            endIndex = var1.curRank - 1;
29
            copyRank.remove(endIndex);
30
            endIndex--;
31
        } else {    //  排名未改变
32
            return false;
33
        }
34
    }
35
    int startIndex;
36
    if (copyRank.isEmpty()) {
37
        var1.curRank = 1;
38
        var1.lastRank = 0;
39
        copyRank.add(var1);
40
    } else {
41
        for (int i = endIndex; i >= 0; i--) {
42
            B next = copyRank.get(i);
43
            if (next.compareTo(var1) < 0) {
44
                startIndex = i + 1;
45
                var1.lastRank = var1.curRank;
46
                var1.curRank = startIndex + 1;
47
                copyRank.add(startIndex, var1);
48
                isDirty = true;
49
                break;
50
            } else {
51
                next.lastRank = next.curRank;
52
                next.curRank += 1;
53
                if (i == 0) {
54
                    var1.lastRank = var1.curRank;
55
                    var1.curRank = 1;
56
                    copyRank.add(0, var1);
57
                    isDirty = true;
58
                }
59
            }
60
        }
61
    }
62
    return isDirty;
63
}

1
@Inherited
2
@Documented()
3
@Retention(RetentionPolicy.RUNTIME)
4
@Target(ElementType.TYPE)
5
public @interface GameRankTemplate {
6

7
    /**
8
     * 排行榜的长度上限
9
     */
10
    int length() default Constant.RANK_MAX_LENGTH;
11

12
    /**
13
     * 数据库操作组件
14
     *
15
     * @return the bean's mybatis mapper.
16
     */
17
    Class<? extends GameRankBeanMapper> mapper() default DefaultGameRankBeanMapper.class;
18

19
    /**
20
     * Bean处理器. 数据加载完成后调用handler处理排行榜的数据.
21
     */
22
    Class<? extends GameRankBeanHandler> beanHandler() default RpgCharNameHandler.class;
23
}
24

25
public interface GameRankBeanMapper<T> {
26

27
    void createTable(int group);
28

29
    List<T> selectById(int group);
30

31
    void deleteById(int group);
32

33
    void batchInsert(int group, List<T> ranks);
34
}
35

36
public interface GameRankBeanHandler<T> {
37

38
    void handle(List<T> beans);
39

40
}

1
public class ReducedGameRank implements Serializable {
2

3
    /**
4
     * Unique rank identify.
5
     */
6
    private final RankConfig config;
7
    /**
8
     * The rank struct description.
9
     */
10
    private final ReducedGameRankStructDescriptor descriptor;
11
    /**
12
     * Unique player's identify and rank score mapping map.
13
     * Unique Id - Sorted Key.
14
     */
15
    protected final ConcurrentHashMap<Object, Comparable> mappingMap;
16
    /**
17
     * player's rank goal and displayed rank info map.
18
     */
19
    protected final ConcurrentSkipListMap<Comparable, RankBean> sortedMap;
20
}

1
public boolean update(final Object uniqueId, final Comparable score, final Object displayInfo) {
2
    Assert.isInstanceOf(this.descriptor.getClzOfUniqueId(), uniqueId);
3
    Assert.isInstanceOf(this.descriptor.getClzOfScore(), score);
4
    Assert.isInstanceOf(this.descriptor.getClzOfInfo(), displayInfo);
5

6
    Comparable lastScore = this.mappingMap.get(uniqueId);
7
    if (lastScore != null
8
            && lastScore.compareTo(score) < 0) {
9
        //  if display info changed. replace by newly info.
10
        RankBean bean = this.sortedMap.get(lastScore);
11
        boolean infoChanged = bean != null && !Objects.equals(bean.getInfoBean(), displayInfo);
12
        if (infoChanged) {
13
            bean.setInfoBean(displayInfo);
14
            this.updateWithIncremental(bean, CHANGED);
15
        }
16
        return infoChanged;
17
    }
18
    if (hasMaxRankLength()) {
19
        Comparable lowest = this.lowest;
20
        if (lowest != null && lowest.compareTo(score) < 0) {
21
            return false;
22
        }
23
    }
24
    if (this.sortedMap.containsKey(score)) {
25
        LOG.error("player's rank data is conflicted. uniqueId:{}, score:{}, info:{}", uniqueId, score, displayInfo);
26
        return false;
27
    }
28
    RankBean bean = new RankBean(identify(), uniqueId, score, displayInfo, rank(uniqueId), GameClock.currentTimeMillis(), 0L, 0, true);
29
    this.lock.writeLock().lock();
30
    try {
31
        this.mappingMap.put(uniqueId, score);
32
        if (lastScore != null) {
33
            //  replace the prevent player's rank goal.
34
            RankBean prev = this.sortedMap.remove(lastScore);
35
            if (prev != null) {
36
                bean.setLastChangeDisplayFlag(prev.getLastChangeDisplayFlag());
37
                bean.setUpdateDisplayCount(prev.getUpdateDisplayCount());
38
                bean.setDisplay(prev.isDisplay());
39
            }
40
            this.updateWithIncremental(bean, CHANGED);
41
            this.sortedMap.putIfAbsent(score, bean);
42
        } else if (hasMaxRankLength()) {
43
            //  remove the lowest player's rank goal.
44
            RankBean removed = this.sortedMap.remove(this.sortedMap.lastKey());
45
            if (removed != null) {
46
                this.updateWithIncremental(removed, REMOVED);
47
            }
48
            this.updateWithIncremental(bean, ADDED);
49
            this.sortedMap.putIfAbsent(score, bean);
50
            this.lowest = this.sortedMap.lastEntry().getKey();
51
        } else {
52
            this.updateWithIncremental(bean, ADDED);
53
            this.sortedMap.putIfAbsent(score, bean);
54
            this.currentRankLength++;
55
        }
56
        this.rankChanged = true;
57
        return true;
58
    } finally {
59
        this.lock.writeLock().unlock();
60
    }
61
}