WebSocket

一  概念   什么是WebSocket

WebSocket协议是基于TCP的一种新的网络协议。随着HTML5的诞生，WebSocket协议被提出，它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。

与传统HTTP协议做对比

  传统的HTTP协议是无状态的，每次请求（request）都要由客户端（如浏览器）主动发起，服务端进行处理后应道（response）结果，而服务端很难主动向客户端发送数据。

这种客户端是主动方，服务端是被动方的Web模式，对应信息变化不频繁的Web应用来说影响不大，而对于涉及实时信息的Web应用却带来了很大的不便，

如 即时通信，实时数据，订阅消息推送等功能的应用。 所以开发人员要实现实时性比较强的功能，经常要使用折中的解决方法： 轮询（polling）和 Comet（也称反向Ajax或服务器端推技术）

其实  Comet 本质上也是一种轮询，只不过有所改进

轮询 是最原始的实现实时Web应用的解决方案。轮询技术要求客户端以设定的时间间隔周期性地向服务端发送请求，频繁地查询是否有新的数据改动。明显地，这种方法会导致过多不必要的请求，浪费流量和服务器资源。

Comet 技术又可以分为长轮询和流技术。长轮询改进了上述的轮询技术，减小了无用的请求。它会为某些数据设定过期时间，当数据过期后才会向服务端发送请求；这种机制适合数据的改动不是特别频繁的情况。流技术通常是指客户端使用一个隐藏的窗口与服务端建立一个HTTP长连接，服务端会不断更新连接状态以保持HTTP长连接存活；这样的话，服务端就可以通过这条长连接主动将数据发送给客户端；流技术在大并发环境下，可能会考验到服务端的性能。

 这两种技术都是基于请求-应答模式，都不算是真正意义上的实时技术；它们的每一次请求、应答，都浪费了一定流量在相同的头部信息上，并且开发复杂度也较大。

伴随着HTML5推出的WebSocket，真正实现了Web的实时通信，使B/S模式具备了C/S模式的实时通信能力。WebSocket的工作流程是这 样的：浏览器通过JavaScript向服务端发出建立WebSocket连接的请求，在WebSocket连接建立成功后，客户端和服务端就可以通过 TCP连接传输数据。因为WebSocket连接本质上是TCP连接，不需要每次传输都带上重复的头部数据，所以它的数据传输量比轮询和Comet技术小 了很多。本文不详细地介绍WebSocket规范，主要介绍下WebSocket在Java Web中的实现。

 

二  WebSocket 示例

服务端实现

2.1 首先加入pom依赖

<dependency>
　　<groupId>javax.websocket</groupId>
　　<artifactId>javax.websocket-api</artifactId>
　　<version>1.1</version>
　　<scope>provided</scope>
</dependency>

 2.2 、创建一个WebSocket服务端类MyWebSocketServer，

并在类前添加@ServerEndpoint(value = "/websocket")注解，@ServerEndpoint(value = "/websocket")注释端点表示将 WebSocket 服务端运行在 ws://[Server 端 IP 或域名]:[Server 端口]/项目名/websocket 的访问端点

2.3 、实现onOpen、onClose、onMessage、onError等方法

import java.io.IOException;
import javax.websocket.EncodeException;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import net.sf.json.JSONObject;

@ServerEndpoint(value = "/websocket")
public class MyWebSocketServer {
　　private Logger logger = Logger.getLogger(MyWebSocketServer.class);
　　private Session session;

　　/**
　　* 连接建立后触发的方法
　　 */
　　@OnOpen
　　public void onOpen(Session session){
　　　　this.session = session;
　　　　logger.info("onOpen"+session.getId());
　　　　WebSocketMapUtil.put(session.getId(),this);
　　}

　　/**
　　* 连接关闭后触发的方法
　　*/
　　@OnClose
　　public void onClose(){
　　　　//从map中删除
　　　　WebSocketMapUtil.remove(session.getId());
　　　　logger.info("====== onClose:"+session.getId()+" ======");
　　}

　　/**
　　 * 接收到客户端消息时触发的方法
　　 */
　　@OnMessage
　　public void onMessage(String params,Session session) throws Exception{
　　　　//获取服务端到客户端的通道
　　　　MyWebSocketServer myWebSocket = WebSocketMapUtil.get(session.getId());
　　　　logger.info("收到来自"+session.getId()+"的消息"+params);
　　　　String result = "收到来自"+session.getId()+"的消息"+params;
　　　　//返回消息给Web Socket客户端（浏览器）
　　　　myWebSocket.sendMessage(1,”成功！”,result);
　　}
　　/**
　　 * 发生错误时触发的方法
　　*/
　　@OnError
　　public void onError(Session session,Throwable error){
　　　　logger.info(session.getId()+"连接发生错误"+error.getMessage());
　　　　error.printStackTrace();
　　}

　　public void sendMessage(int status,String message,Object datas) throws IOException{
　　　　JSONObject result = new JSONObject();
　　　　result.put("status", status);
　　　　result.put("message", message);
　　　　result.put("datas", datas);
this.session.getBasicRemote().sendText(result.toString());
}

}

WebSocketMapUtil 工具类

import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class WebSocketMapUtil {

　　public static ConcurrentMap<String, MyWebSocketServer> webSocketMap = new ConcurrentHashMap<>();

　　public static void put(String key, MyWebSocketServer myWebSocketServer){
     　　webSocketMap.put(key, myWebSocketServer);
    }

    public static MyWebSocketServer get(String key){
         return webSocketMap.get(key);
    }

    public static void remove(String key){
         webSocketMap.remove(key);
    }
 
    public static Collection<MyWebSocketServer> getValues(){
        return webSocketMap.values();
    }
}

2.4 客户端实现（后端代码实现）

加入依赖

        <dependency>
            <groupId>org.java-websocket</groupId>
            <artifactId>Java-WebSocket</artifactId>
            <version>1.3.5</version>
        </dependency>

后端代码实现

package com.differ.opensdk.service.websocket;


import org.java_websocket.WebSocket;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;

import java.net.URI;

/**
 * 自己的webSocket类
 *
 * @author hup
 * @data 2020-05-19 20:39
 **/
public class MyWebSocketClient extends WebSocketClient {
    //webSocket url
    public static final String url = "ws://192.168.98.78/sfr";/**
     * 获取 已连接上的 MyWebSocketClient 对象
     *
     * @param client webSocket 对象
     * @return 已连接上的 MyWebSocketClient 对象
     */
    public static MyWebSocketClient getMySocketClient(MyWebSocketClient client) {
        //判断连接状态
        while (client == null || !client.getReadyState().equals(WebSocket.READYSTATE.OPEN)) {
            try {
                client = new MyWebSocketClient(new URI(MyWebSocketClient.url));
            } catch (Exception ex) {
                ;
            }
        }
        System.out.println("建立websocket连接");
        return client;
    }

    public MyWebSocketClient(URI serverUri) {
        super(serverUri);
    }

    @Override
    public void onOpen(ServerHandshake serverHandshake) {
        System.out.println("客户端连接了服务器");
    }

    @Override
    public void onMessage(String s) {
        System.out.println("接收到消息：" + s);
    }

    @Override
    public void onClose(int i, String s, boolean b) {
        System.out.println("服务器关闭...");
    }

    @Override
    public void onError(Exception e) {
        System.out.println("连接异常" + e);
    }
}

测试类

    public void testSocket() {
        try {
            MyWebSocketClient client = MyWebSocketClient.getMySocketClient(null);
            client.send("我是测试消息");//发送消息
        } catch (Exception e) {
            System.out.println("异常" + e);
        }
        System.out.println("发送消息成功");
    }

2.5 网页实现客户端

<script type="text/javascript"  
        src="http://localhost:8080/Bank/js/sockjs-0.3.min.js"></script>  
    <script>  
        var websocket;  
      
        if ('WebSocket' in window) {  
            websocket = new WebSocket("ws://" + document.location.host + "/Bank/webSocketServer");  
        } else if ('MozWebSocket' in window) {  
            websocket = new MozWebSocket("ws://" + document.location.host + "/Bank/webSocketServer");  
        } else {  
            websocket = new SockJS("http://" + document.location.host + "/Bank/sockjs/webSocketServer");  
        }  
      
        websocket.onopen = function(evnt) {};  
        websocket.onmessage = function(evnt) {  
            $("#test").html("(<font color='red'>" + evnt.data + "</font>)")  
        };  
      
        websocket.onerror = function(evnt) {};  
        websocket.onclose = function(evnt) {}  
      
        $('#btn').on('click', function() {  
            if (websocket.readyState == websocket.OPEN) {  
                var msg = $('#id').val();  
                //调用后台handleTextMessage方法  
                websocket.send(msg);  
            } else {  
                alert("连接失败!");  
            }  
        });  
    </script> 

--end