devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java使用WebStocket实现前后端互发消息_websocket前后端交互java

作者：神奇cpp | 2024-07-26 07:02:50

赞

踩

websocket前后端交互java

记录一下自己使用WebStocket实现服务器主动发消息的过程和踩得雷。

需求：车牌识别系统识别到车牌后，持续向前端推送车牌信息，直到前端回复收到。

测试需求：新增 客户后，持续向前端推送客户信息，直到前端收到消息，并且回复收到。

1.引入WebStocket的依赖

  1. <dependency>
  2. 	<groupId>org.springframework.boot</groupId>
  3. 	<artifactId>spring-boot-starter-websocket</artifactId>
  4. 	<version>2.7.0</version>
  5. </dependency>

2.创建配置类 WebScoketConfig

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.web.socket.server.standard.ServerEndpointExporter;
  4.  
  5. /**
  6.  * 开启WebSocket支持
  7.  */
  8. @Configuration
  9. public class WebSocketConfig {
  10.     @Bean
  11.     public ServerEndpointExporter serverEndpointExporter() {
  12.         return new ServerEndpointExporter();
  13.     }
  14. }

新增客户的业务层

  这里实现了新增 客户后，持续向前端推送客户信息。

  实现思路：本来是打算 让前端接收到客户信息，回复后端的时候，后端修改数据库中此条客户的 接收状态的字段，然后每次后端往前端发送消息的时候都去数据库查询一次 客户信息的接收状态，如果已经接收到了就不往前端推送。但是好像会造成一边读数据库，一边修改数据库，会出现脏读的问题，而且我在 WebScoketConfigServer 中并不能创建Service层的对象，总是报空指针。

  最后，决定使用 static修饰的静态变量来实现对前端是否接受到消息和是否发送的是同一条重复的消息进行判断。然后根据返回的结果决定是否继续往前端推送消息。

  1. import io.recycle.modules.rest.api.dto.system.CustomerDto;
  2. import io.recycle.modules.rest.api.dto.system.CustomerQueryDto;
  3. import io.recycle.modules.rest.api.dto.weigh.CardDto;
  4. import io.recycle.modules.rest.api.dto.weigh.CustomerParam;
  5. import io.recycle.modules.rest.api.dto.weigh.CustomerWeighDto;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8.  
  9. import java.util.List;
  10. import java.util.Map;
  11.  
  12. import io.recycle.modules.rest.api.dao.RecycleCustomerDao;
  13. import io.recycle.modules.rest.api.entity.RecycleCustomerEntity;
  14. import io.recycle.modules.rest.api.service.RecycleCustomerService;
  15.  
  16.  
  17.  
  18. @Service("recycleCustomerService")
  19. public class RecycleCustomerServiceImpl implements RecycleCustomerService{
  20.  
  21. 	private static int count=0;
  22. 	@Autowired
  23. 	private NoticeWebsocket noticeWebsocket;
  24. 	@Autowired
  25. 	private RecycleCustomerDao recycleCustomerDao;
  26.  
  27. 	@Override
  28. 	public void save(RecycleCustomerEntity recycleCustomer){
  29. 		recycleCustomerDao.save(recycleCustomer);
  30. 		//测试webstocket,实现新增客户往前端推送消息，直到前端回复
  31. //		//测试webstocket
  32. 		boolean flag = false;
  33. 		do{
  34. 			try {
  35. 				Thread.sleep(300);    //休息300毫秒
  36. 			} catch (InterruptedException e) {
  37. 				e.printStackTrace();
  38. 				System.out.println("休息时出错000000");
  39. 			}
  40. 			//往前端发送消息
  41. 			System.out.println("count===="+count);
  42. 			boolean resultFlag = noticeWebsocket.sendMessage("新增了用户：" + recycleCustomer.toString(),count);
  43.  
  44. 			flag = resultFlag;
  45.  
  46. 			if (resultFlag){
  47. 				System.out.println("停止往前端发送数据，因为 resultFlag 为： "+resultFlag+"==说明前端已接收的消息");
  48. 			}else {
  49. 				System.out.println("往前端发送数据，因为 resultFlag 为： "+resultFlag+"==说明前端还没接收到消息");
  50. 			}
  51.  
  52.  
  53. 		}while ( !flag );
  54. 		System.out.println("停止往前端发送数据，因为 delFlag 为： "+flag);
  55. 		count = count +1;
  56.  
  57.  
  58. 	}
  59. }

3.创建WebScoketConfigServer

在websocket协议下，后端服务器相当于ws里的客户端，需要用@ServerEndpoint指定访问的路径，并使用@Component注入容器。

这里实现了新增 客户后，持续向前端推送客户信息，直到前端收到消息，并且回复收到。

实现思路：

  1. import com.alibaba.fastjson.JSONObject;
  2. import io.recycle.modules.rest.api.dao.RecycleCustomerDao;
  3. import io.recycle.modules.rest.api.dto.websocket.NoticeWebsocketResp;
  4. import io.recycle.modules.rest.api.entity.RecycleCustomerEntity;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.util.StringUtils;
  9. import javax.websocket.*;
  10. import javax.websocket.server.PathParam;
  11. import javax.websocket.server.ServerEndpoint;
  12. import java.io.IOException;
  13. import java.util.*;
  14. import java.util.concurrent.ConcurrentHashMap;
  15.  
  16. /**
  17.  * @ServerEndpoint 注解是一个类层次的注解，它的功能主要是将目前的类定义成一个websocket服务器端,
  18.  * 注解的值将被用于监听用户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端
  19.  */
  20. @ServerEndpoint("/chepaisend")
  21. @Component
  22. @Slf4j
  23. public class NoticeWebsocket {
  24.  
  25.     //记录连接的客户端
  26.     public static Map<String, Session> clients = new ConcurrentHashMap<>();
  27.  
  28.     /**
  29.      * userId关联sid（解决同一用户id，在多个web端连接的问题）
  30.      */
  31.     public static Map<String, Set<String>> conns = new ConcurrentHashMap<>();
  32.  
  33.     private String sid = null;
  34.  
  35.  
  36.  
  37.  
  38.     //一些记录发送消息状态
  39.     private static int initFlag =0;
  40.  
  41.     private static int tempFlag =0;
  42.     //区分新旧消息的变量
  43.     private static int sum=0;
  44.     /**
  45.      * 连接成功后调用的方法
  46.      * @param session
  47.      *
  48.      */
  49.     @OnOpen
  50.     public void onOpen(Session session) {
  51.         this.sid = UUID.randomUUID().toString();
  52.  
  53.         clients.put(this.sid, session);
  54.  
  55.         log.info(this.sid + "连接开启！");
  56.     }
  57.  
  58.     /**
  59.      * 连接关闭调用的方法
  60.      */
  61.     @OnClose
  62.     public void onClose() {
  63.         log.info(this.sid + "连接断开！");
  64.         clients.remove(this.sid);
  65.     }
  66.  
  67.     /**
  68.      * 判断是否连接的方法
  69.      * @return
  70.      */
  71.     public static boolean isServerClose() {
  72.         if (NoticeWebsocket.clients.values().size() == 0) {
  73.             log.info("已断开");
  74.             return true;
  75.         }else {
  76.             log.info("已连接");
  77.             return false;
  78.         }
  79.     }
  80.  
  81.     /**
  82.      * 发送给所有用户
  83.      * @param noticeType
  84.      */
  85.  
  86.     public static boolean sendMessage(String noticeType,int count){
  87.         //判断是否是新的新增客户
  88.         System.out.println("count= "+count+",sum= "+sum+",initFlag= "+initFlag+",tempFlag= "+tempFlag);
  89.         if (sum != count){
  90.             NoticeWebsocketResp noticeWebsocketResp = new NoticeWebsocketResp();
  91.             noticeWebsocketResp.setNoticeType(noticeType);
  92.             sendMessage(noticeWebsocketResp);
  93.             sum = count;
  94.         }
  95.         //判断前端是否 回复了 收到消息  相等没收到，不相等 收到
  96.         if (initFlag==tempFlag){
  97.             NoticeWebsocketResp noticeWebsocketResp = new NoticeWebsocketResp();
  98.             noticeWebsocketResp.setNoticeType(noticeType);
  99.             sendMessage(noticeWebsocketResp);
  100.         }else {
  101.             //收到消息了，别发同一个消息了
  102.             tempFlag = initFlag;
  103.             return true;
  104.         }
  105.         tempFlag = initFlag;
  106.         //没收到消息继续发
  107.         return false;
  108.     }
  109.  
  110.  
  111.     /**
  112.      * 发送给所有用户
  113.      * @param noticeWebsocketResp
  114.      */
  115.     public static void sendMessage(NoticeWebsocketResp noticeWebsocketResp){
  116.         String message = JSONObject.toJSONString(noticeWebsocketResp);
  117.         for (Session session1 : NoticeWebsocket.clients.values()) {
  118.             try {
  119.                 session1.getBasicRemote().sendText(message);
  120.             } catch (IOException e) {
  121.                 e.printStackTrace();
  122.             }
  123.         }
  124.     }
  125.  
  126.     /**
  127.      * 根据用户id发送给某一个用户
  128.      * **/
  129.     public static void sendMessageByUserId(String userId, NoticeWebsocketResp noticeWebsocketResp) {
  130.         if (!StringUtils.isEmpty(userId)) {
  131.             String message = JSONObject.toJSONString(noticeWebsocketResp);
  132.             Set<String> clientSet = conns.get(userId);
  133.             if (clientSet != null) {
  134.                 Iterator<String> iterator = clientSet.iterator();
  135.                 while (iterator.hasNext()) {
  136.                     String sid = iterator.next();
  137.                     Session session = clients.get(sid);
  138.                     if (session != null) {
  139.                         try {
  140.                             session.getBasicRemote().sendText(message);
  141.                         } catch (IOException e) {
  142.                             e.printStackTrace();
  143.                         }
  144.                     }
  145.                 }
  146.             }
  147.         }
  148.     }
  149.  
  150.  
  151.     /**
  152.      * 收到客户端消息后调用的方法
  153.      * @param message
  154.      * @param session
  155.      */
  156.  
  157.     @OnMessage
  158.     public void onMessage(String message, Session session) {
  159.         log.info("收到来自窗口"+"的信息:"+message);
  160.         if ("已接收到消息".equals(message)){
  161.             //收到消息，改变flag的值
  162.             System.out.println("前端已经收到消息，开始改变 initFlag的值，此时initFlag= "+initFlag);
  163.             initFlag = initFlag +1;
  164.             System.out.println("前端已经收到消息，已经改变 initFlag的值，此时initFlag== "+initFlag);
  165.         }
  166.  
  167.     }
  168.  
  169.     /**
  170.      * 发生错误时的回调函数
  171.      * @param error
  172.      */
  173.     @OnError
  174.     public void onError(Throwable error) {
  175.         log.info("错误");
  176.         error.printStackTrace();
  177.     }
  178.  
  179. }

封装的发送消息的对象

  1. import io.swagger.annotations.ApiModel;
  2. import io.swagger.annotations.ApiModelProperty;
  3. import lombok.Data;
  4.  
  5. @Data
  6. @ApiModel("ws通知返回对象")
  7. public class NoticeWebsocketResp<T> {
  8.  
  9.     @ApiModelProperty(value = "通知类型")
  10.     private String noticeType;
  11.  
  12.     @ApiModelProperty(value = "通知内容")
  13.     private T noticeInfo;
  14.  
  15. }

4.WebSocket调用

用户端调用此接口，主动将消息发送给后端，后端接收到消息后再主动推送给指定/全部用户，可以实现消息的私聊和群发功能。

  1. import io.recycle.common.utils.R;
  2. import io.recycle.modules.rest.api.service.impl.NoticeWebsocket;
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6.  
  7. @RestController
  8. @RequestMapping("/order")
  9. public class OrderController {
  10. 	@GetMapping("/test")
  11.     public R test() {
  12.     	NoticeWebsocket.sendMessage("你好，WebSocket",1);
  13.         return R.ok();
  14.     }
  15. }

前端WebSocket连接

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>SseEmitter</title>
  6. </head>
  7. <body>
  8. <div id="message"></div>
  9. </body>
  10. <script>
  11.     var limitConnect = 0;
  12.     init();
  13.     function init() {
  14.         //开启webstocket服务的ip地址  ws:// + ip地址 + 访问路径
  15.         var ws = new WebSocket('ws://127.0.0.1:8191/double-win/chepaisend');
  16. // 获取连接状态
  17.         console.log('ws连接状态：' + ws.readyState);
  18. //监听是否连接成功
  19.         ws.onopen = function () {
  20.             console.log('ws连接状态：' + ws.readyState);
  21.             limitConnect = 0;
  22.             //连接成功则发送一个数据
  23.             ws.send('我们建立连接啦');
  24.         }
  25. // 接听服务器发回的信息并处理展示
  26.         ws.onmessage = function (data) {
  27.             console.log('接收到来自服务器的消息：');
  28.             console.log(data);
  29.             //接收到 消息后给后端发送的 确认收到消息，后端接收到后 不再重复发消息
  30.             ws.send('已接收到消息');
  31.             //完成通信后关闭WebSocket连接
  32.             // ws.close();
  33.         }
  34. // 监听连接关闭事件
  35.         ws.onclose = function () {
  36.             // 监听整个过程中websocket的状态
  37.             console.log('ws连接状态：' + ws.readyState);
  38.             reconnect();
  39.  
  40.         }
  41. // 监听并处理error事件
  42.         ws.onerror = function (error) {
  43.             console.log(error);
  44.         }
  45.     }
  46.     function reconnect() {
  47.         limitConnect ++;
  48.         console.log("重连第" + limitConnect + "次");
  49.         setTimeout(function(){
  50.             init();
  51.         },2000);
  52.  
  53.     }
  54. </script>
  55. </html>
  56.

项目启动后，打开写好的前端页面后控制台打印连接信息

 新增客户后，前端接收到，并回复收到了

  新增客户后，前端接收到，并回复收到了，后端停止推送

前端接收到，但是骗后端没收到，或者说后端不知道 前端已经接收到消息。 

后端展示，后端一直往前端推送

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/884070
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号