Nginx支持WebSocket反向代理-学习小结

  categories:资料  author:

是目前比较成熟的技术了,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是应用层协议。

***************当你发现自己的才华撑不起野心时,就请安静下来学
来源:https://www.cnblogs.com/kevingrace/p/9512287.html
另外一个tomcat 的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 支持

使用 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特点如下:

  1. 单一TCP长连接,采用全双工通信模式
  2. 对代理、防火墙透明
  3. 无头部信息、消息更明确
  4. 通过ping/pong来保活
  5. 服务器可以主动推送消息给客户端,不在需要客户轮询

通过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

 

 




快乐成长 每天进步一点点      京ICP备18032580号-1