本篇博客只是记录websocket在自己的项目中的应用，只是记录，不做说明（后来替换为GoEasy了）。
/**
* 握手的设置，这其实是为了获取session
*/
public class GetHttpSessionConfigurator extends ServerEndpointConfig.Configurator {
@Override
public void modifyHandshake(ServerEndpointConfig config,
HandshakeRequest request,
HandshakeResponse response) {
HttpSession httpSession = (HttpSession) request.getHttpSession();
config.getUserProperties().put(HttpSession.class.getName(), httpSession);
}
}
/**
* JSR356定义了WebSocket的规范，Tomcat7中实现了该标准。
* JSR356 的 WebSocket 规范使用 javax.websocket.*的 API，
* 可以将一个普通 Java 对象（POJO）使用 @ServerEndpoint 注释作为 WebSocket 服务器的端点。
* value必须以"/"开始，是否已"/"结束无所谓，
* configurator指的是ServerEndpointConfig 的配置信息，可以配置握手协议等信息，而在本例中是为了获取session
*/
@ServerEndpoint(value = "/websocket/task", configurator = GetHttpSessionConfigurator.class)
public class TaskServer { private static Logger logger = LoggerFactory.getLogger(TaskServer.class); //ConcurrentHashMap在线程安全的基础上提供了更好的写并发能力，但同时降低了对读一致性的要求
private static final Map<String, Session> doctorMap = new ConcurrentHashMap<String, Session>(); //使用ServerEndpoint注释的类必须有一个公共的无参数构造函数
public TaskServer() {
} @OnOpen
public void onOpen(Session session, EndpointConfig config) {
HttpSession httpSession = (HttpSession) config.getUserProperties().get(HttpSession.class.getName());
if (httpSession == null) {
return;
}
// DoctorUser doctor = (DoctorUser) httpSession.getAttribute(Constants.SESSION_DOCTOR);
Doctoruser doctor = (Doctoruser) httpSession.getAttribute(Constants.SESSION_DOCTOR_USER); String doctorID = doctor.getId();
logger.info("doctor " + doctor.getName() + " id = " + doctor.getId() + " 建立连接");
doctorMap.put(doctorID, session);
// attributes.put(Constants.WEBSOCKET_DOCTORNAME,userName);
} @OnClose
public void onClose(Session session) {
// doctorMap.remove( doctorID);
boolean has = doctorMap.containsValue(session);
String doctorId = null;
if (has == true) {
for (Map.Entry entry : doctorMap.entrySet()) {
if (entry.getValue().equals(session)) {
doctorId = (String) entry.getKey();
doctorMap.remove(doctorId);
}
}
} else {
logger.info("on close error");
}
logger.info("doctor " + doctorId + " 断开连接");
} @OnMessage
public void incoming(String message, Session session) {
//logger.info("recv message: " + message);
sendMessage("pong",session);
} @OnError
public void onError(Throwable t) throws Throwable {
logger.info("socket 连接错误 " + t.toString());
} //把消息推送给前端，在本例中推送是给doctorID推送message（数据库表中任务表的id）
public static void broadcast(String doctorID, String message) {
Session session = doctorMap.get(doctorID);
if (session == null) {
logger.warn("用户:" + doctorID + "socket连接不存在");
return;
} session.getAsyncRemote().sendText(message); //非阻塞、异步 /*try {
//详见 《 websocket getAsyncRemote()和getBasicRemote()区别》
//http://blog.csdn.net/who_is_xiaoming/article/details/53287691 //session.getBasicRemote().sendText(message); //阻塞、同步
session.getAsyncRemote().sendText(message); //非阻塞、异步
} catch (IOException e) {
logger.error("推送消息错误--" + e);
doctorMap.remove(doctorID);
try {
session.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}*/
} /**
* 发送信息
*
* @param message 发送内容
* @param session 用户session
*/
public void sendMessage(String message, Session session) {
try {
synchronized (session) {
if (session.isOpen()) {
session.getBasicRemote().sendText(message);
}
}
} catch (Exception e) {
logger.error("send message exception", e);
}
} public static boolean hasConnection(String doctorID) {
if (doctorMap.get(doctorID) == null) return false;
return true;
} public static List<String> getDoctorList() {
ArrayList<String> doctors = new ArrayList<>();
for (Map.Entry entry : doctorMap.entrySet()) {
doctors.add((String) entry.getKey());
}
return doctors;
} public static Map<String, Session> getDoctorMap() {
return doctorMap;
}
}
<script type="text/javascript">
/*
1.连接上之后，每秒发送一个心跳，服务器同样返回一个心跳，用来表示服务器没挂。
2.断线重连（我们测试的环境是断开网络连接），断开网络后，心跳包无法发送出去，所以如果当前时间距离上次成功心跳的时间超过20秒，说明连接已经出现问题了，此时需要关闭连接。
3.第一次关闭连接时websocket会尝试重连，设置了一个时间期限，10秒。10秒内如果能连上（恢复网络连接）就可以继续收发消息，连不上就关闭了，并且不会重连。
4.30秒内收不到服务器消息（心跳每秒发送），我就认为服务器已经挂了，就会调用close事件，然后进入第3步。
*/
/*
•一个定时器ws.keepAliveTimer，用来每秒发送一次心跳。
•上次心跳成功的时间ws.last_health_time以及当前时间let time = new Date().getTime();。
•断开连接(ws.close())时的时间reconnect，因为在close事件发生后需要重连10秒。
•是否已经重连过reconnectMark。
•断开连接(ws.close())时需要保存ws对象tempWs。我曾试图ws = { ...ws }发现会丢失绑定的事件。
•一个定时时间为30秒的setTimeout定时器ws.receiveMessageTimer，用来表示服务器是否在30秒内返回了消息。
*/ var ws = null;
var url = 'ws://' + window.location.host + "${rootPath}/websocket/task"; var queue = new Queue(); //js的队列先进先出,把推送任务放到里面 $(function () {
connect(url);
getTask();
}); //==============================================推送================================================
function connect(url) {
// 用户登录了并且没有连接过websocket
if ("${sessionScope.SESSION_DOCTOR_ACCOUNT.id}".length == 32) {
ws = new WebSocket(url);
ws.last_health_time = -1; // 上次心跳成功的时间 //保持连接
ws.keepalive = function () {
var time = new Date().getTime(); //当前时间
/*断线重连（我们测试的环境是断开网络连接），断开网络后，心跳包无法发送出去，
所以如果当前时间距离上次成功心跳的时间超过20秒，说明连接已经出现问题了，此时需要关闭连接。*/
if (ws.last_health_time !== -1 && time - ws.last_health_time > 20000) {
ws.close();
console.log("Info: connection closed.");
} else {
/*连接上之后，每秒发送一个心跳，服务器同样返回一个心跳，用来表示服务器没挂。
ws.bufferedAmount === 0 && ws.readyState === 1 均表示连接是正常的*/
if (ws.bufferedAmount === 0 && ws.readyState === 1) {
ws.send("ping");
ws.last_health_time = time;
}
}
} if (ws) {
var reconnectTime = 0; //断开连接的时间
var reconnectMark = false; //是否重连过
ws.onopen = function () {
reconnectTime = 0;
reconnectMark = false;
// 30s没收到信息，代表服务器出问题了，关闭连接。如果收到消息了，重置该定时器。
ws.receiveMessageTimer = setTimeout(function () {
ws.close();
console.log("Info: connection closed.");
}, 30000);
// 为1表示连接处于open状态，keepAliveTimer用来每秒发送一次心跳；
if (ws.readyState === 1) {
ws.keepAliveTimer = setInterval(function () {
ws.keepalive();
}, 5000);
}
console.log("Info: connection opened. " + url);
} ws.onerror = function () {
console.error("onerror");
}
ws.onmessage = function (event) {
//console.log("Received:" + event.data+" "+new Date().getTime());
//真正的逻辑代码
if(event.data!="pong"){
queue.push(event.data);
playSound();
$("#taskNum").html(queue.size());
var src1 = $("#iframe").attr("src");
if (src1 == "doctor/noTask.do") {
srcValue("doctor/ecgTask.do");
}
} // 收到消息，重置定时器
clearTimeout(ws.receiveMessageTimer);
// 30s没收到信息，代表服务器出问题了，关闭连接。
ws.receiveMessageTimer = setTimeout(function () {
ws.close();
console.log("Info: connection closed.");
}, 30000);
} ws.onclose = function () {
clearTimeout(ws.receiveMessageTimer);
clearInterval(ws.keepAliveTimer);
// 如果没有重连过，进行重连。
if (!reconnectMark) {
reconnectTime = new Date().getTime();
reconnectMark = true;
}
var tempWs = ws; // 保存ws对象 /*第一次关闭连接时websocket会尝试重连，设置了一个时间期限，10秒。
10秒内如果能连上（恢复网络连接）就可以继续收发消息，连不上就关闭了，并且不会重连。*/
if (new Date().getTime() - reconnectTime >= 10000) {
ws.close();
console.log("Info: connection closed.");
} else {
ws = new WebSocket(url);
ws.onopen = tempWs.onopen;
ws.onmessage = tempWs.onmessage;
ws.onerror = tempWs.onerror;
ws.onclose = tempWs.onclose;
ws.keepalive = tempWs.keepalive;
ws.last_health_time = -1;
}
}
} else {
alert("This browser does not support webSocket");
return false;
}
}
} <!--断开连接-->
function disconnect() {
if (ws!= null) {
ws.close();
ws = null;
window.location = document.getElementsByTagName("base")[0].getAttribute("href")+ "doctor/logout.do";
}
} <!--播放音乐-->
function playSound() {
var borswer = window.navigator.userAgent.toLowerCase();
if (borswer.indexOf("ie") >= 0) {
//IE内核浏览器
var strEmbed = '<embed name="embedPlay" src="sounds/doctorTask.wav" autostart="true" hidden="true" loop="false"></embed>';
if ($("body").find("embed").length <= 0)
$("body").append(strEmbed);
var embed = document.embedPlay;
//浏览器不支持 audion，则使用 embed 播放
embed.volume = 100;
//embed.play();这个不需要
} else {
var audio = new Audio("sounds/doctorTask.wav");
//audio.loop="loop";
audio.play();
}
} <!--onbeforeunload 事件在即将离开当前页面（刷新或关闭）时触发。-->
window.onbeforeunload = signout;
function signout() {
disconnect();
} //改变iframe的src值
function srcValue(val) {
$("#iframe").attr("src", val);
} //退出
function logout(){
disconnect();
$("#exitModal").modal("hide");
}
</script>