最近復盤專案的時候，把CTF平臺中實時榜單的后端設計部分整理了一下，在此分享出來，

1.CTF平臺實時榜單功能介紹（需求分析）

線上CTF競賽（奪旗賽）通常是在限定的時間內訪問題目，解出flag后在平臺上提交，提交后能夠獲得一定的分數，最后會按總分進行排序確定此次競賽的成績，

在CTF競賽中，榜單功能是訪問量最高的一個功能，通過查看榜單的排名，做題情況，能夠感知題目的難度，方便及時調整團隊做題的策略，這個榜單通常需要反映全部戰隊的一個做題情況，包括每個題的解出情況，大致如下圖（截圖來自i春秋，第二屆“祥云杯”網路安全大賽暨吉林省第四屆大學生網路安全大賽），

大致會有如下功能：

• 1.整體按總分進行排序，
• 2.對于每一行，除了顯示戰隊的基礎資訊，總分之外，還會顯示每一個題目的解出情況，包括是否一二三血，
• 3.實時榜單，有任何題目解出情況，題目變動情況（增刪題目），總榜單都會實時變動，

實時榜單功能作為整個CTF平臺最重要的功能之一，同時也是訪問量最高的一個功能，對這個功能做一個比較全面的設計是很有必要的，

2.實時榜單具體功能點特點分析

對實時榜單整個介面來說，一般具體以下特點：

• 1.介面訪問特別頻繁，特別是在比賽快結束的時候，訪問量幾憾訓翻幾倍，
• 2.比賽程序中，除了極少數簽到題，一般的題目不會集中在一個時間段內提交，實際解題成功的數量在總隊伍數里面占比較少，
• 3.一般CTF競賽會分批次的上題，也就是說：并不是比賽開始后，題目就不再變動了的，但是，上題次數不多，一般集中上題1-3次，
• 4.一般CTF題目的數量不會太多，總題目一般就20-50道左右，
• 5.一般參賽隊伍數不會太多，一般參賽隊伍一般在100-1500左右，
• 6.排名是實時會變動的，

3.難點分析

從上面的具體情況可以發現，其實整體的排序計算開銷是非常小的，因為隊伍數和題目數都非常少，主要的開銷集中在資料庫IO，而榜單介面的訪問并發非常大，如果每次訪問的請求最終都打到資料庫上，很有可能造成資料庫宕機，

如果簡單的對榜單進行快取，那么只要有人交題，就會導致快取失效，這個時候還是有可能導致資料庫宕機，

因此我們要設計好對榜單的快取機制，盡量少訪問資料庫，

4.整體設計思路

通過上面的分析，我們設計榜單的關鍵就在如何在整個榜單維護在redis快取中，從而降低資料庫的查詢次數，

在比賽期間，我們完全可以將整個榜單全部快取到redis中，當比賽結束時，如果再次查詢榜單（這個時候這個介面的訪問量已經非常少了），我們可以從資料庫中查出并將整個榜單存盤到資料庫中（因為此時整個榜單已經不會再變動），

我們如果要保證快取中的榜單總是實時正確的，就需要在有任何隊伍分數發生變化的時候或者新增題目的時候，重新生成整份榜單并存回redis中，注意，這個時候，我們不需要從資料庫中查詢記錄，只需要把提交記錄保存到資料庫，并且重新生成快取即可，

除此之外，我們還需要注意一個問題，因為很有可能會出現多個執行緒對redis完成讀，更新，寫入的一個事務，這其中是存在執行緒安全問題的，針對上述提交正確次數不會過于集中的情況，我們可以對每個更新事務加鎖來解決執行緒安全的問題，

總結一下：整體設計思路是：比賽程序中把榜單維護在redis中，比賽結束后，再將整份榜單記錄寫入到資料庫，

5.部分涉及的物體類介紹

以下物體類我只將與榜單功能相關的欄位寫出來了，實際情況可以再添加更多的欄位，

5.1 Team類

存盤團隊資訊的物體類，和資料庫欄位一一對應，

/**
 * @author ATFWUS
 * @version 1.0
 * @date 2021/11/12 16:48
 * @description
 */
public class Team {
    // 團隊名稱
    private String teamName;
    // 團隊id
    private String id;
    // 公司或學校名稱
    private String belongName;
    // 組隊性質
    private String companyOrSchool;

    public String getTeamName() {
        return teamName;
    }

    public void setTeamName(String teamName) {
        this.teamName = teamName;
    }

    public String getId() {
        return id;
    }

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

    public String getBelongName() {
        return belongName;
    }

    public void setBelongName(String belongName) {
        this.belongName = belongName;
    }

    public String getCompanyOrSchool() {
        return companyOrSchool;
    }

    public void setCompanyOrSchool(String companyOrSchool) {
        this.companyOrSchool = companyOrSchool;
    }

    @Override
    public String toString() {
        return "Team{" +
                "teamName='" + teamName + '\'' +
                ", id='" + id + '\'' +
                ", belongName='" + belongName + '\'' +
                ", companyOrSchool='" + companyOrSchool + '\'' +
                '}';
    }
}

5.2 Problem類

題目的物體類，和資料庫欄位一一對應，

/**
 * @author ATFWUS
 * @version 1.0
 * @date 2021/11/12 16:49
 * @description
 */
public class Problem {

    // 題目id
    private String problemId;
    // 題目名稱
    private String problemName;
    // 題目型別
    private String tag;
    // 題目分數
    private Double score;

    public String getProblemId() {
        return problemId;
    }

    public void setProblemId(String problemId) {
        this.problemId = problemId;
    }

    public String getProblemName() {
        return problemName;
    }

    public void setProblemName(String problemName) {
        this.problemName = problemName;
    }

    public String getTag() {
        return tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Preoblem{" +
                "problemId='" + problemId + '\'' +
                ", problemName='" + problemName + '\'' +
                ", tag='" + tag + '\'' +
                ", score=" + score +
                '}';
    }
}

5.3 ProblemSolveRecord

解題記錄，和資料庫欄位一一對應，在使用的時候，是篩選出了所有提交正確的記錄，

/**
 * @author ATFWUS
 * @version 1.0
 * @date 2021/11/12 18:21
 * @description 成功解題記錄
 */
public class ProblemSolveRecord {
    // 題目id
    private String problemId;
    // 解出團隊
    private String teamId;
    // 解出人
    private String userId;
    // 題目名稱
    private String problemName;
    // 題目型別
    private String tag;
    // 題目得分
    private Double getScore;
    // 是否一血
    private Boolean firstBlood;
    // 是否二血
    private Boolean secondBlood;
    // 是否三血
    private Boolean tribleBlood;

    public String getProblemId() {
        return problemId;
    }

    public void setProblemId(String problemId) {
        this.problemId = problemId;
    }

    public String getTeamId() {
        return teamId;
    }

    public void setTeamId(String teamId) {
        this.teamId = teamId;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getProblemName() {
        return problemName;
    }

    public void setProblemName(String problemName) {
        this.problemName = problemName;
    }

    public String getTag() {
        return tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    public Double getGetScore() {
        return getScore;
    }

    public void setGetScore(Double getScore) {
        this.getScore = getScore;
    }

    public Boolean getFirstBlood() {
        return firstBlood;
    }

    public void setFirstBlood(Boolean firstBlood) {
        this.firstBlood = firstBlood;
    }

    public Boolean getSecondBlood() {
        return secondBlood;
    }

    public void setSecondBlood(Boolean secondBlood) {
        this.secondBlood = secondBlood;
    }

    public Boolean getTribleBlood() {
        return tribleBlood;
    }

    public void setTribleBlood(Boolean tribleBlood) {
        this.tribleBlood = tribleBlood;
    }
}

5.4 ProblemSolve

不是資料庫中表對應的物體類，代表對某個隊伍來說，具體某個題目的解題情況，用于榜單每一行的題目顯示，相關欄位可以從上述ProblemSolveRecord物件中拷貝，

/**
 * @author ATFWUS
 * @version 1.0
 * @date 2021/11/11 22:11
 * @description 具體題目情況
 */
public class ProblemSolve {
    // 題目id
    private String problemId;
    // 題目名稱
    private String problemName;
    // 題目型別
    private String tag;
    // 題目得分
    private Double getScore;
    // 是否一血
    private Boolean firstBlood;
    // 是否二血
    private Boolean secondBlood;
    // 是否三血
    private Boolean tribleBlood;

    public ProblemSolve(String problemId, String problemName, String tag) {
        this.problemId = problemId;
        this.problemName = problemName;
        this.tag = tag;
    }

    public String getProblemId() {
        return problemId;
    }

    public void setProblemId(String problemId) {
        this.problemId = problemId;
    }

    public String getProblemName() {
        return problemName;
    }

    public void setProblemName(String problemName) {
        this.problemName = problemName;
    }

    public String getTag() {
        return tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    public Double getGetScore() {
        return getScore;
    }

    public void setGetScore(Double getScore) {
        this.getScore = getScore;
    }

    public Boolean getFirstBlood() {
        return firstBlood;
    }

    public void setFirstBlood(Boolean firstBlood) {
        this.firstBlood = firstBlood;
    }

    public Boolean getSecondBlood() {
        return secondBlood;
    }

    public void setSecondBlood(Boolean secondBlood) {
        this.secondBlood = secondBlood;
    }

    public Boolean getTribleBlood() {
        return tribleBlood;
    }

    public void setTribleBlood(Boolean tribleBlood) {
        this.tribleBlood = tribleBlood;
    }
}

5.5 OneTotalRecord

代表榜單中的一行記錄，包含了一行需要顯示的所有記錄欄位，其中對于這個團隊來說的所有解題情況，都可以靠titles集合來遍歷，

注意這里將成功解題的方法添加到了物體類中，

/**
 * @author ATFWUS
 * @version 1.0
 * @date 2021/11/11 21:53
 * @description 總榜單條資料
 */
public class OneTotalRecord {
    // 團隊名稱
    private String teamName;
    // 團隊id
    private String id;
    // 公司或學校名稱
    private String belongName;
    // 組隊性質
    private String companyOrSchool;
    // 團隊總解題數
    private Integer totalSolveNum;
    // 團隊總分
    private Double totalScore;
    // 一血數
    private Integer firstBlood;
    // 最后一次成功提交時間
    private Date lastSolveTime;
    // 所有解題資料 具體的分類由前端進行分類
    private List<ProblemSolve> titles = new LinkedList<>();

    public OneTotalRecord(){

    }

    public OneTotalRecord(String teamName, String id, String belongName, String companyOrSchool){

    }

    public String getTeamName() {
        return teamName;
    }

    public void setTeamName(String teamName) {
        this.teamName = teamName;
    }

    public String getBelongName() {
        return belongName;
    }

    public void setBelongName(String belongName) {
        this.belongName = belongName;
    }

    public String getCompanyOrSchool() {
        return companyOrSchool;
    }

    public void setCompanyOrSchool(String companyOrSchool) {
        this.companyOrSchool = companyOrSchool;
    }

    public Integer getTotalSolveNum() {
        return totalSolveNum;
    }

    public void setTotalSolveNum(Integer totalSolveNum) {
        this.totalSolveNum = totalSolveNum;
    }

    public Double getTotalScore() {
        return totalScore;
    }

    public void setTotalScore(Double totalScore) {
        this.totalScore = totalScore;
    }

    public Integer getFirstBlood() {
        return firstBlood;
    }

    public void setFirstBlood(Integer firstBlood) {
        this.firstBlood = firstBlood;
    }

    public String getId() {
        return id;
    }

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

    public Date getLastSolveTime() {
        return lastSolveTime;
    }

    public void setLastSolve(Date lastSolve) {
        this.lastSolveTime = lastSolve;
    }

    public List<ProblemSolve> getTitles() {
        return titles;
    }

    public void setTitles(List<ProblemSolve> titles) {
        this.titles = titles;
    }

    public void solveOneProblem(ProblemSolve solve){
        for(ProblemSolve problemSolve : titles){
            if(problemSolve.getProblemId().equals(solve.getProblemId())){
                problemSolve.setGetScore(solve.getGetScore());
                problemSolve.setFirstBlood(solve.getFirstBlood());
                problemSolve.setSecondBlood(solve.getSecondBlood());
                problemSolve.setTribleBlood(solve.getTribleBlood());
                totalScore += solve.getGetScore();
                break;
            }
        }
    }

    @Override
    public String toString() {
        return "OneTotalRecord{" +
                "teamName='" + teamName + '\'' +
                ", id='" + id + '\'' +
                ", belongName='" + belongName + '\'' +
                ", companyOrSchool='" + companyOrSchool + '\'' +
                ", totalSolveNum=" + totalSolveNum +
                ", totalScore=" + totalScore +
                ", firstBlood=" + firstBlood +
                ", titles=" + titles +
                '}';
    }
}

6.具體業務功能ServeiceImpl設計

針對上述需求分析，我們的榜單的Service介面只需要三個public方法即可，

• 1.public List<OneTotalRecord> getAllRecord(String competitionId) 獲取指定比賽的榜單，
• 2.public void addOneSolution(String competitionId, String teamId, ProblemSolve problemSolve) 新增一條成功解題記錄時，更新榜單，
• 3.public void addOneProblem(String competitionId, Problem problem) 新增一個題目的時候，更新邏輯，（可以在批量上題完畢后呼叫一次）

這里沒有給出洗掉題目的方法，因為比賽程序中洗掉題目會有很多種不同的處理邏輯，需要自行去實作處理邏輯，

6.1 獲取榜單方法 getAllRecord

總體思路就是，先從redis中獲取，redis中有直接回傳，沒有就先判斷一下是否是初始化榜單（沒有任何成功解題記錄就是初始化榜單），如果不是初始化（說明此時快取失效，需要從資料庫中查出），然后獲得操作榜單的鎖，開始從資料庫中查出記錄，生成整個榜單，

    public List<OneTotalRecord> getAllRecord(String competitionId){
        // 1.從redis中查詢，如果存在，直接反序列化成物件后回傳
        List<OneTotalRecord> redisRecords = getRecordsAllRedis(competitionId);
        if(redisRecords != null){
            return redisRecords;
        }

        // 如果redis中不存在
        // 2.資料庫查詢出當前比賽是否有成功的解題記錄 如果沒有，進入初始化流程，初始化后直接回傳
        if(checkValidSolve(competitionId)){
            return initRecord(competitionId);
        }
        lock.lock();
        try{
            // 某個執行緒獲得鎖時已經成功初始化
            redisRecords = getRecordsAllRedis(competitionId);
            if(redisRecords != null){
                return redisRecords;
            }
            // 此時資料庫中有對應的解題記錄，但是redis中沒有快取，很有可能是快取失效 那么需要從資料庫中查出所有解題記錄，生成榜單
            // 3.查詢對應榜單
            List<ProblemSolveRecord> solveRecords = getCompetitionSolveRecord(competitionId);
            // 將榜單串列轉化為map 鍵為團隊id 值為解題串列
            Map<String, List<ProblemSolveRecord>> solveMap = new HashMap<>();
            for(ProblemSolveRecord solveRecord : solveRecords){
                if(solveMap.containsKey(solveRecord.getTeamId())){
                    solveMap.get(solveRecord.getTeamId()).add(solveRecord);
                }else{
                    solveMap.put(solveRecord.getTeamId(), new ArrayList<ProblemSolveRecord>());
                    solveMap.get(solveRecord.getTeamId()).add(solveRecord);
                }
            }
            // 4.查詢出所有團隊
            List<Team> teams = getAllCompetitionTeam(competitionId);
            if(teams.size() == 0){
                return null;
            }
            // 5.查詢出所有的題目
            List<Problem> problems = getAllCompetitionProblem(competitionId);
            // 6.初始化每一條記錄 數量固定，使用ArrayList
            List<OneTotalRecord> records = new ArrayList<>(teams.size());
            for(Team team : teams){
                // 初始化基本資訊
                OneTotalRecord record = new OneTotalRecord(team.getTeamName(), team.getId(), team.getBelongName(), team.getCompanyOrSchool());
                List<ProblemSolve> solveProblemList = record.getTitles();
                // 初始化題目資訊
                for(Problem problem : problems){
                    // 初始化解題記錄
                    solveProblemList.add(new ProblemSolve(problem.getProblemId(), problem.getProblemName(), problem.getTag()));
                }
                if(solveMap.containsKey(team.getId())){
                    List<ProblemSolveRecord> solveRecordList = solveMap.get(team.getId());
                    // 遍歷當前團隊解出的每一個題
                    for(int i = 0; i < solveRecordList.size(); i++){
                        ProblemSolveRecord solveRecord = solveRecordList.get(i);
                        String problemId = solveRecord.getProblemId();
                        // 尋找每一個題目對應的記錄
                        for(ProblemSolve problemSolve : solveProblemList){
                            // 找到了對應的解題記錄
                            if(problemSolve.getProblemId().equals(problemId)){
                                problemSolve.setGetScore(solveRecord.getGetScore());
                                problemSolve.setFirstBlood(solveRecord.getFirstBlood());
                                problemSolve.setSecondBlood(solveRecord.getSecondBlood());
                                problemSolve.setTribleBlood(solveRecord.getTribleBlood());
                                break;
                            }
                        }
                    }
                    solveMap.remove(team.getId());
                }
            }
            // 7.排序
            recordsSortByScore(records);
            // 8.存入redis
            saveRecordsToRedis(records);
            return records;
        }finally {
            lock.unlock();
        }

    }

6.2 新增解題記錄后呼叫 addOneSolution

新增成功解題記錄時，只需要獲取鎖，然后更新對應的記錄，最后對榜單重新排序即可，

    /**
     * 當新增一條解題記錄時的處理邏輯
     * @param competitionId
     * @param teamId
     * @param
     */
    public void addOneSolution(String competitionId, String teamId, ProblemSolve problemSolve){
        lock.lock();
        try{
            // 1.獲取之前的榜單
            List<OneTotalRecord> records = getAllRecord(competitionId);
            // 2.找到指定團隊
            for(OneTotalRecord record : records){
                if(record.getId().equals(teamId)){
                    // 新增解題
                    record.solveOneProblem(problemSolve);
                    break;
                }
            }
            // 3.重新排序
            recordsSortByScore(records);
            // 4.存入redis
            saveRecordsToRedis(records);
        }finally {
            lock.unlock();
        }

    }

6.3 新上題后呼叫 addOneProblem

新上題時，獲取鎖后，往每一條拌榜單記錄里新增一條初始題目記錄即可，

    /**
     * 后臺新上了題目
     * @param problem
     */
    public void addOneProblem(String competitionId, Problem problem){
        lock.lock();
        try{
            // 1.獲取之前的榜單
            List<OneTotalRecord> records = getAllRecord(competitionId);
            // 2.給每條資料新增一個題目
            for(OneTotalRecord record : records){
                record.getTitles().add(new ProblemSolve(problem.getProblemId(), problem.getProblemName(), problem.getTag()));
            }
            // 3.無需重新排序 直接存入redis
            saveRecordsToRedis(records);
        }finally {
            lock.unlock();
        }
    }

6.4 完整service

將原本專案中的serviceImpl的關鍵方法抽離出來重新處理了一下，只需要按照需求拓展物體類，重寫這些方法就可以放在專案中使用，

package awardList;

import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author ATFWUS
 * @version 1.0
 * @date 2021/11/12 16:29
 * @description
 */
public class RecordServiceImpl {

    private final ReentrantLock lock = new ReentrantLock();

    public List<OneTotalRecord> getAllRecord(String competitionId){
        // 1.從redis中查詢，如果存在，直接反序列化成物件后回傳
        List<OneTotalRecord> redisRecords = getRecordsAllRedis(competitionId);
        if(redisRecords != null){
            return redisRecords;
        }

        // 如果redis中不存在
        // 2.資料庫查詢出當前比賽是否有成功的解題記錄 如果沒有，進入初始化流程，初始化后直接回傳
        if(checkValidSolve(competitionId)){
            return initRecord(competitionId);
        }
        lock.lock();
        try{
            // 某個執行緒獲得鎖時已經成功初始化
             redisRecords = getRecordsAllRedis(competitionId);
            if(redisRecords != null){
                return redisRecords;
            }
            // 此時資料庫中有對應的解題記錄，但是redis中沒有快取，很有可能是快取失效 那么需要從資料庫中查出所有解題記錄，生成榜單
            // 3.查詢對應榜單
            List<ProblemSolveRecord> solveRecords = getCompetitionSolveRecord(competitionId);
            // 將榜單串列轉化為map 鍵為團隊id 值為解題串列
            Map<String, List<ProblemSolveRecord>> solveMap = new HashMap<>();
            for(ProblemSolveRecord solveRecord : solveRecords){
                if(solveMap.containsKey(solveRecord.getTeamId())){
                    solveMap.get(solveRecord.getTeamId()).add(solveRecord);
                }else{
                    solveMap.put(solveRecord.getTeamId(), new ArrayList<ProblemSolveRecord>());
                    solveMap.get(solveRecord.getTeamId()).add(solveRecord);
                }
            }
            // 4.查詢出所有團隊
            List<Team> teams = getAllCompetitionTeam(competitionId);
            if(teams.size() == 0){
                return null;
            }
            // 5.查詢出所有的題目
            List<Problem> problems = getAllCompetitionProblem(competitionId);
            // 6.初始化每一條記錄 數量固定，使用ArrayList
            List<OneTotalRecord> records = new ArrayList<>(teams.size());
            for(Team team : teams){
                // 初始化基本資訊
                OneTotalRecord record = new OneTotalRecord(team.getTeamName(), team.getId(), team.getBelongName(), team.getCompanyOrSchool());
                List<ProblemSolve> solveProblemList = record.getTitles();
                // 初始化題目資訊
                for(Problem problem : problems){
                    // 初始化解題記錄
                    solveProblemList.add(new ProblemSolve(problem.getProblemId(), problem.getProblemName(), problem.getTag()));
                }
                if(solveMap.containsKey(team.getId())){
                    List<ProblemSolveRecord> solveRecordList = solveMap.get(team.getId());
                    // 遍歷當前團隊解出的每一個題
                    for(int i = 0; i < solveRecordList.size(); i++){
                        ProblemSolveRecord solveRecord = solveRecordList.get(i);
                        String problemId = solveRecord.getProblemId();
                        // 尋找每一個題目對應的記錄
                        for(ProblemSolve problemSolve : solveProblemList){
                            // 找到了對應的解題記錄
                            if(problemSolve.getProblemId().equals(problemId)){
                                problemSolve.setGetScore(solveRecord.getGetScore());
                                problemSolve.setFirstBlood(solveRecord.getFirstBlood());
                                problemSolve.setSecondBlood(solveRecord.getSecondBlood());
                                problemSolve.setTribleBlood(solveRecord.getTribleBlood());
                                break;
                            }
                        }
                    }
                    solveMap.remove(team.getId());
                }
            }
            // 7.排序
            recordsSortByScore(records);
            // 8.存入redis
            saveRecordsToRedis(records);
            return records;
        }finally {
            lock.unlock();
        }

    }

    /**
     * 當新增一條解題記錄時的處理邏輯
     * @param competitionId
     * @param teamId
     * @param
     */
    public void addOneSolution(String competitionId, String teamId, ProblemSolve problemSolve){
        lock.lock();
        try{
            // 1.獲取之前的榜單
            List<OneTotalRecord> records = getAllRecord(competitionId);
            // 2.找到指定團隊
            for(OneTotalRecord record : records){
                if(record.getId().equals(teamId)){
                    // 新增解題
                    record.solveOneProblem(problemSolve);
                    break;
                }
            }
            // 3.重新排序
            recordsSortByScore(records);
            // 4.存入redis
            saveRecordsToRedis(records);
        }finally {
            lock.unlock();
        }

    }

    /**
     * 后臺新上了題目
     * @param problem
     */
    public void addOneProblem(String competitionId, Problem problem){
        lock.lock();
        try{
            // 1.獲取之前的榜單
            List<OneTotalRecord> records = getAllRecord(competitionId);
            // 2.給每條資料新增一個題目
            for(OneTotalRecord record : records){
                record.getTitles().add(new ProblemSolve(problem.getProblemId(), problem.getProblemName(), problem.getTag()));
            }
            // 3.無需重新排序 直接存入redis
            saveRecordsToRedis(records);
        }finally {
            lock.unlock();
        }
    }


    /**
     * 初始化一份榜單資料
     * @param competitionId
     * @return
     */
    private List<OneTotalRecord> initRecord(String competitionId){
        lock.lock();
        try{
            // 某個執行緒獲得鎖時已經成功初始化
            List<OneTotalRecord> redisRecords = getRecordsAllRedis(competitionId);
            if(redisRecords != null){
                return redisRecords;
            }
            // 1.先查詢出所有的隊伍
            List<Team> teams = getAllCompetitionTeam(competitionId);
            if(teams.size() == 0){
                return null;
            }
            // 2.查詢出所有的題目
            List<Problem> problems = getAllCompetitionProblem(competitionId);
            // 3.初始化每一條記錄 數量固定，使用ArrayList
            List<OneTotalRecord> records = new ArrayList<>(teams.size());
            for(Team team : teams){
                // 初始化基本資訊
                OneTotalRecord record = new OneTotalRecord(team.getTeamName(), team.getId(), team.getBelongName(), team.getCompanyOrSchool());
                List<ProblemSolve> solveProblemList = record.getTitles();
                // 初始化題目資訊
                for(Problem problem : problems){
                    solveProblemList.add(new ProblemSolve(problem.getProblemId(), problem.getProblemName(), problem.getTag()));
                }
            }
            // 4.排序
            recordsSortById(records);
            // 5.存入redis中
            saveRecordsToRedis(records);
            return records;
        }finally {
            lock.unlock();
        }

    }

    /**
     * 對榜單按按照Id排序
     * @param records
     */
    private void recordsSortById(List<OneTotalRecord> records){
        Collections.sort(records, new Comparator<OneTotalRecord>() {
            @Override
            public int compare(OneTotalRecord o1, OneTotalRecord o2) {
                return o1.getId().compareTo(o2.getId());
            }
        });
    }

    /**
     * 對榜單按照總分排序
     * @param records
     */
    private void recordsSortByScore(List<OneTotalRecord> records){
        Collections.sort(records, new Comparator<OneTotalRecord>() {
            @Override
            public int compare(OneTotalRecord o1, OneTotalRecord o2) {
                // 先按總分排
                if(o2.getTotalScore().compareTo(o1.getTotalScore()) != 0){
                    return o2.getTotalScore().compareTo(o1.getTotalScore());
                }
                // 再按解出時間排序
                return o1.getLastSolveTime().compareTo(o2.getLastSolveTime());
            }
        });
    }



    private List<ProblemSolveRecord> getCompetitionSolveRecord(String competitionId){
        return new ArrayList<>();
    }


    /**
     *
     * @param competitionId
     * @return 當前比賽是否有成功解題記錄
     */
    private boolean checkValidSolve(String competitionId){
        // TODO 需要重寫 從資料庫中查詢當前比賽是否有成功解題記錄
        return false;
    }

    /**
     * 將榜單資料存盤到redis中
     * @param records
     */
    private void saveRecordsToRedis(List<OneTotalRecord> records){
        // TODO 需要重寫 將榜單資料保存至redis中
    }

    /**
     *
     * @param competitionId
     * @return 總榜單資料
     */
    private List<OneTotalRecord> getRecordsAllRedis(String competitionId){
        // TODO 需要重寫 從redis中查詢出對應比賽榜單
        return null;
    }

    /**
     *
     * @param competitionId
     * @return 所有參賽團隊
     */
    private List<Team> getAllCompetitionTeam(String competitionId){
        // TODO 需要重寫 從資料庫中查詢所有參賽團隊
        return new ArrayList<>();
    }

    /**
     *
     * @param competitionId
     * @return 所有比賽題目
     */
    private List<Problem> getAllCompetitionProblem(String competitionId){
        // TODO 需要重寫 從資料庫中查詢所有賽題
        return new ArrayList<>();
    }
}

6.5 實作細節

6.5.1 如何確定具體的資料結構？

存盤總記錄的資料結構的選擇（ArrayList）

比賽一開始，就不可以再報名，也就是說，比賽程序中榜單的總記錄數是確定的，不涉及動態插入洗掉的需求，所以可以直接使用ArryList，并且可以在構造方法中顯示的傳入大小，

存盤單條記錄的所有題目的資料結構的選擇（LinkedList）

比賽題目會涉及動態的添加或洗掉，此時選擇雙鏈表實作的LinkedList更好，

存盤資料庫中解題記錄的資料結構的選擇（HashMap）

因為總記錄是使用List存盤的，所以要找到指定的隊伍添加解題記錄，就需要遍歷整個List，如果我們將解題記錄存放到Map中，鍵為團隊ID，值為該團隊解題記錄的鏈表，這樣只需要遍歷一次即可把一個團隊的解題記錄全部添加，

6.5.2 為何要加鎖

Spring默認的Service物件是單例物件，當多個執行緒訪問的時候，訪問的是同一個方法，此時，redis中存盤的榜單，就相當于是共享資料，多個執行緒對共享資料的操作，就需要考慮執行緒安全的問題，

6.5.3 雙檢鎖思想

在初始化榜單和重寫從資料庫查出記錄生成榜單的方法中，可以看到一個細節，在獲得鎖后，還是需要判斷一下redis中是否存在，這就是典型的雙檢鎖思想，確保redis中的記錄只生成唯一一次，

6.5.4 redis快取策略如何設定

在代碼中并沒有給出redis具體快取策略怎么實作，但是可以知道存盤的都是榜單物件序列化后的結果，這樣將所有對榜單的操作都放在java層中，耦合度小很多，

關于過期時間的策略，建議可以設定久一點，比如一個小時，反正如果榜單有變動，會及時重繪，

6.5.5 比賽時間到后如何處理榜單

比賽程序中，榜單全部在redis中，一旦比賽結束，榜單將不會再變動，這時候可以從資料庫中查出對應的記錄生成一份最終的榜單，序列化后存入資料庫中，或者為每個戰隊生成一條記錄（包含排名）存到資料庫中，

7.設計方案總結

7.1 優點

• 比賽程序中，榜單幾乎從redis中獲取，解決了比賽程序中榜單介面呼叫頻繁導致資料庫壓力過大的問題，
• 這個設計方案，回傳的榜單包含了所需的所有資訊，前端只需要按tag分一下類即可展示，
• 效率高，解決了執行緒安全問題，

7.2 缺陷

• 使用了直接加鎖的方式來解決執行緒安全問題，一旦某個題出現集中提交且正確的情況，那么會有多個執行緒阻塞，執行緒數堆積過多，可能會導致oom，
• 在很多地方，仍然使用的直接遍歷的方式去查找指定的戰隊，如果戰隊數過多，這個時間消耗也會很大，
• 對于動態分數的比賽機制，沒有很好的支持，

7.3 改進思路

• 在應用層采用信號量的方式，限制提交題目介面的并發次數，
• 空間換時間，對所有戰隊，將其維護在一個哈希表中，這樣每次找到這個戰隊，只需要O（1）的時間即可，
• 如果采用動態分數制，那么將所有題目和解出數全部維護在redis中，在排序前，先更新每個戰隊每個題目的分數，

ATFWUS 2021-11-14