WebSocket

时间  2019-11-12
标签 websocket 繁體版
原文   原文链接

WebSocket是什么？javascript

WebSocket是一种在单个TCP链接上进行全双向通讯的协议。
WebSocket使得客户端和服务器之间的数据交换变得更加简单，容许服务端主动向客户端推送数据。
在WebSocket API中，浏览器和服务器只须要完成一次握手，二者之间就直接能够建立持久性的链接，并进行双向数据传输。
Websocket 经过HTTP/1.1 协议的101状态码进行握手。html

 

握手java

在客户端，new WebSocket实例化一个新的WebSocket客户端对象，请求相似 ws://yourdomain:port/path 的服务端WebSocket URL，客户端WebSocket对象会自动解析并识别为WebSocket请求，并链接服务端端口，执行双方握手过程，客户端发送数据格式相似：web

能够看到，客户端发起的WebSocket链接报文相似传统HTTP报文，Upgrade：websocket参数值代表这是WebSocket类型请求，Sec-WebSocket-Key是WebSocket客户端发送的一个 base64编码的密文，要求服务端必须返回一个对应加密的Sec-WebSocket-Accept应答，不然客户端会抛出Error during WebSocket handshake错误，并关闭链接。spring

服务端收到报文后返回的数据格式相似：浏览器

Sec-WebSocket-Accept的值是服务端采用与客户端一致的密钥计算出来后返回客户端的，HTTP/1.1 101 Switching Protocols表示服务端接受WebSocket协议的客户端链接，通过这样的请求-响应处理后，两端的WebSocket链接握手成功, 后续就能够进行TCP通信了。安全

 

保持长链接服务器

服务器和客户端经过发送Ping/Pong+Frame（RFC+6455+-+The+WebSocket+Protocol）。这种 Frame+是一种特殊的数据包，它只包含一些元数据而不须要真正的 Data+Payload，能够在不影响应用的状况下维持住中间网络的链接状态。websocket

 

例子1网络

pom文件：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
    <version>1.3.5.RELEASE</version>
</dependency>

java:

package com.test;

import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

@ServerEndpoint(value = "/websocket")
@Component
public class WebSocketController {
    //当前在线链接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;

    //concurrent包的线程安全Set，用来存放每一个客户端对应的WebSocket对象。
    private static CopyOnWriteArraySet<WebSocketController> webSocketSet = new CopyOnWriteArraySet<WebSocketController>();

    //与某个客户端的链接会话，须要经过它来给客户端发送数据
    private Session session;

    /**
     * 链接创建成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        webSocketSet.add(this);//加入set中
        addOnlineCount();//在线数加1
        System.out.println("有新链接加入！当前在线人数为" + getOnlineCount());
        try {
            sendMessage("init success!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 链接关闭调用的方法
     */
    @OnClose
    public void onClose() {
        webSocketSet.remove(this);//从set中删除
        subOnlineCount();//在线数减1
        System.out.println("有一链接关闭！当前在线人数为" + getOnlineCount());
    }

    /**
     * 收到客户端消息后调用的方法
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("来自客户端的消息:" + message);
        try {
            session.getBasicRemote().sendText("service:"+message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 发生错误时调用
     */
     @OnError
     public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
     }

    /**
     * 发送消息
     */
     public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
     }

     /**
      * 群发自定义消息
      */
    public static void sendInfo(String message) {
        if(webSocketSet!=null && webSocketSet.size()>0) {
            for (WebSocketController item : webSocketSet) {
                try {
                    item.sendMessage(message);
                } catch (IOException e) {
                    e.printStackTrace();
                    continue;
                }
            }
        }
    }

    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        WebSocketController.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        WebSocketController.onlineCount--;
    }
}

　

package com.test;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@Configuration
public class WebSocketConfig {

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

html:

<!DOCTYPE HTML>
<html>
<head>
    <meta charset="UTF-8">
    <title>WebSocket</title>
</head>

<body>
    Welcome Use WebSocket<br/>
    <input id="text" type="text" />
    <button onclick="send()">Send</button>
    <button onclick="closeWebSocket()">Close</button>
    <div id="message"></div>
</body>
<script type="text/javascript">
    var websocket = null;

    //判断当前浏览器是否支持WebSocket
    if('WebSocket' in window){
        websocket = new WebSocket("ws://localhost:8080/websocket");
    } else{
        alert('Not support websocket')
    }

    //链接发生错误的回调方法
    websocket.onerror = function(){
        setMessageInnerHTML("error");
    };

    //链接成功创建的回调方法
    websocket.onopen = function(event){
        setMessageInnerHTML("open");
    }

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

    //链接关闭的回调方法
    websocket.onclose = function(){
        setMessageInnerHTML("close");
    }

    //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket链接，防止链接还没断开就关闭窗口，server端会抛异常。
    window.onbeforeunload = function(){
        websocket.close();
    }

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

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

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

　　例子2（一个websocket分发多个功能，经过参数区分）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
    <version>1.3.5.RELEASE</version>
</dependency>
package com.cuc.happyseat.config.websocket;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * 开启WebSocket支持
 */
@Configuration  
public class WebSocketConfig {  
    
    @Bean  
    public ServerEndpointExporter serverEndpointExporter() {  
        return new ServerEndpointExporter();  
    }  
  
}

　　

WebSocket服务类对照下面的代码看：

第20行，@ServerEndpoint("/websocket/{userID}")，括号中的内容就是客户端请求Socket链接时的访问路径，userID是我要求客户端传来的参数，我这里算是为了标识该客户端吧。
第28行，在该类中添加属性 userID，并添加对应的getUserID()方法。
第46行，在onOpen()方法即创建链接的时候就接收参数userID，须要标识@PathParam("userID") 。接收参数后直接赋值给属性userID。
第140-157行，是针对特定客户端发送消息。服务器和客户端在创建链接成功后就生成了一个WebSocket对象，并存在集合中，对象里特有的属性是咱们设置的userID。因此经过惟一的userID就能标识服务器与该客户端创建的那个链接啦！这样要求发送消息时，传入userID与消息，服务器在本身的WebSocket链接集合中遍历找到对应客户端的链接，就能够直接发消息过去啦~~

package com.cuc.happyseat.websocket;

import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

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.springframework.stereotype.Component;

/*@ServerEndpoint注解是一个类层次的注解，它的功能主要是将目前的类定义成一个websocket服务器端,
 * 注解的值将被用于监听用户链接的终端访问URL地址,客户端能够经过这个URL来链接到WebSocket服务器端
*/
@ServerEndpoint("/websocket/{userID}")
@Component
public class WebSocketServer {

	//每一个客户端都会有相应的session,服务端能够发送相关消息
	private Session session;

	//接收userID
	private Integer userID;
 
	//J.U.C包下线程安全的类，主要用来存放每一个客户端对应的webSocket链接
	private static CopyOnWriteArraySet<WebSocketServer> copyOnWriteArraySet = new CopyOnWriteArraySet<WebSocketServer>();

	public Integer getUserID() {
		return userID;
	}
    
	/**
	 * @Name：onOpen
	 * @Description：打开链接。进入页面后会自动发请求到此进行链接
	 * @Author：mYunYu
	 * @Create Date：14:46 2018/11/15
	 * @Parameters：@PathParam("userID") Integer userID
	 * @Return：
	 */
	@OnOpen
	public void onOpen(Session session, @PathParam("userID") Integer userID) {
		this.session = session;
		this.userID = userID;
		System.out.println(this.session.getId());
		copyOnWriteArraySet.add(this);
	}

	/**
	 * @Name：onClose
	 * @Description：用户关闭页面，即关闭链接
	 * @Author：mYunYu
	 * @Create Date：14:46 2018/11/15
	 * @Parameters：
	 * @Return：
	 */
	@OnClose
	public void onClose() {
		copyOnWriteArraySet.remove(this);
	}

	/**
	 * @Name：onMessage
	 * @Description：测试客户端发送消息，测试是否联通
	 * @Author：mYunYu
	 * @Create Date：14:46 2018/11/15
	 * @Parameters：
	 * @Return：
	 */
	@OnMessage
	public void onMessage(String message) {
		System.out.println("websocket收到客户端发来的消息:"+message);
	}

	/**
	 * @Name：onError
	 * @Description：出现错误
	 * @Author：mYunYu
	 * @Create Date：14:46 2018/11/15
	 * @Parameters：
	 * @Return：
	 */
	@OnError
	public void onError(Session session, Throwable error) {
		System.out.println("发生错误：" + error.getMessage() + "; sessionId:" + session.getId());
		error.printStackTrace();
	}

	public void sendMessage(Object object){
		//遍历客户端
		for (WebSocketServer webSocket : copyOnWriteArraySet) {
			System.out.println("websocket广播消息：" + object.toString());
			try {
				//服务器主动推送
				webSocket.session.getBasicRemote().sendObject(object) ;
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * @Name：sendMessage
	 * @Description：用于发送给客户端消息（群发）
	 * @Author：mYunYu
	 * @Create Date：14:46 2018/11/15
	 * @Parameters：
	 * @Return：
	 */
	public void sendMessage(String message) {
		//遍历客户端
		for (WebSocketServer webSocket : copyOnWriteArraySet) {
			System.out.println("websocket广播消息：" + message);
			try {
				//服务器主动推送
				webSocket.session.getBasicRemote().sendText(message);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * @throws Exception 
	 * @Name：sendMessage
	 * @Description：用于发送给指定客户端消息
	 * @Author：mYunYu
	 * @Create Date：14:47 2018/11/15
	 * @Parameters：
	 * @Return：
	 */
	public void sendMessage(Integer userID, String message) throws Exception {
		Session session = null;
		WebSocketServer tempWebSocket = null;
		for (WebSocketServer webSocket : copyOnWriteArraySet) {
			if (webSocket.getUserID() == userID) {
				tempWebSocket = webSocket;
				session = webSocket.session;
				break;
			}
		}
		if (session != null) {
			//服务器主动推送
			tempWebSocket.session.getBasicRemote().sendText(message);
		} else {
			System.out.println("没有找到你指定ID的会话：{}"+ "; userId:" + userID);
		}
	}    
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程