websocket服务器推送

1.1 服务器推送

WebSocket作为一种通信协议，属于服务器推送技术的一种，IE10+支持。

服务器推送技术不止一种，有短轮询、长轮询、WebSocket、Server-sent Events（SSE）等，他们各有优缺点：

#	短轮询	长轮询	Websocket	sse
通讯方式	http	http	基于TCP长连接通讯	http
触发方式	轮询	轮询	事件	事件
优点	兼容性好容错性强，实现简单	比短轮询节约资源	全双工通讯协议，性能开销小、安全性高，有一定可扩展性	实现简便，开发成本低
缺点	安全性差，占较多的内存资源与请求数	安全性差，占较多的内存资源与请求数	传输数据需要进行二次解析，增加开发成本及难度	只适用高级浏览器
适用范围	b/s服务	b/s服务	网络游戏、银行交互和支付	服务端到客户端单向推送

短轮询最简单，在一些简单的场景也会经常使用，就是隔一段时间就发起一个ajax请求。那么长轮询是什么呢？

长轮询(Long Polling)是在Ajax轮询基础上做的一些改进，在没有更新的时候不再返回空响应，而且把连接保持到有更新的时候，客户端向服务器发送Ajax请求，服务器接到请求后hold住连接，直到有新消息才返回响应信息并关闭连接，客户端处理完响应信息后再向服务器发送新的请求。它是一个解决方案，但不是最佳的技术方案。

如果说短轮询是客户端不断打电话问服务端有没有消息，服务端回复后立刻挂断，等待下次再打；长轮询是客户端一直打电话，服务端接到电话不挂断，有消息的时候再回复客户端并挂断。

SSE(Server-Sent Events)与长轮询机制类似，区别是每个连接不只发送一个消息。客户端发送一个请求，服务端保持这个连接直到有新消息发送回客户端，仍然保持着连接，这样连接就可以支持消息的再次发送，由服务器单向发送给客户端。然而IE直到11都不支持，不多说了....

1.2 WebSocket的特点

为什么已经有了轮询还要WebSocket呢，是因为短轮询和长轮询有个缺陷：通信只能由客户端发起。

那么如果后端想往前端推送消息需要前端去轮询，不断查询后端是否有新消息，而轮询的效率低且浪费资源（必须不停 setInterval 或 setTimeout 去连接，或者 HTTP 连接始终打开），WebSocket提供了一个文明优雅的全双工通信方案。一般适合于对数据的实时性要求比较强的场景，如通信、股票、直播、共享桌面，特别适合于客户端与服务频繁交互的情况下，如聊天室、实时共享、多人协作等平台。

特点

1. 建立在 TCP 协议之上，服务器端的实现比较容易。
2. 与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。
3. 数据格式比较轻量，性能开销小，通信高效。服务器与客户端之间交换的标头信息大概只有2字节;
4. 可以发送文本，也可以发送二进制数据。
5. 没有同源限制，客户端可以与任意服务器通信。
6. 协议标识符是ws（如果加密，则为wss），服务器网址就是 URL。ex：ws://example.com:80/some/path
7. 不用频繁创建及销毁TCP请求，减少网络带宽资源的占用，同时也节省服务器资源;
8. WebSocket是纯事件驱动的，一旦连接建立，通过监听事件可以处理到来的数据和改变的连接状态，数据都以帧序列的形式传输。服务端发送数据后，消息和事件会异步到达。
9. 无超时处理。

HTTP与WS协议结构

WebSocket协议标识符用ws表示。`wss协议表示加密的WebSocket协议，对应HTTPs协议。结构如下：

• HTTP: TCP > HTTP
• HTTPS: TCP > TLS > HTTP
• WS: TCP > WS
• WSS: TCP > TLS > WS

以下是简单代码记录，亲测可用,基于springMVC的服务器推送技术websocket。

1.gradle构建，websocket引入的包："org.springframework:spring-websocket:4.2.4.RELEASE"

2.context.xml配置需要加的地方

xmlns:websocket="http://www.springframework.org/schema/websocket"

http://www.springframework.org/schema/websocket

http://www.springframework.org/schema/websocket/spring-websocket-4.1.xsd

3.websocket的配置类

 4.websocke接受消息以及处理的类

5.页面js代码

 

6.简单的运行效果

 

 

 涉及到的代码就这几个，拷贝到springmvc项目里就可以。

package com.kitty.activity.common.websocket;

import org.springframework.stereotype.Service;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Created by liuxn on 2018/5/22 0022.
 */
@Service
public class MyHandler extends TextWebSocketHandler {
    //在线用户列表
    private static final Map<Integer, WebSocketSession> users;
    //用户标识
    private static final String CLIENT_ID = "userId";

    static {
        users = new HashMap<>();
    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        System.out.println("成功建立连接");
        Integer userId = getClientId(session);
        if (userId != null) {
            users.put(userId, session);
            session.sendMessage(new TextMessage("你已成功建立socket连接"));
            System.out.println(userId);
            System.out.println(session);
        }
    }

    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
        // ...
        System.out.println("收到客户端消息:"+message.getPayload());

        WebSocketMessage message1 = new TextMessage("server:"+message);
        try {
            session.sendMessage(message1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        if (session.isOpen()) {
            session.close();
        }
        System.out.println("连接出错");
        users.remove(getClientId(session));
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        System.out.println("连接已关闭：" + status);
        users.remove(getClientId(session));
    }

    /**
     * 发送信息给指定用户
     * @param clientId
     * @param message
     * @return
     */
    public boolean sendMessageToUser(Integer clientId, TextMessage message) {
        if (users.get(clientId) == null) return false;
        WebSocketSession session = users.get(clientId);
        System.out.println("sendMessage:" + session+",msg:"+message.getPayload());
        if (!session.isOpen()) return false;
        try {
            session.sendMessage(message);
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 广播信息
     * @param message
     * @return
     */
    public boolean sendMessageToAllUsers(TextMessage message) {
        boolean allSendSuccess = true;
        Set<Integer> clientIds = users.keySet();
        WebSocketSession session = null;
        for (Integer clientId : clientIds) {
            try {
                session = users.get(clientId);
                if (session.isOpen()) {
                    session.sendMessage(message);
                }
            } catch (IOException e) {
                e.printStackTrace();
                allSendSuccess = false;
            }
        }

        return  allSendSuccess;
    }

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

    /**
     * 获取用户标识
     * @param session
     * @return
     */
    private Integer getClientId(WebSocketSession session) {
        try {
            Integer clientId = (Integer) session.getAttributes().get(CLIENT_ID);
            return clientId;
        } catch (Exception e) {
            return null;
        }
    }
}

package com.kitty.activity.common.websocket;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.socket.TextMessage;

import javax.servlet.http.HttpSession;

 
@Controller
public class SocketController {

    @Autowired
    MyHandler handler;

    //玩家登录
    @RequestMapping("/external/login/{userId}")
    public ModelAndView login(HttpSession session, @PathVariable("userId") Integer userId) {
        System.out.println("登录接口,userId=" + userId);
        session.setAttribute("userId", userId);
        System.out.println(session.getAttribute("userId"));

        return new ModelAndView("phone/websocket_test");
    }

    //模拟给指定玩家发消息
    @RequestMapping("/external/message")
    @ResponseBody
    public String sendMessage(Integer userId,String message) {
        boolean hasSend = handler.sendMessageToUser(userId, new TextMessage(message));
        System.out.println(hasSend);
        return "success";
    }


    //模拟给所有玩家发消息
    @RequestMapping("/external/message/all")
    @ResponseBody
    public String sendAll(String message) {
        boolean hasSend = handler.sendMessageToAllUsers(new TextMessage(message));
        System.out.println(hasSend);
        return "success";
    }

}

package com.kitty.activity.common.websocket;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

 
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/external/myHandler").addInterceptors(new WebSocketInterceptor());
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new MyHandler();
    }
}

package com.kitty.activity.common.websocket;

import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

import javax.servlet.http.HttpSession;
import java.util.Map;

/**
 * 
 */
public class WebSocketInterceptor implements HandshakeInterceptor {

    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler handler, Map<String, Object> map) throws Exception {
        if (request instanceof ServletServerHttpRequest) {
            System.out.println("*****beforeHandshake******");
            ServletServerHttpRequest serverHttpRequest = (ServletServerHttpRequest) request;
            HttpSession session = serverHttpRequest.getServletRequest().getSession();
//            Map parameterMap = serverHttpRequest.getServletRequest().getParameterMap();
//            System.out.println(parameterMap);
            if (session != null) {
                map.put("userId", session.getAttribute("userId"));
            }

        }
        return true;
    }

    @Override
    public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
        System.out.println("******afterHandshake******");
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<c:set var="ctx" value="${pageContext.request.contextPath}"/>
<html>
<head>
    <meta charset="utf-8">
    <meta content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=no" name="viewport">
    <meta content="yes" name="apple-mobile-web-app-capable">
    <meta content="black" name="apple-mobile-web-app-status-bar-style">
    <meta content="telephone=no" name="format-detection">
    <meta content="email=no" name="format-detection">
    <meta name="baseUrl" content="${ctx}"/>
    <meta name="roleId" content="${roleId}"/>
    <title>websocket</title>
    <script src="${ctx}/assets/js/jquery.min.js"></script>
    <script src="http://cdn.jsdelivr.net/sockjs/1.0.1/sockjs.min.js"></script>

</head>

<body>
<div class="act-outline" width="100%">
    it is work.
</div>
<script>
    //websocket
    $(function () {
        var baseUrl = $('meta[name="baseUrl"]').attr("content");
        //判断当前浏览器是否支持WebSocket
        var websocket;
        if ('WebSocket' in window) {
            websocket = new WebSocket('ws://' + window.location.host + '/activity/external/myHandler');
            //      var ws = new WebSocket('ws://192.168.3.26:8999/activity/external/myHandler') //也可以指定ip
        } else if ('MozWebSocket' in window) {
            websocket = new MozWebSocket("ws://" + window.location.host + '/activity/external/myHandler'); //未测试
        } else {
            websocket = new SockJS("http://" + window.location.host + '/activity/external/myHandler'); //未测试
        }

        websocket.onopen = function () {
                    console.log("正在打开连接,准备发消息给服务器...");
            websocket.send("{text:hello}");
        }
        websocket.onclose = function () {
                    console.log("服务器关闭连接:onclose");
        }

        websocket.onmessage = function (msg) {
                    console.log("收到服务器推送数据:"+msg.data);
        }


    })
</script>
</body>
</html>

 备注：http://ip:port/activity 是项目根目录。

参考链接地址：

https://blog.csdn.net/u014520745/article/details/62046396

https://www.cnblogs.com/interdrp/p/7903736.html