是目前比较成熟的技术了,WebSocket协议为创建客户端和服务器端需要实时双向通讯的webapp提供了一个选择。其为HTML5的一部分,WebSocket相较于原来开发这类app的方法来说,其能使开发更加地简单。大部分现在的浏览器都支持WebSocket,比如Firefox,IE,Chrome,Safari,Opera,并且越来越多的服务器框架现在也同样支持WebSocket。
在实际的生产环境中,要求多个WebSocket服务器必须具有高性能和高可用,那么WebSocket协议就需要一个负载均衡层,NGINX从1.3版本开始支持WebSocket,其可以作为一个反向代理和为WebSocket程序做负载均衡。
WebSocket协议与HTTP协议不同,但WebSocket握手与HTTP兼容,使用HTTP升级工具将连接从HTTP升级到WebSocket。这允许WebSocket应用程序更容易地适应现有的基础架构。例如,WebSocket应用程序可以使用标准HTTP端口80和443,从而允许使用现有的防火墙规则。
WebSocket应用程序可以在客户端和服务器之间保持长时间运行的连接,从而有助于开发实时应用程序。用于将连接从HTTP升级到WebSocket的HTTP升级机制使用Upgrade和Connection头。反向代理服务器在支持WebSocket时面临一些挑战。一个是WebSocket是一个逐跳协议,因此当代理服务器拦截客户端的升级请求时,需要向后端服务器发送自己的升级请求,包括相应的头文件。此外,由于WebSocket连接长期存在,与HTTP使用的典型短期连接相反,反向代理需要允许这些连接保持打开状态,而不是关闭它们,因为它们似乎处于空闲状态。
允许在客户机和后端服务器之间建立隧道,NGINX支持WebSocket。对于NGINX将升级请求从客户端发送到后台服务器,必须明确设置Upgrade和Connection标题。
Nginx开启websocket代理功能的配置如下:
1)编辑nginx.conf,在http区域内一定要添加下面配置:
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
map指令的作用:
该作用主要是根据客户端请求中$http_upgrade 的值,来构造改变$connection_upgrade的值,即根据变量$http_upgrade的值创建新的变量$connection_upgrade,
创建的规则就是{}里面的东西。其中的规则没有做匹配,因此使用默认的,即 $connection_upgrade 的值会一直是 upgrade。然后如果 $http_upgrade为空字符串的话,
那值会是 close。
2)编辑vhosts下虚拟主机的配置文件,在location匹配配置中添加如下内容:
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
示例如下:
upstream socket.kevin.com {
hash $remote_addr consistent;
server 10.0.12.108:9000;
server 10.0.12.109:9000;
}
location / {
proxy_pass http://socket.kevin.com/;
proxy_set_header Host $host:$server_port;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
WebSocket 机制
WebSocket是HTML5下一种新的协议。它实现了浏览器与服务器全双工通信,能更好的节省服务器资源和带宽并达到实时通讯的目的。它与HTTP一样通过已建立的TCP连接来传输数据,但是它和HTTP最大不同是:
1) WebSocket是一种双向通信协议。在建立连接后,WebSocket服务器端和客户端都能主动向对方发送或接收数据,就像Socket一样;
2)WebSocket需要像TCP一样,先建立连接,连接成功后才能相互通信。
传统HTTP客户端与服务器请求响应模式如下图所示:
WebSocket模式客户端与服务器请求响应模式如下图:
上图对比可以看出,相对于传统HTTP每次请求-应答都需要客户端与服务端建立连接的模式,WebSocket是类似Socket的TCP长连接通讯模式。一旦WebSocket连接建立后,后续数据都以帧序列的形式传输。在客户端断开WebSocket连接或Server端中断连接前,不需要客户端和服务端重新发起连接请求。在海量并发及客户端与服务器交互负载流量大的情况下,极大的节省了网络带宽资源的消耗,有明显的性能优势,且客户端发送和接受消息是在同一个持久连接上发起,实时性优势明显。
相比HTTP长连接,WebSocket有以下特点:
1)是真正的全双工方式,建立连接后客户端与服务器端是完全平等的,可以互相主动请求。而HTTP长连接基于HTTP,是传统的客户端对服务器发起请求的模式。
2)HTTP长连接中,每次数据交换除了真正的数据部分外,服务器和客户端还要大量交换HTTP header,信息交换效率很低。Websocket协议通过第一个request建立了TCP连接之后,之后交换的数据都不需要发送 HTTP header就能交换数据,这显然和原有的HTTP协议有区别所以它需要对服务器和客户端都进行升级才能实现(主流浏览器都已支持HTML5)。此外还有 multiplexing、不同的URL可以复用同一个WebSocket连接等功能。这些都是HTTP长连接不能做到的。
总的来说:
WebSocket与Http相同点
- 都是一样基于TCP的,都是可靠性传输协议。
- 都是应用层协议。
WebSocket与Http不同点
- WebSocket是双向通信协议,模拟Socket协议,可以双向发送或接受信息。HTTP是单向的。
- WebSocket是需要浏览器和服务器握手进行建立连接的。而http是浏览器发起向服务器的连接,服务器预先并不知道这个连接。
WebSocket与Http联系
WebSocket在建立握手时,数据是通过HTTP传输的。但是建立之后,在真正传输时候是不需要HTTP协议的。
在WebSocket中,只需要服务器和浏览器通过HTTP协议进行一个握手的动作,然后单独建立一条TCP的通信通道进行数据的传送。
WebSocket连接的过程是:
1)客户端发起http请求,经过3次握手后,建立起TCP连接;http请求里存放WebSocket支持的版本号等信息,如:Upgrade、Connection、WebSocket-Version等;
2)服务器收到客户端的握手请求后,同样采用HTTP协议回馈数据;
3)客户端收到连接成功的消息后,开始借助于TCP传输信道进行全双工通信。
下面再通过客户端和服务端交互的报文对比WebSocket通讯与传统HTTP的不同点:
1)在客户端,new WebSocket实例化一个新的WebSocket客户端对象,请求类似 ws://yourdomain:port/path 的服务端WebSocket URL,客户端WebSocket对象会自动解析并识别为WebSocket请求,并连接服务端端口,执行双方握手过程,客户端发送数据格式类似:
1 2 3 4 5 6 7 | GET /webfin/websocket/ HTTP /1 .1 Host: localhost Upgrade: websocket Connection: Upgrade Sec-WebSocket-Key: xqBt3ImNzJbYqRINxEFlkg== Origin: http: //localhost :8080 Sec-WebSocket-Version: 13 |
可以看到,客户端发起的WebSocket连接报文类似传统HTTP报文,Upgrade:websocket参数值表明这是WebSocket类型请求,Sec-WebSocket-Key是WebSocket客户端发送的一个 base64编码的密文,要求服务端必须返回一个对应加密的Sec-WebSocket-Accept应答,否则客户端会抛出Error during WebSocket handshake错误,并关闭连接。
2)服务端收到报文后返回的数据格式类似:
1 2 3 4 | HTTP /1 .1 101 Switching Protocols Upgrade: websocket Connection: Upgrade Sec-WebSocket-Accept: K7DJLdLooIwIG /MOpvWFB3y3FE8 = |
Sec-WebSocket-Accept
的值是服务端采用与客户端一致的密钥计算出来后返回客户端的,HTTP/1.1 101 Switching Protocols
表示服务端接受WebSocket协议的客户端连接,经过这样的请求-响应处理后,两端的WebSocket连接握手成功, 后续就可以进行TCP通讯了。
在开发方面,WebSocket API 也十分简单:只需要实例化 WebSocket,创建连接,然后服务端和客户端就可以相互发送和响应消息。在WebSocket 实现及案例分析部分可以看到详细的 WebSocket API 及代码实现。
腾讯云公网有日租类型七层负载均衡转发部分支持Websocket,目前包括英魂之刃、银汉游戏等多家企业已接入使用。当出现不兼容问题时,请修改websocket配置,websocket server不校验下图中圈出的字段:
比如一个使用WebSocket应用于视频的业务思路如下:
1)使用心跳维护websocket链路,探测客户端端的网红/主播是否在线
2)设置负载均衡7层的proxy_read_timeout默认为60s
3)设置心跳为50s,即可长期保持Websocket不断开
Nginx代理webSocket经常中断的解决方法(也就是如何保持长连接)
现象描述:用nginx反代代理某个业务,发现平均1分钟左右,就会出现webSocket连接中断,然后查看了一下,是nginx出现的问题。
产生原因:nginx等待第一次通讯和第二次通讯的时间差,超过了它设定的最大等待时间,简单来说就是超时!
解决方法1
其实只要配置nginx.conf的对应localhost里面的这几个参数就好
proxy_connect_timeout;
proxy_read_timeout;
proxy_send_timeout;
解决方法2
发心跳包,原理就是在有效地再读时间内进行通讯,重新刷新再读时间
配置示例:
http {
server {
location / {
root html;
index index.html index.htm;
proxy_pass http://webscoket;
proxy_http_version 1.1;
proxy_connect_timeout 4s; #配置点1
proxy_read_timeout 60s; #配置点2,如果没效,可以考虑这个时间配置长一点
proxy_send_timeout 12s; #配置点3
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
}
}
}
关于上面配置2的解释
这个是服务器对你等待最大的时间,也就是说当你webSocket使用nginx转发的时候,用上面的配置2来说,如果60秒内没有通讯,依然是会断开的,所以,你可以按照你的需求来设定。比如说,我设置了10分钟,那么如果我10分钟内有通讯,或者10分钟内有做心跳的话,是可以保持连接不中断的,详细看个人需求
WebSocket与Socket的关系
- Socket其实并不是一个协议,而是为了方便使用TCP或UDP而抽象出来的一层,是位于应用层和传输控制层之间的一组接口。当两台主机通信时,必须通过Socket连接,Socket则利用TCP/IP协议建立TCP连接。TCP连接则更依靠于底层的IP协议,IP协议的连接则依赖于链路层等更低层次。
- WebSocket就像HTTP一样,则是一个典型的应用层协议。
总的来说:Socket是传输控制层接口,WebSocket是应用层协议。
tomcat支持的websocket服务
在tomcat7之后的版本,写个websocket服务程序非常容易——
如以下代码所示,当客户端建立了一个连接并发送了一些什么内容到服务器,服务器将每隔两秒返回一个字符串“world”。
之所以演示每两秒返回一次是为了说明这是长连接而不是短连接。
import java.io.IOException;
import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;@ServerEndpoint("/test")
public class MyTest {@OnMessage
public void onMessage(String message, Session session)
throws IOException, InterruptedException {
System.out.println("客户端说:" + message);while(true){
session.getBasicRemote().sendText("world");
Thread.sleep(2000);
}
}}
网页只需要这样写:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Hello WebSocket</title>
</head>
<body>
<div id="content"></div>
<button onclick="sayHello()">打招呼</button><script type="text/javascript">
var webSocket =
new WebSocket('ws://localhost:8080/dyna/test');webSocket.onerror = function(event) {
onError(event)
};webSocket.onopen = function(event) {
onOpen(event)
};webSocket.onmessage = function(event) {
onMessage(event)
};function onMessage(event) {
document.getElementById('content').innerHTML += '<br />服务器说:' + event.data;
}function onOpen(event) {
document.getElementById('content').innerHTML = '连接成功';
}function onError(event) {
document.getElementById('content').innerHTML = '出现错误';
}function sayHello() {
webSocket.send('hello');
return false;
}
</script>
</body>
</html>
调试的时候发现tomcat7的支持不是特别好,
在eclipse里添加server然后在上面跑项目,不支持websocket;
用在server.xml里添项目的方式,也不支持websocket。
所以换成tomcat8,在eclipse里添加server然后跑项目,websocket也好使。
这样调试就很方便了。
TODO:
1.maven的tomcat7:run个别项目出现奇怪的问题;maven集成tomcat8的实验有时间做做
2.spring4对websocket的支持怎么试都不成功,有时间攻克它。
3.把今天学的即使通讯技术与websocket结合,做网页版qq之类的demo。
来源:https://www.cnblogs.com/zidafone/p/4743603.html
tomcat8 的 websocket 支持
使用 tomcat8 开发 WebSocket 服务端非常简单,大致有如下两种方式。
1、使用注解方式开发,被 @ServerEndpoint 修饰的 Java 类即可作为 WebSocket 服务端
2、继承 Endpoint 基类实现 WebSocket 服务端
开发被 @ServerEndpoint 修饰的类之后,该类中还可以定义如下方法。
被 @OnOpen 修饰的方法:当客户端与该 WebSocket 服务端建立连接时激发该方法
被 @OnClose 修饰的方法:当客户端与该 WebSocket 服务端断开连接时激发该方法
被 @OnMessage 修饰的方法:当 WebSocket 服务端收到客户端消息时激发该方法
被 @OnError 修饰的方法:当客户端与该 WebSocket 服务端连接出现错误时激发该方法。
下面将基于 WebSocket 开发一个多人实时聊天的程序,该程序思路很简单 -- 在这个程序中,每个客户所用的浏览器都与服务器建立一个 WebSocket,从而保持实时连接,这样客户端的浏览器可以随时把数据发送到服务器端;当服务器收到任何一个浏览器发送来的消息之后,将该消息依次向每个客户端浏览器发送一遍。
按如下步骤开发 WebSocket 服务端程序即可
1、定义 @OnOpen 修饰的方法,每当客户端连接进来时激发该方法,程序使用集合保存所有连接进来的客户端
2、定义 @OnMessage 修饰的方法,每当该服务端收到客户端消息时激发该方法,服务端收到消息之后遍历保存客户端的集合,并将消息逐个发给所有客户端
3、定义 @OnClose 修饰的方法,每当客户端断开与该服务端连接时激发该方法,程序将该客户端从集合中删除。
ChatEndpoint.java
package com.baiguiren;
import java.io.IOException;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.atomic.AtomicInteger;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.OnError;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
@ServerEndpoint(value="/websocket/chat")
public class ChatEndpoint
{
private static final String GUEST_PREFIX = "访客";
private static final AtomicInteger connectionIds = new AtomicInteger(0);
// 定义一个集合,用于保存所有接入的 WebSocket 客户端
private static final Set<ChatEndpoint> clientSet = new CopyOnWriteArraySet<>();
// 定义一个成员变量,记录 WebSocket 客户端的聊天昵称
private final String nickname;
// 定义一个成员变量,记录与 WebSocket 之间的会话
private Session session;
public ChatEndpoint()
{
nickname = GUEST_PREFIX + connectionIds.getAndIncrement();
}
// 当客户端连接进来时自动激发该方法
@OnOpen
public void start(Session session)
{
this.session = session;
// 将 WebSocket 客户端会话添加到集合中
clientSet.add(this);
String message = String.format("[%s %s]", nickname, "加入了聊天室");
// 发送消息
broadcast(message);
}
// 当客户端断开连接时自动激发该方法
@OnClose
public void end()
{
clientSet.remove(this);
String message = String.format("[%s %s]", nickname, "离开了聊天室!");
// 发送消息
broadcast(message);
}
// 每当收到客户端消息时自动激发该方法
@OnMessage
public void incoming(String message)
{
String filteredMessage = String.format("%s: %s", nickname, filter(message));
// 发送消息
broadcast(filteredMessage);
}
// 当客户端通信出现错误时激发该方法
@OnError
public void onError(Throwable t) throws Throwable
{
System.out.println("WebSocket 服务端错误" + t);
}
// 实现广播消息的工具方法
private static void broadcast(String msg)
{
// 遍历服务器关联的所有客户端
for (ChatEndpoint client : clientSet)
{
try {
synchronized (client)
{
// 发送消息
client.session.getBasicRemote().sendText(msg);
}
} catch (IOException e) {
System.out.println("聊天错误,向客户端" + client + "发送消息出现错误。");
clientSet.remove(client);
try {
client.session.close();
} catch (IOException el) {}
String message = String.format("[%s %s]", client.nickname, "已经被断开了连接");
broadcast(message);
}
}
}
// 定义一个工具方法,用于对字符串中的 HTML 字符标签进行转义
private static String filter(String message)
{
if (message == null)
return null;
char content[] = new char[message.length()];
message.getChars(0, message.length(), content, 0);
StringBuilder result = new StringBuilder(content.length + 50);
for (int i = 0; i < content.length; i++)
{
// 控制对尖括号等特殊字符转义
switch (content[i]) {
case '<':
result.append("<");
break;
case '>':
result.append(">");
break;
case '&':
result.append("&");
break;
case '"':
result.append(""");
break;
default:
result.append(content[i]);
}
}
return (result.toString());
}
}
以上文件需要导入 javaee-api-7.0.jar
需要说明的是,该 CharEndpoint 类并不是真正的 WebSocket 服务端,它只实现了 WebSocket 服务端的核心功能,Tomcat 会调用它的方法作为 WebSocket 服务端。因此,Tomcat 会为每个 WebSocket 客户端创建一个 ChatEndpoint 对象,也就是说,有一个 WebSocket 服务端,程序就有一个 ChatEndpoint 对象。所以上面程序中的 clientSet 集合保存了多个 ChatEndpoint 对象,其中每个 ChatEndpoint 对象对应一个 WebSocket 客户端。
chat.html
<html>
<head>
<title>使用 WebSocket 通信</title>
</head>
<body>
<div style="width: 600px; height:240px;overflow-y: auto;border: 1px solid #333;" id="show">
</div>
<input type="text" size="80" id="msg" name="msg" placeholder="请输入聊天内容"/ >
<input type="button" value="发送" id="sendBtn" name="sendBtn" />
<script>
window.onload = function() {
// 创建 WebSocket 对象
var webSocket = new WebSocket("ws://127.0.0.1:8080/jsp/websocket/chat");
var sendMsg = function() {
var inputElement = document.getElementById('msg');
// 发送消息
webSocket.send(inputElement.value);
// 清空单行文本框
inputElement.value = "";
};
var send = function(event) {
if (event.keyCode == 13) {
sendMsg();
}
};
webSocket.onopen = function() {
// 为 onmessage 事件绑定监听器,接收消息
webSocket.onmessage = function(event) {
var show = document.getElementById('show');
// 接收并显示消息
show.innerHTML += event.data + "<br/>";
show.scrollTop = show.scrollHeight;
};
document.getElementById('msg').onkeydown = send;
document.getElementById('sendBtn').onclick = sendMsg;
};
webSocket.onclose = function() {
// document.getElementById('msg').onkeydown = null;
// document.getElementById('sendBtn').onclick = null;
console.log('WebSocket已经被关闭');
};
}
</script>
</body>
</html>
来源:https://www.cnblogs.com/eleven24/p/8680714.html
-----
tomcat websocket的实现
1.客户端发送一个握手包告诉服务端它想升级成WebSocket,不知道服务端是否同意。这时服务端支持WebSocket协议,则会返回一个握手包告诉客户端没问题,升级已确认,然后,就成功建立了一条WebSocket连接,该连接支持双向通信,并且使用WebSocket协议的数据帧格式发送消息。
握手过程需要说明,为了让WebSocket协议能和现有HTTP协议Web架构互相兼容,WebSocket协议的握手要基于HTTP协议.
WebSocket特点如下:
- 单一TCP长连接,采用全双工通信模式
- 对代理、防火墙透明
- 无头部信息、消息更明确
- 通过ping/pong来保活
- 服务器可以主动推送消息给客户端,不在需要客户轮询
通过javaScript 中的API可以直接操作WebSocket对象,其示例如下:
var ws = new WebSocket(“ws://localhost:8080”);
ws.onopen = function()// 建⽴成功之后触发的事件
{
console.log(“打开连接”);
ws.send("ddd"); // 发送消息
};
ws.onmessage = function(evt) { // 接收服务器消息
console.log(evt.data);
};
ws.onclose = function(evt) {
console.log(“WebSocketClosed!”); // 关闭连接
};
ws.onerror = function(evt) {
console.log(“WebSocketError!”); // 连接异常
};
websocket请求头:
其中包含Upgrade:websocket就告诉服务器端客户端想升级协议。
服务端响应、并建立连接
此时如果服务端支持websocket协议,则它会发送一个同意客户端升级协议的报文。其中"Upgrade:websocket" 就告诉 客户端服务器同意客户端的升级协议。
连接状态查看:
通过ws.readyState可查看当前连接状态可选值如下:
1.CONNECT(0):表示还没建立连接
2.OPEN(1):已经建立连接,可以进行通讯
3.CLISING(2):通过关闭握手,正在关闭连接
4.CLOSED(3):连接已经关闭或无法打开
客户端JS 的实现:
if (!window.WebSocket && window.MozWebSocket)
window.WebSocket=window.MozWebSocket;
if (!window.WebSocket)
alert("No Support ");
var ws;
$(document).ready(function(){
$("#sendbutton").attr("disabled", false);
$("#sendbutton").click(sendMessage);
startWebSocket();
})
/**
* 发送消息按钮
* @returns
*/
function sendMessage()
{
var msg="wyy:"+$("#message").val();
send(msg);
}
function send(data)
{
console.log("Send:"+data);
ws.send(data);
}
function startWebSocket()
{
ws = new WebSocket("ws://" + location.host + "/WebSocket/websocket/1");
ws.onopen = function(){
console.log("success open");
$("#sendbutton").attr("disabled", false);
};
//接收后端的消息并处理
ws.onmessage = function(event)
{
alert("RECEIVE:"+event.data);
handleData(event.data);
};
ws.onclose = function(event) {
console.log('Client notified socket has closed',event);
};
}
function handleData(data)
{
$("#msg").html(data);
}
客户端JS 的实现:
if (!window.WebSocket && window.MozWebSocket)
window.WebSocket=window.MozWebSocket;
if (!window.WebSocket)
alert("No Support ");
var ws;
$(document).ready(function(){
$("#sendbutton").attr("disabled", false);
$("#sendbutton").click(sendMessage);
startWebSocket();
})
/**
* 发送消息按钮
* @returns
*/
function sendMessage()
{
var msg="wyy:"+$("#message").val();
send(msg);
}
function send(data)
{
console.log("Send:"+data);
ws.send(data);
}
function startWebSocket()
{
ws = new WebSocket("ws://" + location.host + "/WebSocket/websocket/1");
ws.onopen = function(){
console.log("success open");
$("#sendbutton").attr("disabled", false);
};
//接收后端的消息并处理
ws.onmessage = function(event)
{
alert("RECEIVE:"+event.data);
handleData(event.data);
};
ws.onclose = function(event) {
console.log('Client notified socket has closed',event);
};
}
function handleData(data)
{
$("#msg").html(data);
}
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ConcurrentHashMap;
import javax.websocket.EndpointConfig;
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;
/**
* @ServerEndpoint 注解是一个类层次的注解,它的功能主要是将目前的类定义成一个websocket服务器端,
* 注解的值将被用于监听用户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端
* @ServerEndpoint 可以把当前类变成websocket服务类
*/
@ServerEndpoint("/websocket/{userno}")
public class WebSocketTest {
// 静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
private static int onlineCount = 0;
// concurrent包的线程安全Set,用来存放每个客户端对应的MyWebSocket对象。若要实现服务端与单一客户端通信的话,可以使用Map来存放,其中Key可以为用户标识
private static ConcurrentHashMap<String, WebSocketTest> webSocketSet = new ConcurrentHashMap<String, WebSocketTest>();
// 与某个客户端的连接会话,需要通过它来给客户端发送数据
private Session session;
// 当前发消息的人员编号
private String userno = "";
/**
* 连接建立成功调用的方法
*
* @param session
* 可选的参数。session为与某个客户端的连接会话,需要通过它来给客户端发送数据
*/
@OnOpen
public void onOpen(@PathParam(value = "userno") String param, Session session, EndpointConfig config) {
System.err.println(this);
userno = param;// 接收到发送消息的人员编号
this.session = session;
webSocketSet.put(param, this);// 加入map中
addOnlineCount(); // 在线数加1
System.out.println("有新连接加入!当前在线人数为" + getOnlineCount());
}
/**
* 连接关闭调用的方法
*/
@OnClose
public void onClose() {
if (!userno.equals("")) {
webSocketSet.remove(userno); // 从set中删除
subOnlineCount(); // 在线数减1
System.out.println("有一连接关闭!当前在线人数为" + getOnlineCount());
}
}
/**
* 收到客户端消息后调用的方法
*
* @param message
* 客户端发送过来的消息
* @param session
* 可选的参数
*/
@OnMessage
public void onMessage(String message, Session session) {
System.out.println("来自客户端的消息:" + message);
// session.get
// 群发消息
sendAll(message);
}
/**
* 给指定的人发送消息 可以在项目中直接调用这个方法时
*
* @param message
*/
private void sendToUser(String message) {
// 给指定的人推送消息,推送消息之前,肯定知道userno
String now = getNowTime();
try {
if (webSocketSet.get(1) != null) {
webSocketSet.get(1).sendMessage(now + "用户" + userno + "发来消息:" + " <br/> " + message);
} else {
System.out.println("当前用户不在线");
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 给所有人发消息
*
* @param message
*/
private void sendAll(String message) {
String now = getNowTime();
String sendMessage = message.split("[|]")[0];
// 遍历HashMap
for (String key : webSocketSet.keySet()) {
try {
// 判断接收用户是否是当前发消息的用户
if (!userno.equals(key)) {
webSocketSet.get(key).sendMessage(now + "用户" + userno + "发来消息:" + " <br/> " + sendMessage);
System.out.println("key = " + key);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 获取当前时间
*
* @return
*/
private String getNowTime() {
Date date = new Date();
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time = format.format(date);
return time;
}
/**
* 发生错误时调用
*
* @param session
* @param error
*/
@OnError
public void onError(Session session, Throwable error) {
System.out.println("发生错误");
error.printStackTrace();
}
/**
* 这个方法与上面几个方法不一样。没有用注解,是根据自己需要添加的方法。
*
* @param message
* @throws IOException
*/
public void sendMessage(String message) throws IOException {
this.session.getBasicRemote().sendText(message);
// this.session.getAsyncRemote().sendText(message);
}
public static synchronized int getOnlineCount() {
return onlineCount;
}
public static synchronized void addOnlineCount() {
WebSocketTest.onlineCount++;
}
public static synchronized void subOnlineCount() {
WebSocketTest.onlineCount--;
}
}
tomcat集成websocket