WebSocket实现方式二

Spring方式实现WebSocket

上一次我们实现WebSocket是基于Tomcat的方式，见上一篇博文《WebSocket实现方式一》

这一次我们采用Spring的方式实现

用到的jar包如下：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-websocket</artifactId>
    <version>4.2.3.RELEASE</version>
</dependency>

后台代码：

WebSocketConfig.java类

/**
 * 
 */
package nbs.omp.websocket;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
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;

import nbs.omp.interceptor.HandShakeInterceptor;

/**
 * @author David
 *
 */
@Configuration
@Component
@EnableWebSocket
public class WebSocketConfig extends WebMvcConfigurerAdapter implements WebSocketConfigurer {
	@Autowired
	MyWebSocketHandler handler;
	@Override
	public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
		registry.addHandler(handler, "/ws").addInterceptors(new HandShakeInterceptor());
	}

}

@Configuration  //指明该类为Spring 配置类

@Component //泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。 
@EnableWebSocket  //声明该类支持WebSocket
不要忘记在springmvc的配置文件中配置对此类的自动扫描

<!-- 自动扫描websocket包下的所有类 -->
<context:component-scan base-package="nbs.omp.websocket" /> 

拦截器 HandShakeInterceptor.java类

/**
 * 
 */
package nbs.omp.interceptor;

import java.util.Map;

import javax.servlet.http.HttpSession;

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

import nbs.omp.model.User;

/**
 * @author David
 *
 */
public class HandShakeInterceptor implements HandshakeInterceptor {

	@Override
	public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
		Map<String, Object> attributes) throws Exception {
		System.out.println("Websocket:用户[ID:"+ ((ServletServerHttpRequest) request).getServletRequest()
		.getSession(false).getAttribute("user") + "]已经建立连接");
		if (request instanceof ServletServerHttpRequest) {
			ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
			HttpSession session = servletRequest.getServletRequest().getSession(false);
			// 标记用户
			User user = (User) session.getAttribute("user");
			if (user != null) {
				attributes.put("userId", user.getUserId());
			} else {
				return false;
			}
		}
		return true;
	}

	@Override
	public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
			Exception exception) {
		// TODO Auto-generated method stub

	}

}

MyWebSocketHandler.java类

/**
 * 
 */
package nbs.omp.websocket;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.CopyOnWriteArrayList;

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;


/**
 * @author David
 *
 */
@Component
public class MyWebSocketHandler implements WebSocketHandler {
	
	
	public static final List<Map<Integer, WebSocketSession>> userSocketSessionList;
	static {
		userSocketSessionList = new CopyOnWriteArrayList<Map<Integer, WebSocketSession>>();
	}

	public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        String userName = (String) session.getAttributes().get("");
        //业务代码...
    	//发送消息
        session.sendMessage(new TextMessage());
    }

	@Override
	public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
		//业务代码...
		//发送消息
		sendMessageToUsers(new TextMessage());
	}

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

	@Override
	public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
		System.out.println("Websocket:" + session.getId() + "已经关闭");
		for(Map userSocketSessionMap : userSocketSessionList){
			Iterator<Entry<Integer, WebSocketSession>> it = userSocketSessionMap.entrySet().iterator();
			// 移除Socket会话
			while (it.hasNext()) {
				Entry<Integer, WebSocketSession> entry = it.next();
				if (entry.getValue().getId().equals(session.getId())) {
					userSocketSessionList.remove(userSocketSessionMap);
					System.out.println("Socket会话已经移除:用户ID" + entry.getKey());
					break;
				}
			}
		}
	}

	@Override
	public boolean supportsPartialMessages() {
		// TODO Auto-generated method stub
		return false;
	}
	/**
	 * 给某个指定用户发送消息
	 * 
	 * @param userName
	 * @param message
	 * @throws IOException
	 */
	public void sendMessageToUser(Integer userId, TextMessage message)throws IOException {
		for(Map userSocketSessionMap : userSocketSessionList){
			WebSocketSession session = (WebSocketSession) userSocketSessionMap.get(userId);
			if (session != null && session.isOpen()) {
				session.sendMessage(message);
			}
		}
	}
	
	/**
     * 给所有在线用户发送消息
     *
     * @param message
     */
    public void sendMessageToUsers(TextMessage message) {
        for (WebSocketSession user : users) {
            try {
                if (user.isOpen()) {
                    user.sendMessage(message);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }    

}

前端JS：

<script type="text/javascript">
				
		var websocket;
		if ('WebSocket' in window) {
			websocket = new WebSocket("ws://" + path + "/ws");
		} else if ('MozWebSocket' in window) {
			websocket = new MozWebSocket("ws://" + path + "/ws");
		} else {
			websocket = new SockJS("http://" + path + "/ws/sockjs");
		}
		websocket.onopen = function(event) {
			console.log("WebSocket:已连接");
			console.log(event);
		};
		websocket.onmessage = function(event) {
			var data=JSON.parse(event.data);
			console.log("WebSocket:收到一条消息",data);
			var textCss=data.from==-1?"sfmsg_text":"fmsg_text";
			$("#content").append("<div class='fmsg'><label class='name'>"+data.fromName+"&nbsp;"+data.date+"</label><div class='"+textCss+"'>"+data.text+"</div></div>");
			scrollToBottom();
		};
		websocket.onerror = function(event) {
			console.log("WebSocket:发生错误 ");
			console.log(event);
		};
		websocket.onclose = function(event) {
			console.log("WebSocket:已关闭");
			console.log(event);
		}
		function sendMsg(){
			var data={};
			websocket.send(JSON.stringify(data));				
			}
		}
						
		function send(event){
			var code;
			if(window.event){
			     code = window.event.keyCode; // IE
				 }else{
					 code = e.which; // Firefox
				 }
				if(code==13){ 
					sendMsg();            
				}
			}
			
			function clearAll(){
				$("#content").empty();
			}
		</script>

HTML页面：

<html>
<body>
	<h1>Spring整合WebSocket实现</h1>
	<div id="content"></div>
	<input type="text" placeholder="请输入要发送的信息" id="msg" class="msg" onkeydown="send(event)">
	<input type="button" value="发送" class="send" onclick="sendMsg()" >
	<input type="button" value="清空" class="clear" onclick="clearAll()">
    <div id="message"></div>
 
</body>
</html>

至此代码完毕，下面我们来分析一下代码执行的步骤

1，当spring容器启动时会自动加载WebSocketConfig类，因为该类实现了WebSocketConfigurer接口，所以会调用registerWebSocketHandlers(...)方法。

2，当用户登录后页面会调用JS执行websocket = new WebSocket("ws://" + path + "/ws");这行代码，这时后台拦截器会对“ws://" + path + "/ws”进行拦截，就进入了beforeHandshake(...)方法，握手成成功后进入afterHandshake(...)方法。

3，当拦截器顺利通过后，程序就进入了MyWebSocketHandler类的supportsPartialMessages(...)方法，然后就是重要的afterConnectionEstablished(...)方法。链接成功会调用前端JS的websocket.onopen方法。

4，在afterConnectionEstablished(...)方法中就可以写业务逻辑并利用sendMessageToUser(...)发送消息了。

5，sendMessageToUser(...)方法的实质是利用webSocketSession.sendMessage(...)方法发送消息。

6，消息发送成功，这是会调用前端JS的websocket.onmessage方法。

7，当用户通过页面发送消息，即调用JS代码websocket.send(JSON.stringify(data))，这时就进入了MyWebSocketHandler类的handleMessage(...)方法处理信息。

8，当有来自底层WebSocket消息传输错误时会调用后台MyWebSocketHandler类的handleTransportError(...)方法进行WebSocketSession的close()等处理。

9，当用户关闭WebSocket时会调用后台MyWebSocketHandler类的afterConnectionClosed(...)方法移除会话。

 

 

 

 

 

转载于:https://my.oschina.net/u/3388158/blog/916043