SpringBoot + WebSocket 实现答题对战匹配机制案例详解

概要设计

类似竞技问答游戏：用户随机匹配一名对手，双方同时开始答题，直到双方都完成答题，对局结束。基本的逻辑就是这样，如果有其他需求，可以在其基础上进行扩展

明确了这一点，下面介绍开发思路。为每个用户拟定四种在线状态，分别是：待匹配、匹配中、游戏中、游戏结束。下面是流程图，用户的流程是被规则约束的，状态也随流程而变化

对流程再补充如下：

• 用户进入匹配大厅（具体效果如何由客户端体现），将用户的状态设置为待匹配
• 用户开始匹配，将用户的状态设置为匹配中，系统搜索其他同样处于匹配中的用户，在这个过程中，用户可以取消匹配，返回匹配大厅，此时用户状态重新设置为待匹配。匹配成功，保存匹配信息，将用户状态设置为游戏中
• 根据已保存的匹配信息，用户可以获得对手的信息。答题是时，每次用户分数更新，也会向对手推送更新后的分数
• 用户完成答题，则等待对手也完成答题。双方都完成答题，用户状态设置为游戏结束，展示对局结果

详细设计

针对概要设计提出的思路，我们需要思考以下几个问题：

• 如何保持客户端与服务器的连接？
• 如何设计客户端与服务端的消息交互？
• 如何保存以及改变用户状态？
• 如何匹配用户？

下面我们一个一个来解决

1. 如何保持用户与服务器的连接？

以往我们使用 http 请求服务器，并获取响应信息。然而 http 有个缺陷，就是通信只能由客户端发起，无法做到服务端主动向客户端推送信息。根据概要设计我们知道，服务端需要向客户端推送对手的实时分数，因此这里不适合使用 http，而选择了 websocket。websocket 最大的特点就是服务端可以主动向客户端推送信息，客户端也可以主动向服务端发送信息，是真正的双向平等对话

有关 springboot 集成 websocket 可参考这篇博客：

2. 如何设计客户端与服务端的消息交互？

按照匹配机制要求，把消息划分为 add_user（用户加入）、match_user（匹配对手）、cancel_match（取消匹配）、play_game（游戏开始）、game_over（游戏结束）

public enum messagetypeenum {

    /**
     * 用户加入
     */
    add_user,
    /**
     * 匹配对手
     */
    match_user,
    /**
     * 取消匹配
     */
    cancel_match,
    /**
     * 游戏开始
     */
    play_game,
    /**
     * 游戏结束
     */
    game_over,
}

使用 websocket 客户端可以向服务端发送消息，服务端也能向客户端发送消息。把消息按照需求划分成不同的类型，客户端发送某一类型的消息，服务端接收后判断，并按照类型分别处理，最后返回向客户端推送处理结果。区别客户端 websocket 连接的是从客户端传来的 userid，用 hashmap 保存

@component
@slf4j
@serverendpoint(value = "/game/match/{userid}")
public class chatwebsocket {

    private session session;

    private string userid;

    static questionsev questionsev;
    static matchcacheutil matchcacheutil;

    static lock lock = new reentrantlock();

    static condition matchcond = lock.newcondition();

    @autowired
    public void setmatchcacheutil(matchcacheutil matchcacheutil) {
        chatwebsocket.matchcacheutil = matchcacheutil;
    }

    @autowired
    public void setquestionsev(questionsev questionsev) {
        chatwebsocket.questionsev = questionsev;
    }

    @onopen
    public void onopen(@pathparam("userid") string userid, session session) {

        log.info("chatwebsocket open 有新连接加入 userid: {}", userid);

        this.userid = userid;
        this.session = session;
        matchcacheutil.addclient(userid, this);

        log.info("chatwebsocket open 连接建立完成 userid: {}", userid);
    }

    @onerror
    public void onerror(session session, throwable error) {

        log.error("chatwebsocket onerror 发生了错误 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);
    }

    @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.add_user) {
            adduser(jsonobject);
        } else if (type == messagetypeenum.match_user) {
            matchuser(jsonobject);
        } else if (type == messagetypeenum.cancel_match) {
            cancelmatch(jsonobject);
        } else if (type == messagetypeenum.play_game) {
            toplay(jsonobject);
        } else if (type == messagetypeenum.game_over) {
            gameover(jsonobject);
        } else {
            throw new gameserverexception(gameservererror.websocket_add_user_failed);
        }

        log.info("chatwebsocket onmessage userid: {} 消息接收结束", userid);
    }

    /**
     * 群发消息
     */
    private void sendmessageall(messagereply<?> messagereply) {

        log.info("chatwebsocket sendmessageall 消息群发开始 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 消息群发结束 userid: {}", userid);
    }

    // 出于减少篇幅的目的，业务处理方法暂不贴出...
}

3. 如何保存以及改变用户状态？

创建一个枚举类，定义用户的状态

/**
 * 用户状态
 * @author yeeq
 */
public enum statusenum {

    /**
     * 待匹配
     */
    idle,
    /**
     * 匹配中
     */
    in_match,
    /**
     * 游戏中
     */
    in_game,
    /**
     * 游戏结束
     */
    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();
    }
}

选择 redis 保存用户状态，还是创建一个枚举类，redis 中存储数据都有唯一的 key 做标识，因此在这里定义 redis 中的 key，分别介绍如下：

• user_status：存储用户状态的 key，存储类型是 map<string, string>，其中用户 userid 为 key，用户在线状态 为 value
• user_match_info：当用户处于游戏中时，我们需要记录用户的信息，比如分数等。这些信息不需要记录到数据库，而且随时会更新，放入缓存方便获取
• room：可以理解为匹配的两名用户创建一个房间，具体实现是以键值对方式存储，比如用户 a 和用户 b 匹配，用户 a 的 userid 是 a，用户 b 的 userid 是 b，则在 redis 中记录为 {a -- b}，{b -- a}

public enum enumrediskey {

    /**
     * useronline 在线状态
     */
    user_status,
    /**
     * useronline 对局信息
     */
    user_in_play,
    /**
     * useronline 匹配信息
     */
    user_match_info,
    /**
     * 房间
     */
    room;

    public string getkey() {
        return this.name();
    }
}

创建一个工具类，用于操作 redis 中的数据。

@component
public class matchcacheutil {

    /**
     * 用户 userid 为 key，chatwebsocket 为 value
     */
    private static final map<string, chatwebsocket> clients = new hashmap<>();

    /**
     * key 是标识存储用户在线状态的 enumrediskey，value 为 map 类型，其中用户 userid 为 key，用户在线状态 为 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);
    }

    /**
     * 移除用户在线状态
     */
    public void removeuseronlinestatus(string userid) {
        redistemplate.opsforhash().delete(enumrediskey.user_status.getkey(), userid);
    }

    /**
     * 获取用户在线状态
     */
    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());
    }

    /**
     * 设置用户为 idle 状态
     */
    public void setuseridle(string userid) {
        removeuseronlinestatus(userid);
        redistemplate.opsforhash().put(enumrediskey.user_status.getkey(), userid, statusenum.idle.getvalue());
    }

    /**
     * 设置用户为 in_match 状态
     */
    public void setuserinmatch(string userid) {
        removeuseronlinestatus(userid);
        redistemplate.opsforhash().put(enumrediskey.user_status.getkey(), userid, statusenum.in_match.getvalue());
    }

    /**
     * 随机获取处于匹配状态的用户（除了指定用户外）
     */
    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);
    }

    /**
     * 设置用户为 in_game 状态
     */
    public void setuseringame(string userid) {
        removeuseronlinestatus(userid);
        redistemplate.opsforhash().put(enumrediskey.user_status.getkey(), userid, statusenum.in_game.getvalue());
    }

    /**
     * 设置处于游戏中的用户在同一房间
     */
    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();
    }

    /**
     * 设置处于游戏中的用户的对战信息
     */
    public void setusermatchinfo(string userid, string usermatchinfo) {
        redistemplate.opsforhash().put(enumrediskey.user_match_info.getkey(), userid, usermatchinfo);
    }

    /**
     * 移除处于游戏中的用户的对战信息
     */
    public void removeusermatchinfo(string userid) {
        redistemplate.opsforhash().delete(enumrediskey.user_match_info.getkey(), userid);
    }

    /**
     * 设置处于游戏中的用户的对战信息
     */
    public string getusermatchinfo(string userid) {
        return redistemplate.opsforhash().get(enumrediskey.user_match_info.getkey(), userid).tostring();
    }

    /**
     * 设置用户为游戏结束状态
     */
    public synchronized void setusergameover(string userid) {
        removeuseronlinestatus(userid);
        redistemplate.opsforhash().put(enumrediskey.user_status.getkey(), userid, statusenum.game_over.getvalue());
    }
}

4. 如何匹配用户？

匹配用户的思路之前已经提到过，为了不阻塞客户端与服务端的 websocket 连接，创建一个线程专门用来匹配用户，如果匹配成功就向客户端推送消息

用户匹配对手时遵循这么一个原则：用户 a 找到用户 b，由用户 a 负责一切工作，既由用户 a 完成创建匹配数据并保存到缓存的全部操作。值得注意的一点是，在匹配时要注意保证状态的变化：

• 当前用户在匹配对手的同时，被其他用户匹配，那么当前用户应当停止匹配操作
• 当前用户匹配到对手，但对手被其他用户匹配了，那么当前用户应该重新寻找新的对手

用户匹配对手的过程应该保证原子性，使用 java 锁来保证

/**
 * 用户随机匹配对手
 */
@sneakythrows
private void matchuser(jsonobject jsonobject) {

    log.info("chatwebsocket matchuser 用户随机匹配对手开始 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 {
        // 设置用户状态为匹配中
        matchcacheutil.setuserinmatch(userid);
        matchcond.signal();
    } finally {
        lock.unlock();
    }

    // 创建一个异步线程任务，负责匹配其他同样处于匹配状态的其他用户
    thread matchthread = new thread(() -> {
        boolean flag = true;
        string receiver = null;
        while (flag) {
            // 获取除自己以外的其他待匹配用户
            lock.lock();
            try {
                // 当前用户不处于待匹配状态
                if (matchcacheutil.getuseronlinestatus(userid).compareto(statusenum.in_game) == 0
                    || matchcacheutil.getuseronlinestatus(userid).compareto(statusenum.game_over) == 0) {
                    log.info("chatwebsocket matchuser 当前用户 {} 已退出匹配", userid);
                    return;
                }
                // 当前用户取消匹配状态
                if (matchcacheutil.getuseronlinestatus(userid).compareto(statusenum.idle) == 0) {
                    // 当前用户取消匹配
                    messagereply.setcode(messagecode.cancel_match_error.getcode());
                    messagereply.setdesc(messagecode.cancel_match_error.getdesc());
                    set<string> set = new hashset<>();
                    set.add(userid);
                    result.setreceivers(set);
                    result.settype(messagetypeenum.cancel_match);
                    messagereply.setchatmessage(result);
                    log.info("chatwebsocket matchuser 当前用户 {} 已退出匹配", userid);
                    sendmessageall(messagereply);
                    return;
                }
                receiver = matchcacheutil.getuserinmatchrandom(userid);
                if (receiver != null) {
                    // 对手不处于待匹配状态
                    if (matchcacheutil.getuseronlinestatus(receiver).compareto(statusenum.in_match) != 0) {
                        log.info("chatwebsocket matchuser 当前用户 {}, 匹配对手 {} 已退出匹配状态", userid, receiver);
                    } else {
                        matchcacheutil.setuseringame(userid);
                        matchcacheutil.setuseringame(receiver);
                        matchcacheutil.setuserinroom(userid, receiver);
                        flag = false;
                    }
                } else {
                    // 如果当前没有待匹配用户，进入等待队列
                    try {
                        log.info("chatwebsocket matchuser 当前用户 {} 无对手可匹配", userid);
                        matchcond.await();
                    } catch (interruptedexception e) {
                        log.error("chatwebsocket matchuser 匹配线程 {} 发生异常: {}",
                                  thread.currentthread().getname(), e.getmessage());
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        usermatchinfo senderinfo = new usermatchinfo();
        usermatchinfo receiverinfo = new usermatchinfo();
        senderinfo.setuserid(userid);
        senderinfo.setscore(0);
        receiverinfo.setuserid(receiver);
        receiverinfo.setscore(0);

        matchcacheutil.setusermatchinfo(userid, json.tojsonstring(senderinfo));
        matchcacheutil.setusermatchinfo(receiver, json.tojsonstring(receiverinfo));

        gamematchinfo gamematchinfo = new gamematchinfo();
        list<question> questions = questionsev.getallquestion();
        gamematchinfo.setquestions(questions);
        gamematchinfo.setselfinfo(senderinfo);
        gamematchinfo.setopponentinfo(receiverinfo);

        messagereply.setcode(messagecode.success.getcode());
        messagereply.setdesc(messagecode.success.getdesc());

        result.setdata(gamematchinfo);
        set<string> set = new hashset<>();
        set.add(userid);
        result.setreceivers(set);
        result.settype(messagetypeenum.match_user);
        messagereply.setchatmessage(result);
        sendmessageall(messagereply);

        gamematchinfo.setselfinfo(receiverinfo);
        gamematchinfo.setopponentinfo(senderinfo);

        result.setdata(gamematchinfo);
        set.clear();
        set.add(receiver);
        result.setreceivers(set);
        messagereply.setchatmessage(result);

        sendmessageall(messagereply);

        log.info("chatwebsocket matchuser 用户随机匹配对手结束 messagereply: {}", json.tojsonstring(messagereply));

    }, commonfield.match_task_name_prefix + userid);
    matchthread.start();
}

项目展示

项目代码如下：https://github.com/yee-q/match-project

跑起来后，使用 websocket-client 可以进行测试。在浏览器打开，在控制台查看消息。

在连接输入框随便输入一个数字作为 userid，点击连接，此时客户端就和服务端建立 websocket 连接了

点击加入用户按钮，用户“进入匹配大厅”

点击随机匹配按钮，开始匹配，再取消匹配

按照之前的步骤再建立一个用户连接，都点击随机匹配按钮，匹配成功，服务端返回响应信息

用户分数更新时，在输入框输入新的分数，比如 6，点击实时更新按钮，对手将受到最新的分数消息

当双方都点击游戏结束按钮，则游戏结束

以上就是springboot + websocket 实现答题对战匹配机制案例详解的详细内容，更多关于springboot websocket答题对战的资料请关注其它相关文章！