Spring和websocket整合应用示例（上）

嗯，这次真的仅仅是一个入门教程，因为老夫表示自己也不会。近期老夫参与开发公司的一个CRM系统，系统中有很多消息的推送，由一个同事负责，其用到了websocket技术，老夫比较感兴趣，删繁就简，整理了一个教程，留作自己笔记，因很多原理老夫也是不甚了了，以备将来用到了有资料可查。

maven依赖

<dependency>  
  <groupId>javax.servlet</groupId>  
  <artifactId>javax.servlet-api</artifactId>  
  <version>3.1.0</version>  
</dependency>  
<dependency>  
  <groupId>com.fasterxml.jackson.core</groupId>  
  <artifactId>jackson-core</artifactId>  
  <version>2.3.0</version>  
</dependency>  
<dependency>  
  <groupId>com.fasterxml.jackson.core</groupId>  
  <artifactId>jackson-databind</artifactId>  
  <version>2.3.0</version>  
</dependency>  
<dependency>  
  <groupId>org.springframework</groupId>  
  <artifactId>spring-websocket</artifactId>  
  <version>4.0.1.RELEASE</version>  
</dependency>  
<dependency>  
  <groupId>org.springframework</groupId>  
  <artifactId>spring-messaging</artifactId>  
  <version>4.0.1.RELEASE</version>  
</dependency>

spring-servlet的配置

<?xml version="1.0" encoding="UTF-8"?>  
  <beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:mvc="http://www.springframework.org/schema/mvc"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns:websocket="http://www.springframework.org/schema/websocket"  
    xsi:schemaLocation="  
      http://www.springframework.org/schema/beans  
      http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
      http://www.springframework.org/schema/context  
      http://www.springframework.org/schema/context/spring-context-3.1.xsd  
      http://www.springframework.org/schema/mvc  
      http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd  
      http://www.springframework.org/schema/tx  
      http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
      http://www.springframework.org/schema/websocket  
      http://www.springframework.org/schema/websocket/spring-websocket.xsd">

    ......

    <!-- websocket -->  
    <bean id="websocket" class="cn.bridgeli.websocket.WebsocketEndPoint"/>  
    <websocket:handlers>  
      <websocket:mapping path="/websocket" handler="websocket"/>  
      <websocket:handshake-interceptors>  
      <bean class="cn.bridgeli.websocket.HandshakeInterceptor"/>  
      </websocket:handshake-interceptors>  
    </websocket:handlers>  
</beans>

其中，path对应的路径就是前段通过ws协议调的接口路径

HandshakeInterceptor的实现

package cn.bridgeli.websocket;

import cn.bridgeli.utils.UserManager;  
import cn.bridgeli.util.DateUtil;  
import cn.bridgeli.sharesession.UserInfo;  
import org.apache.commons.lang.StringUtils;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.http.server.ServerHttpRequest;  
import org.springframework.http.server.ServerHttpResponse;  
import org.springframework.web.context.request.RequestContextHolder;  
import org.springframework.web.context.request.ServletRequestAttributes;  
import org.springframework.web.socket.WebSocketHandler;  
import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;

import java.util.Date;  
import java.util.Map;

/**  
 * @Description :创建握手（handshake）接口  
 * @Date : 16-3-3  
 */
public class HandshakeInterceptor extends HttpSessionHandshakeInterceptor{  
  private static final Logger logger = LoggerFactory.getLogger(HandshakeInterceptor.class);

  @Override  
  public boolean beforeHandshake(ServerHttpRequest request,ServerHttpResponse response, WebSocketHandler wsHandler, Map<String,Object> attributes) throws Exception {  
    logger.info("建立握手前...");  
    ServletRequestAttributes attrs = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();  
    UserInfo currUser = UserManager.getSessionUser(attrs.getRequest());  
    UserSocketVo userSocketVo = new UserSocketVo();  
    String email= "";

    if(null != currUser){  
      email = currUser.getEmail();  
    }  
    if(StringUtils.isBlank(email)){  
      email = DateUtil.date2String(new Date());  
    }  
    userSocketVo.setUserEmail(email);  
    attributes.put("SESSION_USER", userSocketVo);

    return super.beforeHandshake(request, response, wsHandler, attributes);  
  }

  @Override  
  public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception ex) {  
    logger.info("建立握手后...");  
    super.afterHandshake(request, response, wsHandler, ex);  
  }  
}

因为老夫不是很懂，所以最大限度的保留原代码，这其实就是从单点登录中取出当前登录用户，转成UserSocketVo对象，放到Map中。所以接下来我们看看UserSocketVo对象的定义

UserSocketVo的定义

package cn.bridgeli.websocket;

import org.springframework.web.socket.WebSocketSession;

import java.util.Date;

/**  
 * @Description : 用户socket连接实体  
 * @Date : 16-3-7  
 */
public class UserSocketVo {

  private String userEmail; //用户邮箱  
  private Date connectionTime; //成功连接时间  
  private Date preRequestTime; //上次请求时间  
  private Date newRequestTime; //新请求时间  
  private Date lastSendTime = new Date(); //下架消息最近一次发送时间  
  private Date lastTaskSendTime = new Date(); //待处理任务最近一次发送时间  
  private WebSocketSession webSocketSession; //用户对应的wsSession 默认仅缓存一个

  // getXX and setXX  
}

其中最重要的就是这个WebSocketSession这个属性了，后面我们要用到

WebsocketEndPoint的实现

package cn.bridgeli.websocket;

import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;  
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;

/**  
 * @Description : websocket处理类  
 * @Date : 16-3-3  
 */
public class WebsocketEndPoint extends TextWebSocketHandler{  
  private static final Logger logger = LoggerFactory.getLogger(WebsocketEndPoint.class);

  @Autowired  
  private NewsListenerImpl newsListener;

  @Override  
  protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {  
    super.handleTextMessage(session, message);  
    TextMessage returnMessage = new TextMessage(message.getPayload()+" received at server");  
    session.sendMessage(returnMessage);  
  }

  /**  
   * @Description :　建立连接后  
   * @param session  
   * @throws Exception  
   */
  @Override  
  public void afterConnectionEstablished(WebSocketSession session) throws Exception{  
    UserSocketVo userSocketVo = (UserSocketVo)session.getAttributes().get("SESSION_USER");  
    if(null != userSocketVo){  
      userSocketVo.setWebSocketSession(session);  
      if(WSSessionLocalCache.exists(userSocketVo.getUserEmail())){  
        WSSessionLocalCache.remove(userSocketVo.getUserEmail());  
      }  
      WSSessionLocalCache.put(userSocketVo.getUserEmail(), userSocketVo);  
      newsListener.afterConnectionEstablished(userSocketVo.getUserEmail());  
    }  
    logger.info("socket成功建立连接...");  
    super.afterConnectionEstablished(session);  
  }

  @Override  
  public void afterConnectionClosed(WebSocketSession session,CloseStatus status) throws Exception {  
    UserSocketVo userSocketVo = (UserSocketVo)session.getAttributes().get("SESSION_USER");  
    if(null != userSocketVo){  
      WSSessionLocalCache.remove(userSocketVo.getUserEmail());  
    }  
    logger.info("socket成功关闭连接...");  
    super.afterConnectionClosed(session, status);  
  }   
}

WSSessionLocalCache的实现

package cn.bridgeli.websocket;

import java.io.Serializable;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;

/**  
 * @Description :本地缓存WebSocketSession实例  
 * @Date : 16-3-7  
 */
public class WSSessionLocalCache implements Serializable {

  private static Map<String, UserSocketVo> wsSessionCache = new HashMap<>();

  public static boolean exists(String userEmail){  
    if(!wsSessionCache.containsKey(userEmail)){  
      return false;  
    }else{  
      return true;  
    }  
  }

  public static void put(String userEmail, UserSocketVo UserSocketVo){  
    wsSessionCache.put(userEmail, UserSocketVo);  
  }

  public static UserSocketVo get(String userEmail){  
    return wsSessionCache.get(userEmail);  
  }

  public static void remove(String userEmail){  
    wsSessionCache.remove(userEmail);  
  }

  public static List<UserSocketVo> getAllSessions(){

    return new ArrayList<>(wsSessionCache.values());  
  }   
}

看了其实现，作用就比较明显了吧，存放每个UserSocketVo的最新数据，其实到这里我们websocket的实现已经算完了，但还有一个核心类（关于业务逻辑查理的类）没有实现，下篇我们就看怎么实现这个类