EN中文
开发者社区 > 美术

Spring整合WebSocket应用示例(上)

发表于2017-08-01
评论0 1.6k浏览

以下是在参与开发公司的一个crm系统，整理了相关资料，在该系统中有很多消息推送功能，在其中用到了websocket技术。特地将Spring整合WebSocket应用示例整理出来分享给给大家参考。


1. maven依赖

  3. javax.servlet
  4. javax.servlet-api
  5. 3.1.0
  8. com.fasterxml.jackson.core
  9. jackson-core
  10. 2.3.0
  13. com.fasterxml.jackson.core
  14. jackson-databind
  15. 2.3.0
  18. org.springframework
  19. spring-websocket
  20. 4.0.1.RELEASE
  23. org.springframework
  24. spring-messaging
  25. 4.0.1.RELEASE
复制代码

2. spring-servlet的配置

  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:mvc="http://www.springframework.org/schema/mvc"
  6. xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  7. xmlns:websocket="http://www.springframework.org/schema/websocket"
  8. xsi:schemaLocation="
  9. http://www.springframework.org/schema/beans
  10. http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
  11. http://www.springframework.org/schema/context
  12. http://www.springframework.org/schema/context/spring-context-3.1.xsd
  13. http://www.springframework.org/schema/mvc
  14. http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
  15. http://www.springframework.org/schema/tx
  16. http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
  17. http://www.springframework.org/schema/websocket
  18. http://www.springframework.org/schema/websocket/spring-websocket.xsd">
  19. ......
  24. </websocket:handshake-interceptors>
复制代码

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

3. HandshakeInterceptor的实现

  2. package cn.bridgeli.websocket;
  3. import cn.bridgeli.utils.UserManager;
  4. import cn.bridgeli.util.DateUtil;
  5. import cn.bridgeli.sharesession.UserInfo;
  6. import org.apache.commons.lang.StringUtils;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.http.server.ServerHttpRequest;
  10. import org.springframework.http.server.ServerHttpResponse;
  11. import org.springframework.web.context.request.RequestContextHolder;
  12. import org.springframework.web.context.request.ServletRequestAttributes;
  13. import org.springframework.web.socket.WebSocketHandler;
  14. import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;
  15. import java.util.Date;
  16. import java.util.Map;
  17. /**
  18. * @Description :创建握手（handshake）接口
  19. * @Date : 16-3-3
  20. */
  21. public class HandshakeInterceptor extends HttpSessionHandshakeInterceptor{
  22. private static final Logger logger = LoggerFactory.getLogger(HandshakeInterceptor.class);
  23. @Override
  24. public boolean beforeHandshake(ServerHttpRequest request,
  25. ServerHttpResponse response, WebSocketHandler wsHandler,
  26. Map attributes) throws Exception {
  27. logger.info("建立握手前...");
  28. ServletRequestAttributes attrs = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  29. UserInfo currUser = UserManager.getSessionUser(attrs.getRequest());
  30. UserSocketVo userSocketVo = new UserSocketVo();
  31. String email= "";
  32. if(null != currUser){
  33. email = currUser.getEmail();
  34. }
  35. if(StringUtils.isBlank(email)){
  36. email = DateUtil.date2String(new Date());
  37. }
  38. userSocketVo.setUserEmail(email);
  39. attributes.put("SESSION_USER", userSocketVo);
  40. return super.beforeHandshake(request, response, wsHandler, attributes);
  41. }
  42. @Override
  43. public void afterHandshake(ServerHttpRequest request,
  44. ServerHttpResponse response, WebSocketHandler wsHandler,
  45. Exception ex) {
  46. logger.info("建立握手后...");
  47. super.afterHandshake(request, response, wsHandler, ex);
  48. }
  49. }
复制代码

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

4. UserSocketVo的定义

  2. package cn.bridgeli.websocket;
  3. import org.springframework.web.socket.WebSocketSession;
  4. import java.util.Date;
  5. /**
  6. * @Description : 用户socket连接实体
  7. * @Date : 16-3-7
  8. */
  9. public class UserSocketVo {
  10. private String userEmail; //用户邮箱
  11. private Date connectionTime; //成功连接时间
  12. private Date preRequestTime; //上次请求时间
  13. private Date newRequestTime; //新请求时间
  14. private Date lastSendTime = new Date(); //下架消息最近一次发送时间
  15. private Date lastTaskSendTime = new Date(); //待处理任务最近一次发送时间
  16. private WebSocketSession webSocketSession; //用户对应的wsSession 默认仅缓存一个
  17. // getXX and setXX
  18. }
复制代码

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

5. WebsocketEndPoint的实现

  2. package cn.bridgeli.websocket;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.socket.CloseStatus;
  7. import org.springframework.web.socket.TextMessage;
  8. import org.springframework.web.socket.WebSocketSession;
  9. import org.springframework.web.socket.handler.TextWebSocketHandler;
  10. /**
  11. * @Description : websocket处理类
  12. * @Date : 16-3-3
  13. */
  14. public class WebsocketEndPoint extends TextWebSocketHandler{
  15. private static final Logger logger = LoggerFactory.getLogger(WebsocketEndPoint.class);
  16. @Autowired
  17. private NewsListenerImpl newsListener;
  18. @Override
  19. protected void handleTextMessage(WebSocketSession session,
  20. TextMessage message) throws Exception {
  21. super.handleTextMessage(session, message);
  22. TextMessage returnMessage = new TextMessage(message.getPayload() " received at server");
  23. session.sendMessage(returnMessage);
  24. }
  25. /**
  26. * @Description :　建立连接后
  27. * @param session
  28. * @throws Exception
  29. */
  30. @Override
  31. public void afterConnectionEstablished(WebSocketSession session) throws Exception{
  32. UserSocketVo userSocketVo = (UserSocketVo)session.getAttributes().get("SESSION_USER");
  33. if(null != userSocketVo){
  34. userSocketVo.setWebSocketSession(session);
  35. if(WSSessionLocalCache.exists(userSocketVo.getUserEmail())){
  36. WSSessionLocalCache.remove(userSocketVo.getUserEmail());
  37. }
  38. WSSessionLocalCache.put(userSocketVo.getUserEmail(), userSocketVo);
  39. newsListener.afterConnectionEstablished(userSocketVo.getUserEmail());
  40. }
  41. logger.info("socket成功建立连接...");
  42. super.afterConnectionEstablished(session);
  43. }
  44. @Override
  45. public void afterConnectionClosed(WebSocketSession session,CloseStatus status) throws Exception{
  46. UserSocketVo userSocketVo = (UserSocketVo)session.getAttributes().get("SESSION_USER");
  47. if(null != userSocketVo){
  48. WSSessionLocalCache.remove(userSocketVo.getUserEmail());
  49. }
  50. logger.info("socket成功关闭连接...");
  51. super.afterConnectionClosed(session, status);
  52. }
  53. }
复制代码

6. WSSessionLocalCache的实现

  2. package cn.bridgeli.websocket;
  3. import java.io.Serializable;
  4. import java.util.ArrayList;
  5. import java.util.HashMap;
  6. import java.util.List;
  7. import java.util.Map;
  8. /**
  9. * @Description :本地缓存WebSocketSession实例
  10. * @Date : 16-3-7
  11. */
  12. public class WSSessionLocalCache implements Serializable {
  13. private static Map wsSessionCache = new HashMap<>();
  14. public static boolean exists(String userEmail){
  15. if(!wsSessionCache.containsKey(userEmail)){
  16. return false;
  17. }else{
  18. return true;
  19. }
  20. }
  21. public static void put(String userEmail, UserSocketVo UserSocketVo){
  22. wsSessionCache.put(userEmail, UserSocketVo);
  23. }
  24. public static UserSocketVo get(String userEmail){
  25. return wsSessionCache.get(userEmail);
  26. }
  27. public static void remove(String userEmail){
  28. wsSessionCache.remove(userEmail);
  29. }
  30. public static List getAllSessions(){
  31. return new ArrayList<>(wsSessionCache.values());
  32. }
  33. }
复制代码

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

WebSocket协议介绍

WebSocket协议是RFC-6455规范定义的一个Web领域的重要的功能：全双工，即客户端和服务器之间的双向通信。它是一个令人兴奋的功能，业界在此领域上已经探索很久，使用的技术包括Java Applet、XMLHttpRequest、Adobe Flash、ActiveXObject、各种Comet技术、服务器端的发送事件等。

需要理解一点，在使用WebSocket协议前，需要先使用HTTP协议用于构建最初的握手。这依赖于一个机制——建立HTTP，请求协议升级（或叫协议转换）。当服务器同意后，它会响应HTTP状态码101，表示同意切换协议。假设通过TCP套接字成功握手，HTTP协议升级请求通过，那么客户端和服务器端都可以彼此互发消息。

Spring框架4.0以上版本引入了一个新模块，即spring-websocket模块。它对WebSocket通信提供了支持。它兼容Java WebSocket API规范JSR-356，同时提供了额外的功能。

什么场景下该使用WebSocket

在Web应用中，客户端和服务器端需要以较高频率和较低延迟来交换事件时，适合用WebSocket。因此WebSocket适合财经、游戏、协作等应用场景。
对于其他应用场景则未必适合。例如，某个新闻订阅需要显示突发新闻，使用间隔几分钟的长轮询也是可以的，这里的延迟可以接受。
即使在要求低延迟的应用场景，如果传输的消息数很低（比如监测网络故障的场景），那么应该考虑使用长轮询技术。

而只有在低延迟和高频消息通信的场景下，选用WebSocket协议才是非常适合的。即使是这样的应用场景，仍然存在是选择WebSocket通信呢？又或者是选择REST HTTP通信呢？
答案是会根据应用程序的需求而定。但是，也可能同时使用这两种技术，把需要频繁交换的数据放到WebSocket中实现，而把REST API作为过程性的业务的实现技术。另外，当REST API的调用中需要把某个信息广播给多个客户端是，也可以通过WebSocket连接来实现。

Spring框架提供了@Controller注释和@RestController注释，两者都可以用于HTTP请求的处理以及WebSocket消息的处理。另外，Spring MVC的请求处理方法，或其它应用程序的请求处理方法，都可以很容易地使用WebSocket协议来广播消息到所有感兴趣的客户端或指定用户。

如社区发表内容存在侵权行为，您可以点击这里查看侵权投诉指引

标签：

List场景Map轮询接口flash