WebSocket原理与实践

开题思考：如何实现客户端及时获取服务端数据？

Polling

指客户端每隔一段时间（周期性）请求服务端获取数据，可能有更新数据返回，也可能什么都没有，它并不在乎服务端数据有无更新。（Web端一般采用ajax polling实现）

Long Polling

阻塞型Polling，和Polling不同的是假如服务端数据没有准备好，那么可能会hold住请求，直到服务端有相关数据，或者等待一定时间超时才会返回。

WebSocket

HTML5 WebSocket规范定义了一种API，使Web页面能够使用WebSocket协议与远程主机进行双向通信。与轮询和长轮询相比，巨大减少了不必要的网络流量和等待时间。

Websocket体系结构

Websocket协议

WebSocket协议被设计成与现有的Web基础结构很好地工作。该协议规范定义了HTTP连接作为WebSocket连接生命的开始，从Http协议转换成WebSocket，被称为WebSocket握手。

浏览器向服务器发送请求，表示它希望将协议从HTTP切换到WebSocket。客户端通过升级报头表达其愿望：

GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13
Origin: http://example.com

从上面的报文可以看到，和HTTP协议的请求中，多了几样东西，核心就是Upgrade和Connection两个参数，用来告诉服务器，我需要升级为Websocket：
```
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13
```

如果服务端能够理解WebSocket协议，它同意以Upgrade头字段来升级协议，会响应以下信息：

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept:HSmrc0sMlYUkAGmm5OPpG2HaGWk=
Sec-WebSocket-Protocol: chat

此时，HTTP连接中断，并由同一底层TCP/IP连接上的WebSocket连接替换。默认情况下，WebSocket连接使用与HTTP（80）和HTTPS（443）相同的端口。

Spring-WebSocket实战

Spring框架提供了WebSocket支持，很容易实现相关功能，此处分享一下使用Spring集成WebSocket实现简单的多人会议系统。

服务端相关代码

MeetingController （很简单的一个入口，创建会议，并生成会议id和对应随机串）

@Controller
public class MeetingController {

    private static AtomicInteger id = new AtomicInteger(0);

    @RequestMapping(value = "/meeting", method = RequestMethod.POST)
    @ResponseBody
    public Map<String, Object> createMeeting() {
        int meetingId = id.incrementAndGet();
        String randStr = RandomStringUtils.random(6, true, true);
        SystemCache.idRandStrMap.put(meetingId, randStr);
        Map<String, Object> meetingVO = new HashMap<>();
        meetingVO.put("id", meetingId);
        meetingVO.put("randStr", randStr);
        return meetingVO;
    }
}

WebSocketConfig （通过WebSocketConfigurer来配置定义自己的Websocket处理器和拦截器）

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        /**
         * 注册websocket处理器以及拦截器
         */
        registry.addHandler(meetingWebSocketHandler(), "/websocket/spring/meeting").addInterceptors(myInterceptor());
    }

    @Bean
    public MeetingWebSocketHandler meetingWebSocketHandler() {
        return new MeetingWebSocketHandler();
    }

    @Bean
    public WebSocketHandshakeInterceptor myInterceptor() {
        return new WebSocketHandshakeInterceptor();
    }
}

WebSocketHandshakeInterceptor （握手拦截器，用于处理请求携带参数）

public class WebSocketHandshakeInterceptor implements HandshakeInterceptor {

    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
            Map<String, Object> attributes) throws Exception {
        if (request instanceof ServletServerHttpRequest) {
            ServletServerHttpRequest serverHttpRequest = (ServletServerHttpRequest) request;
            String randStr = serverHttpRequest.getServletRequest().getParameter("randStr");
            String role = serverHttpRequest.getServletRequest().getParameter("role");
            if (StringUtils.isNotBlank(randStr)) {
                attributes.put("randStr", randStr);
            }
            if (StringUtils.isNotBlank(role)) {
                attributes.put("role", role);
            }
        }
        return true;
    }

   @Override
   public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
        Exception exception) {
   }
}

MeetingWebSocketHandler（websocket处理器，用于接受客户端发送各种类型数据，主要分为数据帧和控制帧）

@Service
public class MeetingWebSocketHandler extends TextWebSocketHandler {

    private static final Log LOG = LogFactory.getLog(MeetingWebSocketHandler.class);
    // 会议id和wsSession列表
    private static final ConcurrentHashMap<Integer, CopyOnWriteArraySet<WebSocketSession>> meetingWsSeesionMap = new ConcurrentHashMap<>();

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        LOG.info("spring websocket成功建立连接...");
        int meetingId = getMeetingId(session);
        if (meetingId <= 0) {
            singleMessage(session, new TextMessage("会议不存在!"));
            session.close();
        }
        // 如果该会议已存在，则直接加入
        if (meetingWsSeesionMap.containsKey(meetingId)) {
            CopyOnWriteArraySet<WebSocketSession> webSocketSessions = meetingWsSeesionMap.get(meetingId);
            webSocketSessions.add(session);
        }
        // 如果不存在，则新建
        else {
            CopyOnWriteArraySet<WebSocketSession> webSocketSessions = new CopyOnWriteArraySet<>();
            webSocketSessions.add(session);
            meetingWsSeesionMap.put(meetingId, webSocketSessions);
        }
    }

    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
        if (!session.isOpen())
            return;
        LOG.info(message.getPayload());
        int meetingId = getMeetingId(session);
        TextMessage wsMessage = new TextMessage(message.getPayload());
        broadcastMessage(meetingId, wsMessage);
    }

    /**
     * 发送信息给指定用户
     * @param clientId
     * @param message
     * @return
     */
    public void singleMessage(WebSocketSession session, TextMessage message) {
        if (!session.isOpen())
            return;
        try {
            session.sendMessage(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 广播信息
     * @param message
     * @return
     */
    public void broadcastMessage(int meetingId, TextMessage message) {
        // 获取会议所有的wsSession
        CopyOnWriteArraySet<WebSocketSession> webSocketSessions = meetingWsSeesionMap.get(meetingId);
        for (WebSocketSession session : webSocketSessions) {
            try {
                if (session.isOpen()) {
                    session.sendMessage(message);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        if (session.isOpen()) {
            session.close();
        }
        LOG.info("连接出错");
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        LOG.info("连接已关闭：" + status);
        int meetingId = getMeetingId(session);
        // role 1为主持人
        String role = String.valueOf(session.getAttributes().get("role"));
        // 如果是主持人，则关闭所有该会议连接
        CopyOnWriteArraySet<WebSocketSession> webSocketSessions = meetingWsSeesionMap.get(meetingId);
        if (StringUtils.equals("1", role)) {
            SystemCache.idRandStrMap.remove(meetingId);
            for (WebSocketSession webSocketSession : webSocketSessions) {
                webSocketSession.close();
            }
            webSocketSessions.remove(meetingId);
        } else {
            webSocketSessions.remove(session);
        }
    }

    @Override
    public boolean supportsPartialMessages() {
        return false;
    }

    private int getMeetingId(WebSocketSession session) {
        String randStr = String.valueOf(session.getAttributes().get("randStr"));
        int meetingId = SystemCache.getMeetingIdByRandStr(randStr);
        return meetingId;
    }
 }

SystemCache（系统缓存，集群部署的情况下，可改为redis实现分布式缓存，单机则不需要）

public class SystemCache {

    // 会议id和随机字符串的映射关系
    public static ConcurrentHashMap<Integer, String> idRandStrMap = new ConcurrentHashMap<>();

    public static int getMeetingIdByRandStr(String randStr) {
        int meetingId = 0;
        for (Map.Entry<Integer, String> entry : idRandStrMap.entrySet()) {
            if (randStr.equals(entry.getValue())) {
                meetingId = entry.getKey();
            }
        }
        return meetingId;
    }
}

前端相关代码

meeting-create.html（主持人页面，用于创建会议并且可以发送消息）

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>在线会议系统</title>
</head>
<body>
    <h2>欢迎使用会议系统</h2>
    <button id="create" onclick="createMeeting()">创建会议</button>
    <hr />
    <div id="meeting"></div>
    消息内容：
    <input id="text" type="text" />
    <button id="send" disabled="disabled" onclick="send()">发送消息</button>
    <hr />
    <button id="close" onclick="closeWebSocket()">结束会议</button>
    <hr />
    <div id="message"></div>
</body>

<script type="text/javascript" src="js/jquery-1.12.0.js"></script>
<script type="text/javascript">
    var websocket = null;
    var randStr;
    var remote = window.location.host;
    function openWebsocket() {
        //判断当前浏览器是否支持WebSocket
        if ('WebSocket' in window) {
            websocket = new WebSocket("ws://" + window.location.host
                    + "/websocket/spring/meeting?role=1&randStr=" + randStr);

            //连接发生错误的回调方法
            websocket.onerror = function() {
                setMessageInnerHTML("会议连接发生错误!");
            };

            //连接成功建立的回调方法
            websocket.onopen = function() {
                setMessageInnerHTML("会议连接成功...");
                document.getElementById("send").disabled = false;
            }

            //接收到消息的回调方法
            websocket.onmessage = function(event) {
                setMessageInnerHTML(event.data);
            }

            //连接关闭的回调方法
            websocket.onclose = function() {
                setMessageInnerHTML("会议结束，连接关闭!");
                document.getElementById("create").disabled = false;
                document.getElementById("send").disabled = true;
            }

            //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常
            window.onbeforeunload = function() {
                closeWebSocket();
            }
        } else {
            alert('当前浏览器 Not support websocket');
        }
    }

    //将消息显示在网页上
    function setMessageInnerHTML(innerHTML) {
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }

    //关闭WebSocket连接
    function closeWebSocket() {
        websocket.close();
    }

    //发送消息
    function send() {
        var content = document.getElementById('text').value;
        websocket.send(content);
    }

    function createMeeting() {
        $.post("/meeting", function(data, status) {
            randStr = data.randStr;
            $("#create").after("<p>会议邀请码：" + randStr + "</p>");
            $("#create").attr("disabled", true);
            openWebsocket();
        });
}
</script>
</html>

meeting-join.html（观众页面，用于加入会议并且也可以发送消息）

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>在线会议系统</title>
</head>
<body>
    <h2>欢迎使用会议系统</h2>
    会议邀请码：
    <input id="randStr" type="text" />
    <button id="open" onclick="openWebsocket()">加入会议</button>
    <hr />
    消息内容：
    <input id="text" type="text" />
    <button id="send" disabled="disabled" onclick="send()">发送消息</button>
    <hr />
    <button id="close" disabled="disabled" onclick="closeWebSocket()">离开会议</button>
    <hr />
    <div id="message"></div>
</body>

<script type="text/javascript">
    var websocket = null;
    var remote = window.location.host;
    function openWebsocket() {
        var randStr = document.getElementById('randStr').value;
        //判断当前浏览器是否支持WebSocket
        if ('WebSocket' in window) {
            websocket = new WebSocket("ws://" + window.location.host
                    + "/websocket/spring/meeting?randStr=" + randStr);

            //连接发生错误的回调方法
            websocket.onerror = function() {
                setMessageInnerHTML("会议连接发生错误!");
            };

            //连接成功建立的回调方法
            websocket.onopen = function() {
                setMessageInnerHTML("会议连接成功...");
                document.getElementById("open").disabled = true;
                document.getElementById("randStr").disabled = true;
                document.getElementById("send").disabled = false;
                document.getElementById("close").disabled = false;
            }

            //接收到消息的回调方法
            websocket.onmessage = function(event) {
                setMessageInnerHTML(event.data);
            }

            //连接关闭的回调方法
            websocket.onclose = function() {
                setMessageInnerHTML("会议结束，连接关闭!");
                document.getElementById("randStr").disabled = false;
                document.getElementById("open").disabled = false;
                document.getElementById("send").disabled = true;
                document.getElementById("close").disabled = true;
            }

            //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常
            window.onbeforeunload = function() {
                closeWebSocket();
            }
        } else {
            alert('当前浏览器 Not support websocket');
        }
    }

    //将消息显示在网页上
    function setMessageInnerHTML(innerHTML) {
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }

    //关闭WebSocket连接
    function closeWebSocket() {
        websocket.close();
    }

    //发送消息
    function send() {
        var content = document.getElementById('text').value;
        websocket.send(content);
}
</script>
</html>

项目演示

访问meeting-create.html进入主持人界面，点击创建会议，生成会议邀请码，并显示会议连接成功，界面如下：
访问meeting-join.html进入观众界面，并通过上面的邀请码加入会议，界面如下：
此时双方就可以互相发送消息，主持人离开会议，则所有人退出，观众离开，不影响会议进行。
具体代码地址：https://gitee.com/yehx/websocket-meeting

总结

WebSocket作为一个双通道的协议，颠覆了传统的Client请求Server这种单向通道的模式。由于WebSocket的兴起，Web领域的实时推送技术也被广泛使用，可以简单实现让用户不需要刷新浏览器就可以获得实时更新。它有着广泛的应用场景，比如在线聊天室、在线客服系统、评论系统、WebIM等。