websocket学习

前台：
1、js包

<script src=".../sockjs.min.js"></script>  ``
<script src=".../stomp.js"></script>

2、构造实例
var stompClient = Stomp.over(new SockJS(‘<%=request.getContextPath()%>/ws/sockjs?userid=userid’));
方法
(1).stompClient.ws.readyState属性返回实例对象的当前状态，共有四种。
0，表示正在连接。
1，表示连接成功，可以通信了。
2，表示连接正在关闭。
3，表示连接已经关闭，或者打开连接失败。
(2)stompClient.ws.onopen
实例对象的onopen属性，用于指定连接成功后的回调函数。
(3)stompClient.ws.onclose
实例对象的onclose属性，用于指定连接关闭后的回调函数。
(4)stompClient.ws.onmessage
实例对象的onmessage属性，用于指定收到服务器数据后的回调函数。

stompClient.ws.onmessage=function(event){
        var data=JSON.parse(event.data);//返回的数据
};

后台：
1、配置连接

package com.neal.config.spring;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
@Component
@EnableWebMvc
@EnableWebSocket
public class MyWebSocketConfig extends WebMvcConfigurerAdapter implements WebSocketConfigurer{
    @Resource
    private MyWebSocketHandler handler;//消息处理器
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry){//
        registry.addHandler(handler, "/ws").addInterceptors(new HandShake());//设置支持window自带的websocket
        registry.addHandler(handler, "/ws/sockjs").addInterceptors(new HandShake()).withSockJS();//设置支持sockjs

    }

}

2、Interceptor拦截

package com.neal.config.spring;

import java.util.Map;

import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

public class HandShake implements HandshakeInterceptor{
    @Override
    public boolean beforeHandshake(ServerHttpRequest request,ServerHttpResponse response,WebSocketHandler wsHandler,
            Map<String, Object> attributes) throws Exception{
        System.out.println("websocket开始握手");
        String userid=((ServletServerHttpRequest) request).getServletRequest().getParameter("userid");
        if(userid!=null){
            attributes.put("userid", userid); 
        }else {
            return false;
        }
        return true;
    }

    @Override
    public void afterHandshake(ServerHttpRequest arg0,ServerHttpResponse arg1,WebSocketHandler arg2,Exception arg3){
        System.out.println("websocket握手结束");
    }
}

3、MyWebSocketHandler具体实现细节

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.log4j.Logger;
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.WebSocketHandler;
import org.springframework.web.socket.WebSocketMessage;
import org.springframework.web.socket.WebSocketSession;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;


//import com.google.gson.GsonBuilder;
@Component
public class MyWebSocketHandler implements WebSocketHandler{
       private Logger log=Logger.getLogger(this.getClass());
       @Autowired
       private T_fault_logService t_fault_logService;
       private Gson gson=new Gson();
        //用于存储websocket会话
       public static final Map<String, WebSocketSession> sessionMap;  

        static {  
            sessionMap = new HashMap<String, WebSocketSession>();  
        } 
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus)throws Exception {
        // TODO Auto-generated method stub
          System.out.println("Websocket:" + session.getId() + "已经关闭");  
            Iterator<Entry<String, WebSocketSession>> it = sessionMap  
                    .entrySet().iterator();  
            // 移除Socket会话  
            while (it.hasNext()) {  
                Entry<String, WebSocketSession> entry = it.next();  
                if (entry.getValue().getId().equals(session.getId())) {  
                    sessionMap.remove(entry.getKey());  
                    System.out.println("Socket会话已经移除:用户ID" + entry.getKey());  
                    break;  
                }  
            }  

    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session)throws Exception {
        System.out.println("websocket握手成功");
        //sessionMap.put(session.getId(),session);//将session会话存储起来，不存到内存，则在消息推送和广播方法无法操作会话
        String userid = (String) session.getAttributes().get("userid");  
        if (userid!= null) {
            sessionMap.put(IdCreater.getUUID(), session);  
        }  

    }

    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message)throws Exception {
        // TODO Auto-generated method stub
        session.sendMessage(message);
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception)
            throws Exception {
        // TODO Auto-generated method stub
        if (session.isOpen()) {  
            session.close();  
        }  
        Iterator<Entry<String, WebSocketSession>> it = sessionMap  
                .entrySet().iterator();  
        // 移除Socket会话  
        while (it.hasNext()) {  
            Entry<String, WebSocketSession> entry = it.next();  
            if (entry.getValue().getId().equals(session.getId())) {  
                sessionMap.remove(entry.getKey());  
                System.out.println("Socket会话已经移除:用户ID" + entry.getKey());  
                break;  
            }  
        }       
    }

    @Override
    public boolean supportsPartialMessages() {
        // TODO Auto-generated method stub
        return false;
    }

    public void sendFaultNum1() throws IOException {  
        Iterator<Entry<String, WebSocketSession>> it = sessionMap.entrySet().iterator();  

        // 多线程群发  
        while (it.hasNext()) {  
            final Entry<String, WebSocketSession> entry = it.next();  
            if (entry.getValue().isOpen()) {  
                new Thread(new Runnable() {  

                    public void run() {  
                        try {  

                            if (entry.getValue().isOpen()) {  
                                entry.getValue().sendMessage("返回信息");  
                            }  
                        } catch (IOException e) {  
                            e.printStackTrace();  
                        }  
                    }  

                }).start();  
            }  

        }  
    }
     // 依次发送，也可以单个启用线程多线发送，但是为了省资源，依次发送
    public void sendFaultNum2(){
        try {
            Iterator<Entry<String, WebSocketSession>> it = sessionMap.entrySet().iterator(); 

            while (it.hasNext()) {  


                if (entry.getValue().isOpen()) {  
                    try {
                        entry.getValue().sendMessage(new TextMessage("返回信息"));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }  
                }  

            } 
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
}

4、服务器开线程监听

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
import com.neal.config.spring.MyWebSocketHandler;

@Component
public class PushTask implements ApplicationListener<ContextRefreshedEvent>{
    private Logger log=Logger.getLogger(PushTask.class);
    @Autowired
    private MyWebSocketHandler myWebSocketHandler;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if(event.getApplicationContext().getParent()!=null){
            Thread t=new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        try{
                            //myWebSocketHandler.sendFaultNum1();
                            myWebSocketHandler.sendFaultNum2();
                            Thread.sleep(1000);
                        }catch (InterruptedException e) {
                            e.printStackTrace();
                            log.error(e.getMessage(), e);
                        }
                    }
                }
            });
            t.start();

        }

    }
}