【转】java中使用WebSocket

传统的请求，都是从客服端到服务端，表现在web应用上就是，消息都只能由浏览器发起请求，调用客户端的方法。

webSocket可以从服务器端推送消息给浏览器。

使用场景：

　　当客户端发起缴费请求时，由服务端发起请求给第三方，跳转到第三方完成支付后，第三方支付回调服务器的接口。在服务端的接口中，推送缴费状态消息给客户端。

页面前台：

var websocket = null;
var host = document.location.host; 
var username = "${loginUsername}"; // 获得当前登录人员的userName 
 // alert(username)
//判断当前浏览器是否支持WebSocket 
if ('WebSocket' in window) { 
    alert("浏览器支持Websocket")
    websocket = new WebSocket('ws://'+host+'/mm-dorado/webSocket/'+username); 
} else { 
    alert('当前浏览器 Not support websocket') 
} 
 
//连接发生错误的回调方法 
websocket.onerror = function() { 
　　alert("WebSocket连接发生错误")
   setMessageInnerHTML("WebSocket连接发生错误"); 
};  
   
//连接成功建立的回调方法 
websocket.onopen = function() {
　　alert("WebSocket连接成功") 
   setMessageInnerHTML("WebSocket连接成功"); 
} 
   
//接收到消息的回调方法 
websocket.onmessage = function(event) {
    alert("接收到消息的回调方法") 
    alert("这是后台推送的消息："+event.data);
　　　　 websocket.close();
　　　　alert("webSocket已关闭！")
} 
   
//连接关闭的回调方法 
websocket.onclose = function() { 
    setMessageInnerHTML("WebSocket连接关闭"); 
} 
   
//监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。 
window.onbeforeunload = function() { 
    closeWebSocket(); 
} 
   
//关闭WebSocket连接 
function closeWebSocket() { 
    websocket.close(); 
} 
 
//将消息显示在网页上
    function setMessageInnerHTML(innerHTML) {
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }

后端：

先引包

<dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
      <scope>provided</scope>
</dependency>

代码：

package com.mes.util;
 
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
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;
import org.springframework.stereotype.Service;
 
import com.google.gson.JsonObject;
 
import net.sf.json.JSONObject;
@ServerEndpoint("/webSocket/{username}")  
    public class WebSocket { 
        private static int onlineCount = 0; 
        private static Map<String, WebSocket> clients = new ConcurrentHashMap<String, WebSocket>(); //这里感觉是取巧的方法，用静态的对象来保存连接，然后在下面发送给单个客户端的时候，用传进来的username和To的目标进行字符串的比较
        private Session session; 
        private String username; 
           
        @OnOpen 
        public void onOpen(@PathParam("username") String username, Session session) throws IOException { 
       
            this.username = username; 
            this.session = session; 
               
            addOnlineCount(); 
            clients.put(username, this);
            System.out.println("已连接");
        } 
       
        @OnClose 
        public void onClose() throws IOException { 
            clients.remove(username); 
            subOnlineCount(); 
        } 
       
        @OnMessage 
        public void onMessage(String message) throws IOException { 
       
            JSONObject jsonTo = JSONObject.fromObject(message); 
            String mes = (String) jsonTo.get("message");
             
            if (!jsonTo.get("To").equals("All")){ 
                sendMessageTo(mes, jsonTo.get("To").toString()); 
            }else{ 
                sendMessageAll("给所有人"); 
            } 
        } 
       
        @OnError 
        public void onError(Session session, Throwable error) { 
            error.printStackTrace(); 
        } 
       
        public void sendMessageTo(String message, String To) throws IOException { 
            // session.getBasicRemote().sendText(message); 
            //session.getAsyncRemote().sendText(message); 
            for (WebSocket item : clients.values()) { 
                if (item.username.equals(To) ) 
                    item.session.getAsyncRemote().sendText(message); 
            } 
        } 
           
        public void sendMessageAll(String message) throws IOException { 
            for (WebSocket item : clients.values()) { 
                item.session.getAsyncRemote().sendText(message); 
            } 
        } 
       
        public static synchronized int getOnlineCount() { 
            return onlineCount; 
        } 
       
        public static synchronized void addOnlineCount() { 
            WebSocket.onlineCount++; 
        } 
       
        public static synchronized void subOnlineCount() { 
            WebSocket.onlineCount--; 
        } 
       
        public static synchronized Map<String, WebSocket> getClients() { 
            return clients; 
        } 
}

其他类中调用：

WebSocket ws = new WebSocket();
JSONObject jo = new JSONObject();
jo.put("message", "这是后台返回的消息！");
jo.put("To",invIO.getIoEmployeeUid());
ws.onMessage(jo.toString());

原地址：https://www.cnblogs.com/freud/p/8397934.html

因为http和websocket的协议是不同的，还有一篇，可以在websocket中获取到HttpSession:

https://www.cnblogs.com/zhuxiaojie/p/6238826.html#autoid-0-0-0