spring-web-socket

首先写一类继承TextWebSocketHandler如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import com.bit.bpj.socket.data.TridePriceForOther;
import com.bit.bpj.socket.starter.PriceTradeInfoStarter;
import com.bit.bpj.socket.util.WebSocketETHUtils;
import com.bit.bpj.socket.util.WebSocketLTCUtils;
import com.bit.bpj.socket.util.WebSocketUtils;
import com.bit.bpj.util.JsonUtil;
import com.bit.coin.service.IJedisClientService;

@Component
public class PriceInfoForOtherHandler extends TextWebSocketHandler {
    private static final Logger log = LoggerFactory.getLogger(PriceInfoForOtherHandler.class);
 
    
  
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
       //管理用户会话
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session,CloseStatus status) throws Exception{
        users.remove(session);
    }
   
    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        //根据建立绘画建立数据交互
    }

    public void sendMessageToUsers(TridePriceForOther priceTride){
       //发送消息
    }
}

//注册发布到WebSocketConfigurer

@Configuration
@EnableWebMvc
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer  {
    
    private static final Logger log = LoggerFactory.getLogger(WebSocketConfig.class);

    
    @Autowired
    private PriceInfoForOtherHandler priceInfoForOtherHandler;

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
       

        //其他平台行情信息
        registry.addHandler(priceInfoForOtherHandler, “请求地址”).addInterceptors(new WebSocketInterceptor()).setAllowedOrigins("*").withSockJS();

        

    }

连接方法：

java客户端连接实现WebSocketClient

/**
 * socket  连接处理  *
 */
public class WebSocketUtils extends WebSocketClient  {
    
    private static final Logger log = LoggerFactory.getLogger(WebSocketUtils.class);

 
    private static final String url = "wss:// ";
 

    private PriceInfoForOtherHandler priceInfoForOtherHandler = new PriceInfoForOtherHandler();

    public static WebSocketUtils webSockelient = null;
    private static Pusher pusher = null; 
 

    private static String rate;

    public WebSocketUtils(URI serverUri, Draft draft) {
        super(serverUri, draft);
    }

    public WebSocketUtils(URI serverURI) {
        super(serverURI);
    }

    public WebSocketUtils(URI serverUri, Map<String, String> headers, int connecttimeout) {
        super(serverUri, new Draft_17(), headers, connecttimeout);
    }

    @Override
    public void onOpen(ServerHandshake handshakedata) {
        log.debug("开流--opened connection");
    }

    @Override
    public void onMessage(ByteBuffer socketBuffer) {
//        try {
//            String marketStr = CommonUtils.byteBufferToString(socketBuffer);
//            String market = CommonUtils.uncompress(marketStr);
//            if (market.contains("ping")) {
//                System.out.println(market.replace("ping", "pong"));
//                // Client 心跳
//                chatclient.send(market.replace("ping", "pong"));
//            } else {
//                System.out.println(" market:" + market);
//
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
    }

    @Override
    public void onMessage(String message) {
        log.debug("接收--received: " + message);
      //收到消息具体处理
            priceInfoForOtherHandler.sendMessageToUsers(tridePrice);
           
    }

  
    
    public void onFragment(Framedata fragment) {
        log.debug("片段--received fragment: " + new String(fragment.getPayloadData().array()));
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        log.debug("关流--Connection closed by " + (remote ? "remote peer" : "us"));
    }

    @Override
    public void onError(Exception ex) {
        log.info("WebSocket 连接异常: 重新连接 " + ex);
 
    
    }

    public static Map<String, String> getWebSocketHeaders() throws IOException {
        Map<String, String> headers = new HashMap<String, String>();
        return headers;
    }

    public static  void executeBitfinexlientSocket()throws Exception {
     
        if(webSockelient==null){
            webSockelient = new WebSocketUtils(new URI(url), getWebSocketHeaders(), 1000);
            trustAllHosts(webSockelient);
            webSockelient.connectBlocking();
            
        }
        // 订阅K线数据 sub 根据自己需要订阅数据
        webSockelient.send(JSONObject.toJSONString(map));

    }
    public static  void execute stampSocket(PriceInfoForOtherHandler priceInfoForOtherHandler)throws Exception{
        if(pusher!=null){
            pusher.disconnect();
        }
        pusher = new Pusher(PLSocketConstants.BITSTAMP_PUSHER_KEY);
        pusher.connect();
        Channel channel = pusher.subscribe("live_trades");
        channel.bind("trade", new SubscriptionEventListener() {
            @Override
            public void onEvent(String channel, String event, String data) {
                
                priceInfoForOtherHandler.sendMessageToUsers(tridePrice);
             
            }
        });

    }
    
    private static void trustAllHosts(WebSocketUtils appClient) {
        TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return new java.security.cert.X509Certificate[] {};
            }

            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }
        } };

        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, trustAllCerts, new java.security.SecureRandom());
            appClient.setWebSocketFactory(new DefaultSSLWebSocketClientFactory(sc));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    public  void close() {
        super.close();
        if(pusher!=null){
            pusher.disconnect();
        }
    
    }
}

JS连接websocket方法：
<script>  
    var path = ' ';  
//     var path = ' ';  
//  var path = '192.168.0.203:8080/';  
    var websocket;  
    if ('WebSocket' in window) {  
        websocket = new WebSocket("ws://" + path + "注册名称/websocket");   
    } 
    else if ('MozWebSocket' in window) {  
        websocket = new MozWebSocket("ws://" + path + "注册名称/websocket");  
    } 
    else { 
        websocket = new SockJS("http://" + path + "注册名称/websocket");  
    }  
    websocket.onopen = function(event) {  
        console.log("WebSocket:已连接");  
         
        websocket.send("");//发送请求数据
    };  
    websocket.onmessage = function(event) {  
        var data = JSON.parse(event.data);  
        console.log("WebSocket:收到一条消息-norm", data);  
 
    };  
    websocket.onerror = function(event) {  
        console.log("WebSocket:发生错误 ");  
        console.log(event);  
    };  
    websocket.onclose = function(event) {  
        console.log("WebSocket:已关闭");  
        console.log(event);  
    }  
</script> 

websocket在线测试地址：http://websocket.org/echo.html