Java+WebSocket實(shí)現(xiàn)簡(jiǎn)單實(shí)時(shí)雙人協(xié)同pk答題系統(tǒng)

更新時(shí)間：2025年06月18日 08:51:31 作者：皮皮林551

在實(shí)時(shí)互動(dòng)應(yīng)用中,實(shí)現(xiàn)流暢的多人協(xié)同對(duì)戰(zhàn)功能是一大挑戰(zhàn),WebSocket技術(shù),以其全雙工通信能力,提供了解決方案,本文我們就來使用WebSocket實(shí)現(xiàn)簡(jiǎn)單實(shí)時(shí)雙人協(xié)同pk答題系統(tǒng)吧

引入

引入與技術(shù)選型：

在實(shí)時(shí)互動(dòng)應(yīng)用中，實(shí)現(xiàn)流暢的多人協(xié)同對(duì)戰(zhàn)功能是一大挑戰(zhàn)。WebSocket技術(shù)，以其全雙工通信能力，提供了解決方案。不同于傳統(tǒng)HTTP請(qǐng)求的短連接，WebSocket建立持久連接，極大減少了通信延遲，為實(shí)時(shí)數(shù)據(jù)傳輸提供了理想的環(huán)境，極大減少了傳統(tǒng)HTTP輪詢的延遲，為實(shí)時(shí)游戲提供了必要的技術(shù)基礎(chǔ)。

架構(gòu)設(shè)計(jì)：

采用前后端分離，將WebSocket服務(wù)獨(dú)立部署。前端使用JavaScript建立與WebSocket服務(wù)器的連接，實(shí)現(xiàn)即時(shí)消息交換；后端則負(fù)責(zé)邏輯處理，包括玩家匹配、狀態(tài)同步等，使用Java語言，借助Spring框架的強(qiáng)大支持，構(gòu)建了穩(wěn)定的WebSocket服務(wù)。

技術(shù)細(xì)節(jié)

狀態(tài)同步：在對(duì)戰(zhàn)中，通過WebSocket實(shí)時(shí)同步玩家的操作和游戲狀態(tài)，每個(gè)動(dòng)作都通過服務(wù)器廣播給所有參與者，確保了游戲進(jìn)程的同步性和準(zhǔn)確性。

異常處理與穩(wěn)定性： 對(duì)于WebSocket連接。一旦檢測(cè)到游戲中的某一方異常斷開，系統(tǒng)會(huì)自動(dòng)結(jié)算對(duì)局。
用戶狀態(tài)設(shè)置： 用戶的狀態(tài)可粗略分為匹配中，對(duì)局中等，不同的狀態(tài)
用戶匹配機(jī)制： 項(xiàng)目中的匹配系統(tǒng)采用動(dòng)態(tài)隊(duì)列，遵循先來后到，并可以根據(jù)用戶的段位等信息進(jìn)行分開匹配，一定程度上提升用戶體驗(yàn)。
并發(fā)錯(cuò)誤避免： 在項(xiàng)目中，每一次對(duì)局的雙方用戶的狀態(tài)信息都將保存在一個(gè)hashmap當(dāng)中，實(shí)現(xiàn)一個(gè)房間的機(jī)制，標(biāo)記用戶的狀態(tài)為游戲中，防止第三用戶加入對(duì)局，引發(fā)未知錯(cuò)誤。

實(shí)現(xiàn)過程

整個(gè)對(duì)戰(zhàn)大致可以分為三個(gè)部分：對(duì)戰(zhàn)前，對(duì)戰(zhàn)中，對(duì)戰(zhàn)后。

對(duì)戰(zhàn)前： 匹配對(duì)手，匹配成功后，服務(wù)器獲取雙方的個(gè)人信息，以及單次對(duì)局中的題目列表，發(fā)送到雙方的客戶端中。
對(duì)戰(zhàn)中： 雙方用戶答題，提交答案后?？蛻舳藢⒋痤}信息發(fā)送到服務(wù)器中，服務(wù)器將其廣播到對(duì)方客戶端中。刷新雙方分?jǐn)?shù)信息。之后的每一次答題均重復(fù)其過程。
對(duì)戰(zhàn)后： 答題完畢，刷新用戶為結(jié)算狀態(tài)。服務(wù)器根據(jù)雙方得分情況判斷勝負(fù)，廣播到雙方客戶端中。

此篇先介紹后端相關(guān)

WebSocket 后端

位于ws包中

1、實(shí)體類

1). 通信信息類 ChatMessage<T>

@Data
public class ChatMessage<T> {
    /**
     * 消息類型
     */
    private MessageTypeEnum type;
    /**
     * 消息發(fā)送者
     */
    private String sender;
    /**
     * 消息接收者
     */
    private Set<String> receivers;
    
    private T data;
}

MessageTypeEnum : 指此通信信息的類型即pk中每一個(gè)階段的不同信息類型 eg匹配中詳見下文
sender : 指此通信信息的發(fā)出方這些響應(yīng)信息是由誰來發(fā)出的
Set receivers : 指此通信信息的接收方這些信息是由誰來接受這個(gè)誰可以是單個(gè)人也可以是一群人
T data : 指此信息中包含的實(shí)際數(shù)據(jù) 由 MessageTypeEnum 來確認(rèn)信息的類型，data 表示信息的數(shù)據(jù)

2). 消息類型枚舉類 MessageTypeEnum

/**
 * 消息類型

 */
public enum MessageTypeEnum {
    /**
     * 匹配對(duì)手
     */
    MATCH_USER,
    /**
     * 游戲開始
     */
    PLAY_GAME,
    /**
     * 游戲結(jié)束
     */
    GAME_OVER,
}

此枚舉類的三個(gè)信息分別代表在游戲的不同階段中，三個(gè)不同的狀態(tài)（不同的狀態(tài)下發(fā)出不同的信息）

3). 回答情況 AnswerSituation

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class AnswerSituation {
    private ArrayList<String> selfAnswerSituations;
}

此實(shí)體類代表著用戶pk答題的情況每一個(gè)用戶在每一局游戲中每一個(gè)用戶都會(huì)有一個(gè)自己的 AnswerSituation

4). 單局游戲回答情況 RoomAnswerSituation

@Data
@AllArgsConstructor
@NoArgsConstructor
public class RoomAnswerSituation {
    private String userId;
    private String receiver;
    private AnswerSituation selfAnswerSituations;
    private AnswerSituation opponentAnswerSituations;
}

其中一種響應(yīng)信息的類型 (GAME_OVER) 所對(duì)應(yīng)的T data數(shù)據(jù)，包含每一局游戲中雙方的回答情況，以及對(duì)方和自己的id標(biāo)識(shí)（便于前端判斷）

5). 用戶的信息 UserMatchInfo

@Data
public class UserMatchInfo {
    private String userId;
    private Integer score;
}

包含用戶的id及分?jǐn)?shù) 在響應(yīng)信息類型為 (TO_PLAY) 時(shí) 傳輸對(duì)方用戶以及自己的分?jǐn)?shù)信息

在響應(yīng)信息類型為 (MATCH_USER) 時(shí) 初始化雙方的分?jǐn)?shù)（總分）及id信息

6). 游戲?qū)中畔?GameMatchInfo

@Data
public class GameMatchInfo {
    // TODO UserMatchInfo 后期按需擴(kuò)充dan等屬性
    private UserMatchInfo selfInfo;
    private UserMatchInfo opponentInfo;
    private List<Question> questions;
//    用戶名
    private String selfUsername;
    private String opponentUsername;
//    頭像
    private String selfPicAvatar;
    private String opponentPicAvatar;
}

在匹配到對(duì)手之后發(fā)送的chatMessage中的 T data 數(shù)據(jù)類型

包含在這一輪游戲中自己以及對(duì)方的數(shù)據(jù)信息

此處包含雙方 id 用戶名頭像問題以及初始化后的用戶總分信息（0）

可進(jìn)一步優(yōu)化封裝為雙方游戲信息類 + 問題信息類

7). 分?jǐn)?shù)選項(xiàng)的反饋信息 ScoreSelectedInfo

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ScoreSelectedInfo {
    private UserMatchInfo userMatchInfo;
    private String userSelectedAnswer;
}

包含用戶信息 UserMatchInfo 及 userSelectedAnswer

顧名思義其為用戶每一題所選擇的答案此程序中記錄的是問題的答案（數(shù)組中的具體值）

可優(yōu)化改變換成記錄數(shù)組對(duì)應(yīng)索引etc

2、異常處理類

1). 錯(cuò)誤碼定義的統(tǒng)一接口

public interface IServerError {

    /**
     * 返回錯(cuò)誤碼
     *
     * @return 錯(cuò)誤碼
     */
    Integer getErrorCode();

    /**
     * 返回錯(cuò)誤詳細(xì)信息
     *
     * @return 錯(cuò)誤詳細(xì)信息
     */
    String getErrorDesc();
}

2). 運(yùn)行時(shí)錯(cuò)誤

public enum GameServerError implements IServerError {

    /**
     * 枚舉型錯(cuò)誤碼
     */
    WEBSOCKET_ADD_USER_FAILED(4018, "用戶進(jìn)入匹配模式失敗"),
    MESSAGE_TYPE_ERROR(4019, "websocket 消息類型錯(cuò)誤"),
    ;

    private final Integer errorCode;
    private final String errorDesc;

    GameServerError(Integer errorCode, String errorDesc) {
        this.errorCode = errorCode;
        this.errorDesc = errorDesc;
    }

    @Override
    public Integer getErrorCode() {
        return errorCode;
    }

    @Override
    public String getErrorDesc() {
        return errorDesc;
    }
}

枚舉錯(cuò)誤類型及錯(cuò)誤碼

3). 運(yùn)行時(shí)異常

public class GameServerException extends RuntimeException {

    private Integer code;

    private String message;

    public GameServerException(GameServerError error) {
        super(error.getErrorDesc());
        this.code = error.getErrorCode();
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }
}

統(tǒng)一規(guī)范拋出的異常及其錯(cuò)誤類型

3、游戲狀態(tài)枚舉類

public enum EnumRedisKey {

    /**
     * userOnline 在線狀態(tài)
     */
    USER_STATUS,
    /**
     * userOnline 匹配信息
     */
    USER_MATCH_INFO,
    /**
     * 房間
     */
    ROOM;

    public String getKey() {
        return this.name();
    }
}

使用枚舉類規(guī)定游戲中玩家的狀態(tài) 并且使用redis進(jìn)行存儲(chǔ)

4、ws主類

此部分代碼分為多板塊

此類完整代碼見附

1). 注入的相關(guān)類

private Session session;

private String userId;

static MatchCacheUtil matchCacheUtil;
// 修改 查看用戶的在線狀態(tài) 客戶端存儲(chǔ)狀態(tài)工具類

static Lock lock = new ReentrantLock();
static Condition matchCond = lock.newCondition();
// 鎖 防止并發(fā)異常情況

static QuestionService questionService;
// 題目業(yè)務(wù)類 用于在題庫中隨機(jī)獲取題目

static CompetitionService competitionService;
// 比賽業(yè)務(wù)類 用于獲取用戶段位信息等 pk相關(guān)的功能信息

static UserService userService;
// 用戶業(yè)務(wù)類 用于獲取用戶個(gè)人信息

static AnswerSituationUtil answerSituationUtil;
// 存儲(chǔ)用戶單輪答案信息 工具類


@Autowired
public void setQuestionService(QuestionService questionService) {
    ChatWebsocket.questionService = questionService;
}

@Autowired
public void setQuestionService(CompetitionService competitionService) {
    ChatWebsocket.competitionService = competitionService;
}

@Autowired
public void setQuestionService(UserService userService) {
    ChatWebsocket.userService = userService;
}

@Autowired
public void setMatchCacheUtil(MatchCacheUtil matchCacheUtil) {
    ChatWebsocket.matchCacheUtil = matchCacheUtil;
}

@Autowired
public void setAnswerSituationUtil(AnswerSituationUtil answerSituationUtil) {
    ChatWebsocket.answerSituationUtil = answerSituationUtil;
}

// 類單例模式注入相關(guān)業(yè)務(wù)工具類

詳細(xì)工具類見下一部分

2). 主要架構(gòu)

@OnOpen
public void onOpen(@PathParam("userId") String userId, Session session) {
    System.out.println(session);
    log.info("ChatWebsocket open 有新連接加入 userId: {}", userId);
    this.userId = userId;
    this.session = session;
    matchCacheUtil.addClient(userId, this);

    log.info("ChatWebsocket open 連接建立完成 userId: {}", userId);
}

onOpen: 建立ws連接時(shí)調(diào)用使用工具類存儲(chǔ)當(dāng)前客戶端的 id和webSocket對(duì)象入redis中便于后期調(diào)用

@OnError
public void onError(Session session, Throwable error) {

    log.error("ChatWebsocket onError 發(fā)生了錯(cuò)誤 userId: {}, errorMessage: {}", userId, error.getMessage());

    matchCacheUtil.removeClinet(userId);
    matchCacheUtil.removeUserOnlineStatus(userId);
    matchCacheUtil.removeUserFromRoom(userId);
    matchCacheUtil.removeUserMatchInfo(userId);

    log.info("ChatWebsocket onError 連接斷開完成 userId: {}", userId);
}

@OnClose
public void onClose() {
    log.info("ChatWebsocket onClose 連接斷開 userId: {}", userId);

    matchCacheUtil.removeClinet(userId);
    matchCacheUtil.removeUserOnlineStatus(userId);
    matchCacheUtil.removeUserFromRoom(userId);
    matchCacheUtil.removeUserMatchInfo(userId);

    log.info("ChatWebsocket onClose 連接斷開完成 userId: {}", userId);
}

OnError: 遇到異常時(shí)退出并調(diào)用將用戶信息經(jīng)過工具類從redis中移除

OnClose: 同理斷開連接時(shí)調(diào)用正常使用時(shí)機(jī)為用戶pk結(jié)束

@OnMessage
public void onMessage(String message, Session session) {

    log.info("ChatWebsocket onMessage userId: {}, 來自客戶端的消息 message: {}", userId, message);

    JSONObject jsonObject = JSON.parseObject(message);
    MessageTypeEnum type = jsonObject.getObject("type", MessageTypeEnum.class);

    log.info("ChatWebsocket onMessage userId: {}, 來自客戶端的消息類型 type: {}", userId, type);

    if (type == MessageTypeEnum.MATCH_USER) {
        matchUser(jsonObject);
    } elseif (type == MessageTypeEnum.PLAY_GAME) {
        toPlay(jsonObject);
    } elseif (type == MessageTypeEnum.GAME_OVER) {
        gameover(jsonObject);
    } else {
        throw new GameServerException(GameServerError.WEBSOCKET_ADD_USER_FAILED);
    }

    log.info("ChatWebsocket onMessage userId: {} 消息接收結(jié)束", userId);
}

OnMessage: 收到客戶端信息時(shí)調(diào)用 ws實(shí)現(xiàn)功能關(guān)鍵部分！

此處將整個(gè)游戲過程分割為三部分分別為匹配玩家游戲中游戲結(jié)束

3). 實(shí)現(xiàn)邏輯方法

1). 群發(fā)消息 sendMessageAll

/**
 * 群發(fā)消息
 */
private void sendMessageAll(MessageReply<?> messageReply) {

    log.info("ChatWebsocket sendMessageAll 消息群發(fā)開始 userId: {}, messageReply: {}", userId, JSON.toJSONString(messageReply));

    Set<String> receivers = messageReply.getChatMessage().getReceivers();
    for (String receiver : receivers) {
        ChatWebsocket client = matchCacheUtil.getClient(receiver);
        client.session.getAsyncRemote().sendText(JSON.toJSONString(messageReply));
    }

    log.info("ChatWebsocket sendMessageAll 消息群發(fā)結(jié)束 userId: {}", userId);
}

此方法根據(jù)形參確定信息的發(fā)出者并從工具類中獲取對(duì)方的webSocket對(duì)象異步發(fā)送到對(duì)方的客戶端中

2). 用戶隨機(jī)匹配對(duì)手 matchUser

    /**
     * 用戶隨機(jī)匹配對(duì)手
     */
    @SneakyThrows
// 拋出異常注解
    private void matchUser(JSONObject jsonObject) {

        log.info("ChatWebsocket matchUser 用戶隨機(jī)匹配對(duì)手開始 message: {}, userId: {}", jsonObject.toJSONString(), userId);

        MessageReply<GameMatchInfo> messageReply = new MessageReply<>();
        ChatMessage<GameMatchInfo> result = new ChatMessage<>();
        result.setSender(userId);
        result.setType(MessageTypeEnum.MATCH_USER);

        lock.lock();
        try {
            // 設(shè)置用戶狀態(tài)為匹配中
//            TODO 修改工具類的類型 使他不只能存儲(chǔ)id 也能存儲(chǔ)玩家的段位
            matchCacheUtil.setUserInMatch(userId);
            matchCond.signal();
        } finally {
            lock.unlock();
        }

        // 創(chuàng)建一個(gè)異步線程任務(wù)，負(fù)責(zé)匹配其他同樣處于匹配狀態(tài)的其他用戶
        Thread matchThread = new Thread(() -> {
            boolean flag = true;
            String receiver = null;
            while (flag) {
                // 獲取除自己以外的其他待匹配用戶
                lock.lock();
                try {
                    // 當(dāng)前用戶不處于待匹配狀態(tài) 直接返回
                    if (matchCacheUtil.getUserOnlineStatus(userId).compareTo(StatusEnum.IN_GAME) == 0
//                            觀察當(dāng)前用戶是否游戲中狀態(tài)
                            || matchCacheUtil.getUserOnlineStatus(userId).compareTo(StatusEnum.GAME_OVER) == 0) {
//                        觀察當(dāng)前用戶是否游戲結(jié)束 結(jié)算的狀態(tài)
                        log.info("ChatWebsocket matchUser 當(dāng)前用戶 {} 已退出匹配", userId);
                        return;
                    }
                    // 當(dāng)前用戶取消匹配狀態(tài)
                    if (matchCacheUtil.getUserOnlineStatus(userId).compareTo(StatusEnum.IDLE) == 0) {
                        // 當(dāng)前用戶取消匹配
                        messageReply.setCode(MessageCode.CANCEL_MATCH_ERROR.getCode());
                        messageReply.setDesc(MessageCode.CANCEL_MATCH_ERROR.getDesc());
//                        設(shè)定返回信息 將從匹配中的狀態(tài)該為待匹配
                        Set<String> set = new HashSet<>();
                        set.add(userId);
                        result.setReceivers(set);
                        result.setType(MessageTypeEnum.CANCEL_MATCH);
                        messageReply.setChatMessage(result);
                        log.info("ChatWebsocket matchUser 當(dāng)前用戶 {} 已退出匹配", userId);
//                        發(fā)送返回信息
                        sendMessageAll(messageReply);
                        return;
                    }

//                    從room中獲取對(duì)手的對(duì)象 這個(gè)receiver是對(duì)手的id
//                    可以在這里下手腳 加一個(gè)while循環(huán) 判斷直至找到相同段位的用戶為止
//                    TODO 直接在setUserMatchRoom那塊 加入玩家的段位信息 需要改動(dòng)工具類
                    String userDan = competitionService.showPlayersExtraDan(Integer.parseInt(userId));
                    while (true) {
                        receiver = matchCacheUtil.getUserInMatchRandom(userId);
//                        這里必須把判空放在上面 否則如果是隊(duì)列中沒有人在匹配 卻給receiver調(diào)用了Integer.parseInt(receiver)方法 會(huì)報(bào)空指針
                        if (Objects.isNull(receiver))
                            break;
                        elseif (userDan.equals(competitionService.showPlayersExtraDan(Integer.parseInt(receiver))))
                            break;
                    }
                    if (receiver != null) {
                        // 對(duì)手不處于待匹配狀態(tài)
                        if (matchCacheUtil.getUserOnlineStatus(receiver).compareTo(StatusEnum.IN_MATCH) != 0) {
                            log.info("ChatWebsocket matchUser 當(dāng)前用戶 {}, 匹配對(duì)手 {} 已退出匹配狀態(tài)", userId, receiver);
   ??                    } else {
//                            進(jìn)了這個(gè)else就表明用戶已經(jīng)匹配到狀態(tài)正常的對(duì)手了
//                            設(shè)定對(duì)手的基本信息
                            matchCacheUtil.setUserInGame(userId);
                            matchCacheUtil.setUserInGame(receiver);
//                            將對(duì)手放入房間中 （指定唯一user）
                            matchCacheUtil.setUserInRoom(userId, receiver);
                            flag = false;
//                            匹配到了 令flag為false 跳出while循環(huán)
//                            此次匹配結(jié)束 進(jìn)入開打狀態(tài)
                        }
                    } else {
                        // 如果當(dāng)前沒有待匹配用戶，進(jìn)入等待隊(duì)列
                        try {
                            log.info("ChatWebsocket matchUser 當(dāng)前用戶 {} 無對(duì)手可匹配", userId);
                            matchCond.await();
                        } catch (InterruptedException e) {
                            log.error("ChatWebsocket matchUser 匹配線程 {} 發(fā)生異常: {}",
                                    Thread.currentThread().getName(), e.getMessage());
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }

            log.info("已找到玩家 雙方分別為" + userId + "和" + receiver);

            UserMatchInfo senderInfo = new UserMatchInfo();
            UserMatchInfo receiverInfo = new UserMatchInfo();
            senderInfo.setUserId(userId);
            senderInfo.setScore(0);
            receiverInfo.setUserId(receiver);
            receiverInfo.setScore(0);
//            兩個(gè)對(duì)象分別記錄兩個(gè)玩家的得分

            matchCacheUtil.setUserMatchInfo(userId, JSON.toJSONString(senderInfo));
            matchCacheUtil.setUserMatchInfo(receiver, JSON.toJSONString(receiverInfo));
//            初始化接下來pk中玩家的信息 (每一道題提交答案完成都會(huì) 刷新一次對(duì)應(yīng)的得分)

            GameMatchInfo gameMatchInfo = new GameMatchInfo();

//            獲取玩家段位 根據(jù)玩家段位來獲取題目
            String dan = competitionService.showPlayersDan(Integer.parseInt(userId));
            List<Question> questions = questionService.getCompetitionQuestionsByDan(dan);

            gameMatchInfo.setQuestions(questions);
            gameMatchInfo.setSelfInfo(senderInfo);
            gameMatchInfo.setOpponentInfo(receiverInfo);
//            一次性獲取所有題目
//            存入此次對(duì)戰(zhàn)中的當(dāng)前玩家 對(duì)方 題目
//            一個(gè)GameMatchInfo就代表一個(gè)玩家的對(duì)象

//            新增 存入此次pk中對(duì)方的用戶名 頭像
            UserWithValue userWithValue = userService.showUser(Integer.parseInt(userId));
            String username = userWithValue.getUser().getUsername();
            String userPic = userWithValue.getUserValue().getPic();
            gameMatchInfo.setSelfUsername(username);
            gameMatchInfo.setSelfPicAvatar(userPic);

            UserWithValue receiverValue = userService.showUser(Integer.parseInt(receiver));
            String receiverUsername = receiverValue.getUser().getUsername();
            String opponentPic = receiverValue.getUserValue().getPic();
            gameMatchInfo.setOpponentUsername(receiverUsername);
            gameMatchInfo.setOpponentPicAvatar(opponentPic);

            messageReply.setCode(MessageCode.SUCCESS.getCode());
            messageReply.setDesc(MessageCode.SUCCESS.getDesc());
//            確認(rèn)返回信息的類型以及數(shù)據(jù)

            result.setData(gameMatchInfo);
            Set<String> set = new HashSet<>();
            set.add(userId);
            result.setReceivers(set);
            result.setType(MessageTypeEnum.MATCH_USER);
            messageReply.setChatMessage(result);
            sendMessageAll(messageReply);

//            自己的傳給自己的 對(duì)面的傳給對(duì)面的
            gameMatchInfo.setSelfInfo(senderInfo);
            gameMatchInfo.setOpponentInfo(receiverInfo);

            result.setData(gameMatchInfo);
            set.clear();
            set.add(receiver);
            result.setReceivers(set);
            messageReply.setChatMessage(result);

            sendMessageAll(messageReply);

            log.info("ChatWebsocket matchUser 用戶隨機(jī)匹配對(duì)手結(jié)束 messageReply: {}", JSON.toJSONString(messageReply));

        }, MATCH_TASK_NAME_PREFIX + userId);
        matchThread.start();
    }

基本思路為改變玩家狀態(tài)為匹配中并且匹配相同狀態(tài) 相同段位的對(duì)手 (段位可按需增刪)

匹配的過程是異步多線程匹配若沒有相同狀態(tài)的對(duì)手則線程沉睡直至有對(duì)手匹配為止 (此處可以設(shè)置匹配超時(shí)時(shí)間進(jìn)行優(yōu)化)

確認(rèn)對(duì)手狀態(tài)無誤后根據(jù)id獲取雙方信息此輪pk中題目

最后通過 sendMessageAll 的方法將信息發(fā)送給自己與對(duì)方

執(zhí)行步驟見代碼注釋

3). 游戲中 toPlay

    /**
     * 游戲中
     */
    @SneakyThrows
    public void toPlay(JSONObject jsonObject) {
//        每一道題提交了都會(huì)重新執(zhí)行一次這個(gè)方法
//        (由答題方 執(zhí)行)
        log.info("ChatWebsocket toPlay 用戶更新對(duì)局信息開始 userId: {}, message: {}", userId, jsonObject.toJSONString());

        MessageReply<ScoreSelectedInfo> messageReply = new MessageReply<>();
//        返回的信息類型

//        下面的這個(gè)思路就是 從房間中找到對(duì)方 并且發(fā)送自己的分?jǐn)?shù)更新信息給他
        ChatMessage<ScoreSelectedInfo> result = new ChatMessage<>();
        result.setSender(userId);
        String receiver = matchCacheUtil.getUserFromRoom(userId);
//        從房間中找出對(duì)面的對(duì)手是誰 發(fā)信息給他
        Set<String> set = new HashSet<>();
        set.add(receiver);
        result.setReceivers(set);
        result.setType(MessageTypeEnum.PLAY_GAME);
//        設(shè)置消息的發(fā)送方 和 接收方 以及消息類型 (游戲中)

//        獲取新的得分 并且重新賦值給當(dāng)前的user   (當(dāng)前的user就是得分的那個(gè))
        UserMatchChoice userMatchChoice = jsonObject.getObject("data", UserMatchChoice.class);
        Integer newScore = userMatchChoice.getUserScore();
        String userSelectedAnswer = userMatchChoice.getUserSelectedAnswer();

//        獲取answerSituation對(duì)象 此對(duì)象中是所有正在游戲中的用戶的回答信息 暫時(shí)存在這里
        answerSituationUtil.addAnswer(userId, userSelectedAnswer);

        UserMatchInfo userMatchInfo = new UserMatchInfo();
        userMatchInfo.setUserId(userId);
        userMatchInfo.setScore(newScore);

//        setUserMatchInfo所改變的數(shù)據(jù)是 同一時(shí)刻所有對(duì)戰(zhàn)的用戶的信息
//        在這里set是根據(jù)當(dāng)前用戶的id
//        重新設(shè)置一下對(duì)應(yīng)的用戶對(duì)戰(zhàn)信息
        matchCacheUtil.setUserMatchInfo(userId, JSON.toJSONString(userMatchInfo));

//        設(shè)置響應(yīng)數(shù)據(jù)的類型
//        更新 同時(shí)發(fā)送對(duì)面所選的選項(xiàng)
        result.setData(new ScoreSelectedInfo(userMatchInfo, userSelectedAnswer));
        messageReply.setCode(MessageCode.SUCCESS.getCode());
        messageReply.setDesc(MessageCode.SUCCESS.getDesc());
        messageReply.setChatMessage(result);

//        返回包含當(dāng)前用戶的新信息的響應(yīng)數(shù)據(jù)
        sendMessageAll(messageReply);

        log.info("ChatWebsocket toPlay 用戶更新對(duì)局信息結(jié)束 userId: {}, userMatchInfo: {}", userId, JSON.toJSONString(userMatchInfo));
    }

pk中每一道題答完后客戶端往服務(wù)器發(fā)起的請(qǐng)求類型

主要思路是根據(jù)信息的發(fā)出方從redis中的房間機(jī)制獲取他的對(duì)手 (在匹配的時(shí)候會(huì)將一輪對(duì)戰(zhàn)中雙方的id存入redis 可理解成放入房間防止第三者客戶端進(jìn)入對(duì)pk過程進(jìn)行干擾) 之后將答題情況發(fā)送給對(duì)方

4). 游戲結(jié)束 gameover

    /**
     * 游戲結(jié)束
     */
    public void gameover(JSONObject jsonObject) {

        log.info("ChatWebsocket gameover 用戶對(duì)局結(jié)束 userId: {}, message: {}", userId, jsonObject.toJSONString());

//        設(shè)置響應(yīng)數(shù)據(jù)類型
        MessageReply<RoomAnswerSituation> messageReply = new MessageReply<>();

//        設(shè)置響應(yīng)數(shù)據(jù) 改變玩家的狀態(tài)
        ChatMessage<RoomAnswerSituation> result = new ChatMessage<>();
        result.setSender(userId);
        String receiver = matchCacheUtil.getUserFromRoom(userId);
        result.setType(MessageTypeEnum.GAME_OVER);
        lock.lock();
        try {
//            設(shè)定用戶為游戲結(jié)束的狀態(tài)
            matchCacheUtil.setUserGameover(userId);
            if (matchCacheUtil.getUserOnlineStatus(receiver).compareTo(StatusEnum.GAME_OVER) == 0) {
                messageReply.setCode(MessageCode.SUCCESS.getCode());
                messageReply.setDesc(MessageCode.SUCCESS.getDesc());

                //        記錄贏了的玩家的ID
                Integer winnerId = jsonObject.getInteger("data");
                boolean isUpdate = competitionService.updateUserStar(winnerId);
                if (!isUpdate) {
                    messageReply.setCode(MessageCode.SYSTEM_ERROR.getCode());
                    messageReply.setDesc(MessageCode.SYSTEM_ERROR.getDesc());
                }

//                獲取對(duì)戰(zhàn)后的對(duì)戰(zhàn)信息
                AnswerSituation selfAnswer = answerSituationUtil.getAnswer(userId);
                AnswerSituation opponentAnswer = answerSituationUtil.getAnswer(receiver);
                RoomAnswerSituation roomAnswerSituation = new RoomAnswerSituation(userId, receiver, selfAnswer, opponentAnswer);
                result.setData(roomAnswerSituation);

//                設(shè)置完結(jié)后的返回信息
                messageReply.setChatMessage(result);
                Set<String> set = new HashSet<>();
                set.add(receiver);
                result.setReceivers(set);
                sendMessageAll(messageReply);
//                屎山會(huì)出手 兩邊全部發(fā)
                set.clear();
                set.add(userId);
                result.setReceivers(set);
                sendMessageAll(messageReply);

//                移除屬于游戲中的游戲信息
                matchCacheUtil.removeUserMatchInfo(userId);
                matchCacheUtil.removeUserFromRoom(userId);

//                移除屬于這一次的游戲選擇信息
                answerSituationUtil.removeAnswer(userId);
                answerSituationUtil.removeAnswer(receiver);
            }
        } finally {
            lock.unlock();
        }

        log.info("ChatWebsocket gameover 對(duì)局 [{} - {}] 結(jié)束", userId, receiver);
    }

代碼中通過前端判斷題目數(shù)組遍歷完成判斷雙方分?jǐn)?shù) 發(fā)送gameover狀態(tài)信息

前端通過比較雙方總分將勝利用戶的id發(fā)回給后端即此狀態(tài)信息中的 T data

后端將其狀態(tài)轉(zhuǎn)換并且將對(duì)應(yīng)的雙方此輪對(duì)戰(zhàn)信息包括總分獲勝者對(duì)方的回答情況發(fā)回給雙方客戶端

至此一輪pk結(jié)束

5、配置類及工具類

1). WebSocket配置類

@Configuration
@EnableWebSocket
public class WebsocketConfig {
    @Bean
    public ServerEndpointExporter serverEndpointExporter(){
        return new ServerEndpointExporter();
    }
}

2). AnswerSituation 用戶答題情況存儲(chǔ)工具類

@Component
//用戶答題情況 工具類
public class AnswerSituationUtil {

    private static final Map<String, AnswerSituation> ANSWER_SITUATION = new HashMap<>();

//    新增答案
    public void addAnswer(String userId,String answer){
        boolean isScored = ANSWER_SITUATION.containsKey(userId);
        if (isScored)
            ANSWER_SITUATION.get(userId).getSelfAnswerSituations().add(answer);
        if (!isScored) {
            ArrayList<String> answers = new ArrayList<>();
            answers.add(answer);
            ANSWER_SITUATION.put(userId,new AnswerSituation(answers));
        }
    }

//    獲取用戶所有答案
    public AnswerSituation getAnswer(String userId){
        boolean isContain = ANSWER_SITUATION.containsKey(userId);
        if (!isContain)
            return null;
        return ANSWER_SITUATION.get(userId);
    }

//    移除答案
    public boolean removeAnswer(String userId){
        boolean isContain = ANSWER_SITUATION.containsKey(userId);
        if (!isContain)
            returnfalse;
        ANSWER_SITUATION.remove(userId);
        returntrue;
    }
}

主要存儲(chǔ) 記錄清除用戶每一輪答題的緩存

可優(yōu)化存進(jìn) redis 中

3). MatchCacheUtil 存儲(chǔ)用戶在線狀態(tài)及其客戶端工具類

@Component
public class MatchCacheUtil {

    /**
     * 用戶 userId 為 key，ChatWebsocket 為 value
     */
    private static final Map<String, ChatWebsocket> CLIENTS = new HashMap<>();

    /**
     * key 是標(biāo)識(shí)存儲(chǔ)用戶在線狀態(tài)的 EnumRedisKey，value 為 map 類型，其中用戶 userId 為 key，用戶在線狀態(tài) 為 value
     */
    @Resource
    private RedisTemplate<String, Map<String, String>> redisTemplate;

    /**
     * 添加客戶端
     */
    public void addClient(String userId, ChatWebsocket websocket) {
        CLIENTS.put(userId, websocket);
    }

    /**
     * 移除客戶端
     */
    public void removeClinet(String userId) {
        CLIENTS.remove(userId);
    }

    /**
     * 獲取客戶端
     */
    public ChatWebsocket getClient(String userId) {
        return CLIENTS.get(userId);
    }

    /**
     * 移除用戶在線狀態(tài)
     */
    public void removeUserOnlineStatus(String userId) {
        redisTemplate.opsForHash().delete(EnumRedisKey.USER_STATUS.getKey(), userId);
    }

    /**
     * 獲取用戶在線狀態(tài)
     */
    public StatusEnum getUserOnlineStatus(String userId) {
        Object status = redisTemplate.opsForHash().get(EnumRedisKey.USER_STATUS.getKey(), userId);
        if (status == null) {
            return null;
        }
        return StatusEnum.getStatusEnum(status.toString());
    }

    /**
     * 設(shè)置用戶為 IDLE 狀態(tài)
     */
    public void setUserIDLE(String userId) {
        removeUserOnlineStatus(userId);
        redisTemplate.opsForHash().put(EnumRedisKey.USER_STATUS.getKey(), userId, StatusEnum.IDLE.getValue());
    }

    /**
     * 設(shè)置用戶為 IN_MATCH 狀態(tài)
     */
    public void setUserInMatch(String userId) {
        removeUserOnlineStatus(userId);
        redisTemplate.opsForHash().put(EnumRedisKey.USER_STATUS.getKey(), userId, StatusEnum.IN_MATCH.getValue());
    }

    /**
     * 隨機(jī)獲取處于匹配狀態(tài)的用戶（除了指定用戶外）
     */
    public String getUserInMatchRandom(String userId) {
        Optional<Map.Entry<Object, Object>> any = redisTemplate.opsForHash().entries(EnumRedisKey.USER_STATUS.getKey())
                .entrySet().stream().filter(entry -> entry.getValue().equals(StatusEnum.IN_MATCH.getValue()) && !entry.getKey().equals(userId))
                .findAny();
        return any.map(entry -> entry.getKey().toString()).orElse(null);
    }

    /**
     * 設(shè)置用戶為 IN_GAME 狀態(tài)
     */
    public void setUserInGame(String userId) {
        removeUserOnlineStatus(userId);
        redisTemplate.opsForHash().put(EnumRedisKey.USER_STATUS.getKey(), userId, StatusEnum.IN_GAME.getValue());
    }

    /**
     * 設(shè)置處于游戲中的用戶在同一房間
     */
    public void setUserInRoom(String userId1, String userId2) {
        redisTemplate.opsForHash().put(EnumRedisKey.ROOM.getKey(), userId1, userId2);
        redisTemplate.opsForHash().put(EnumRedisKey.ROOM.getKey(), userId2, userId1);
    }

    /**
     * 從房間中移除用戶
     */
    public void removeUserFromRoom(String userId) {
        redisTemplate.opsForHash().delete(EnumRedisKey.ROOM.getKey(), userId);
    }

    /**
     * 從房???中獲取用戶
     */
    public String getUserFromRoom(String userId) {
        return redisTemplate.opsForHash().get(EnumRedisKey.ROOM.getKey(), userId).toString();
    }

    /**
     * 設(shè)置處于游戲中的用戶的對(duì)戰(zhàn)信息
     */
    public void setUserMatchInfo(String userId, String userMatchInfo) {
        redisTemplate.opsForHash().put(EnumRedisKey.USER_MATCH_INFO.getKey(), userId, userMatchInfo);
    }

    /**
     * 移除處于游戲中的用戶的對(duì)戰(zhàn)信息
     */
    public void removeUserMatchInfo(String userId) {
        redisTemplate.opsForHash().delete(EnumRedisKey.USER_MATCH_INFO.getKey(), userId);
    }

    /**
     * 設(shè)置處于游戲中的用戶的對(duì)戰(zhàn)信息
     */
    public String getUserMatchInfo(String userId) {
        return redisTemplate.opsForHash().get(EnumRedisKey.USER_MATCH_INFO.getKey(), userId).toString();
    }

    /**
     * 設(shè)置用戶為游戲結(jié)束狀態(tài)
     */
    public synchronized void setUserGameover(String userId) {
        removeUserOnlineStatus(userId);
        redisTemplate.opsForHash().put(EnumRedisKey.USER_STATUS.getKey(), userId, StatusEnum.GAME_OVER.getValue());
    }
}

設(shè)置并改變用戶的在線狀態(tài) 利用redis + 枚舉類

在每一輪游戲結(jié)束之后將其移除緩存

4). MessageCode 響應(yīng)碼

@Getter
public enum MessageCode {

    /**
     * 響應(yīng)碼
     */
    SUCCESS(2000, "連接成功"),
    USER_IS_ONLINE(2001, "用戶已存在"),
    CURRENT_USER_IS_INGAME(2002, "當(dāng)前用戶已在游戲中"),
    MESSAGE_ERROR(2003, "消息錯(cuò)誤"),
    CANCEL_MATCH_ERROR(2004, "用戶取消了匹配"),
    SYSTEM_ERROR(2005,"系統(tǒng)錯(cuò)誤");

    private final Integer code;
    private final String desc;

    MessageCode(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }
}

枚舉類定義封裝ws使用中會(huì)出現(xiàn)的錯(cuò)誤

5). MessageTypeEnum 用戶狀態(tài)枚舉類

public enum MessageTypeEnum {
    /**
     * 匹配對(duì)手
     */
    MATCH_USER,
    /**
     * 游戲開始
     */
    PLAY_GAME,
    /**
     * 游戲結(jié)束
     */
    GAME_OVER,
}

枚舉類統(tǒng)一定義ws連接中OnMessage中會(huì)出現(xiàn)的消息類型

前后端根據(jù)判斷消息類型判斷執(zhí)行的邏輯和方法執(zhí)行的階段

6). StatusEnum 用戶狀態(tài)枚舉類

public enum StatusEnum {

    /**
     * 待匹配
     */
    IDLE,
    /**
     * 匹配中
     */
    IN_MATCH,
    /**
     * 游戲中
     */
    IN_GAME,
    /**
     * 游戲結(jié)束
     */
    GAME_OVER,
    ;

    public static StatusEnum getStatusEnum(String status) {
        switch (status) {
            case"IDLE":
                return IDLE;
            case"IN_MATCH":
                return IN_MATCH;
            case"IN_GAME":
                return IN_GAME;
            case"GAME_OVER":
                return GAME_OVER;
            default:
                throw new GameServerException(GameServerError.MESSAGE_TYPE_ERROR);
        }
    }

    public String getValue() {
        return this.name();
    }
}

確認(rèn)用戶此時(shí)的狀態(tài) 為匹配中待匹配游戲中游戲結(jié)束

注：用戶的狀態(tài) ≠ 消息類

以上就是Java+WebSocket實(shí)現(xiàn)簡(jiǎn)單實(shí)時(shí)雙人協(xié)同pk答題系統(tǒng)的詳細(xì)內(nèi)容，更多關(guān)于Java WebSocket答題系統(tǒng)的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: