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

SpringBoot整合Netty+Websocket实现消息推送_springboot 整合websoket与netty

作者：我家自动化 | 2024-04-11 09:34:49

赞

踩

springboot 整合websoket与netty

前言

       Netty是一个高性能、异步事件驱动的网络应用框架，用于快速开发可维护的高性能协议服务器和客户端。以下是Netty的主要优势：

  1. 高性能：Netty基于NIO（非阻塞IO）模型，采用事件驱动的设计，具有高性能的特点。它通过零拷贝技术、内存池化技术等手段，进一步提高了IO性能，降低了资源消耗。
  2. 易用性：Netty提供了丰富的API和功能，如对TCP、UDP和文件传输的支持，以及对SSL/TLS、压缩、编解码等功能的内置实现。这些功能简化了网络应用的开发，降低了学习和使用的难度。
  3. 可扩展性：Netty采用了模块化设计，各个模块之间耦合度低，易于扩展。开发者可以根据需要定制和扩展Netty的功能，如添加新的编解码器、处理器或协议。
  4. 稳定性：Netty经过了大规模生产环境的验证，具有高稳定性。它通过合理的线程模型、资源管理和错误处理机制，保证了系统的稳定性和可靠性。
  5. 社区活跃：Netty拥有一个活跃的开源社区，不断有新的功能和优化被贡献出来。这为开发者提供了强大的支持，也促进了Netty的发展和完善。
  6. 跨平台性：Netty可以在多种操作系统和平台上运行，如Windows、Linux和Mac OS等。这一特性使得开发者可以轻松地在不同环境下部署和维护网络应用。

        WebSocket 是一种网络通信协议，相比传统的HTTP协议，它具有以下优势： 

  1. 实时性：WebSocket 允许服务器主动向客户端推送数据，从而实现实时通信，这对于需要即时反馈的应用（如在线游戏、聊天应用等）至关重要。
  2. 全双工通信：WebSocket 支持双向通信，服务器和客户端可以同时发送和接收数据，提高了通信的灵活性。
  3. 节省带宽：由于 WebSocket 在单个 TCP 连接上运行，避免了为每个消息创建新连接所需的额外开销，减少了数据传输量。
  4. 更好的二进制支持：WebSocket 定义了二进制帧，可以更轻松地处理二进制内容，如图片、音视频等。
  5. 跨域通信：WebSocket 支持跨域通信，使得客户端可以与不同域名的服务器进行通信，增加了应用的灵活性和可访问性。
  6. 可扩展性：WebSocket 定义了扩展机制，用户可以根据需要扩展协议或实现自定义的子协议。
  7. 更好的支持实时应用：由于 WebSocket 的实时性和全双工通信特性，它特别适合用于需要实时反馈的应用，例如在线游戏、实时音视频聊天等。
  8. 更快的传输速度：由于 WebSocket 减少了不必要的连接和状态转换，通信速度更快。
  9. 更低的延迟：由于 WebSocket 建立的是持久连接，减少了建立和关闭连接的开销，从而降低了通信延迟。
  10. 更强的兼容性：虽然 WebSocket 协议并未在所有浏览器中得到完全支持，但有各种库和框架可以帮助实现兼容性，例如通过 polyfill 技术。

说明：以下为SpringBoot整合Netty+Websocket实现实时的消息通讯

一、引入Netty依赖

  1.    <!--netty-->
  2.         <dependency>
  3.             <groupId>io.netty</groupId>
  4.             <artifactId>netty-all</artifactId>
  5.             <version>4.1.25.Final</version>
  6.         </dependency>

二、 使用步骤

1.配置服务启动类

  1. package com.pzg.chat.communication;
  2.  
  3. import io.netty.bootstrap.ServerBootstrap;
  4. import io.netty.channel.ChannelFuture;
  5. import io.netty.channel.nio.NioEventLoopGroup;
  6. import io.netty.channel.socket.nio.NioServerSocketChannel;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Component;
  10.  
  11. import javax.annotation.PostConstruct;
  12.  
  13. @Slf4j
  14. @Component
  15. public class WebSocketNettyServer {
  16.  
  17. 	@Autowired
  18. 	WebSocketChannelInitializer webSocketChannelInitializer;
  19. 	/**
  20. 	 * Netty服务器启动对象
  21. 	 */
  22. 	private  final ServerBootstrap serverBootstrap = new ServerBootstrap();;
  23.  
  24. 	@PostConstruct
  25. 	public void WebSocketNettyServerInit() {
  26. 		// 初始化服务器启动对象
  27. 		// 主线程池
  28. 		NioEventLoopGroup mainGrp = new NioEventLoopGroup();
  29. 		// 从线程池
  30. 		NioEventLoopGroup subGrp = new NioEventLoopGroup();
  31. 		serverBootstrap
  32. 				// 指定使用上面创建的两个线程池
  33. 				.group(mainGrp, subGrp)
  34. 				// 指定Netty通道类型
  35. 				.channel(NioServerSocketChannel.class)
  36. 				// 指定通道初始化器用来加载当Channel收到事件消息后
  37. 				.childHandler(webSocketChannelInitializer);
  38. 	}
  39.  
  40. 	public void start() throws InterruptedException {
  41. 		// 绑定服务器端口，以异步的方式启动服务器
  42. 		ChannelFuture future = serverBootstrap.bind("0.0.0.0",8089).sync();
  43. 		if (future.isSuccess()){
  44. 			log.info("netty初始化完成，端口8088");
  45. 		}
  46. 	}
  47. }

        说明：@PostConstruct用来保证容器初始化后触发该注解下的方法

 2.Netty服务初始化器

  1. package com.pzg.chat.communication;
  2.  
  3. import com.pzg.chat.handler.ChatHandler;
  4. import io.netty.channel.ChannelInitializer;
  5. import io.netty.channel.ChannelPipeline;
  6. import io.netty.channel.socket.SocketChannel;
  7. import io.netty.handler.codec.http.HttpObjectAggregator;
  8. import io.netty.handler.codec.http.HttpServerCodec;
  9. import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
  10. import io.netty.handler.stream.ChunkedWriteHandler;
  11. import io.netty.handler.timeout.IdleStateHandler;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.stereotype.Component;
  14.  
  15.  
  16. @Component
  17. public class WebSocketChannelInitializer extends ChannelInitializer<SocketChannel> {
  18.  
  19. 	@Autowired
  20. 	private ChatHandler chatHandler;
  21.  
  22. 	@Override
  23. 	protected void initChannel(SocketChannel socketChannel) {
  24. 		//获取对应的管道
  25. 		ChannelPipeline pipeline = socketChannel.pipeline();
  26.  
  27. 		pipeline
  28. 				//添加HTTP编码解码器
  29. 				.addLast(new HttpServerCodec())
  30. 				//添加对大数据流的支持
  31. 				.addLast(new ChunkedWriteHandler())
  32. 				//添加聚合器
  33. 				.addLast(new HttpObjectAggregator(1024 * 64))
  34. 				//设置websocket连接前缀前缀
  35. 				//心跳检查(8秒)
  36. 				.addLast(new IdleStateHandler(8,0,0))
  37. 				//添加自定义处理器
  38. 				.addLast(new WebSocketServerProtocolHandler("/ws",null,true))
  39. 				.addLast(chatHandler);
  40.  
  41. 	}
  42. }

3.自定义处理器类

  1. package com.pzg.chat.handler;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.pzg.chat.communication.context.impl.WebSocketContext;
  6. import com.pzg.chat.service.ChannelService;
  7. import io.netty.channel.*;
  8. import io.netty.channel.group.ChannelGroup;
  9. import io.netty.channel.group.DefaultChannelGroup;
  10. import io.netty.handler.codec.http.FullHttpRequest;
  11. import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
  12. import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
  13. import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
  14. import io.netty.handler.codec.http.websocketx.WebSocketFrame;
  15. import io.netty.handler.timeout.IdleState;
  16. import io.netty.handler.timeout.IdleStateEvent;
  17. import io.netty.util.concurrent.GlobalEventExecutor;
  18. import lombok.extern.slf4j.Slf4j;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.stereotype.Component;
  21. import javax.annotation.PostConstruct;
  22. @ChannelHandler.Sharable
  23. @SuppressWarnings("all")
  24. @Component
  25. @Slf4j
  26. public class ChatHandler extends SimpleChannelInboundHandler<WebSocketFrame> {
  27.  
  28. 	private static ChatHandler chatHandler;
  29.  
  30. 	@Autowired
  31. 	private ChannelService channelService;
  32.  
  33.  
  34. 	@Autowired
  35. 	private WebSocketContext webSocketContext;
  36.  
  37.  
  38. 	@PostConstruct
  39. 	public void init() {
  40. 		chatHandler = this;
  41. 	}
  42.  
  43. 	/**
  44. 	 * 创建ChannelGroup对象存储所有连接的用户
  45. 	 */
  46. 	private static final ChannelGroup clients = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
  47.  
  48. 	/**
  49. 	 * 有新消息时会调用这个方法
  50. 	 *
  51. 	 * @param channelHandlerContext 上下文处理器
  52. 	 * @param textWebSocketFrame    文本
  53. 	 * @throws Exception
  54. 	 */
  55. 	@Override
  56. 	@SuppressWarnings("all")
  57. 	public void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception {
  58. 		System.out.println(frame.getClass());
  59. 		if (frame instanceof FullHttpRequest) {
  60. 		}
  61. 		//判断是否为关闭事件
  62. 		if (frame instanceof CloseWebSocketFrame) {
  63. 			ctx.channel().close();
  64. 			return;
  65. 		}
  66. 		if (frame instanceof PingWebSocketFrame) {
  67. 			return;
  68. 		}
  69. 		if (frame instanceof TextWebSocketFrame) {
  70. 			TextWebSocketFrame textWebSocketFrame = (TextWebSocketFrame) frame;
  71. 			JSONObject jsonObject = JSON.parseObject(textWebSocketFrame.text());
  72. 			webSocketContext.executeWebSocketContext(jsonObject,ctx.channel());
  73. 			//类型转为（前后端达成的消息体）
  74. 		}
  75. 		//遍历出所有连接的通道
  76. 	}
  77.  
  78. 	/**
  79. 	 * 有新的连接建立时
  80. 	 *
  81. 	 * @param ctx
  82. 	 * @throws Exception
  83. 	 */
  84. 	@Override
  85. 	public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
  86. 		//加入通道组
  87. 		clients.add(ctx.channel());
  88. 	}
  89.  
  90. 	/**
  91. 	 * 不活跃时会调用这个方法
  92. 	 *
  93. 	 * @param ctx
  94. 	 * @throws Exception
  95. 	 */
  96. 	@Override
  97. 	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
  98. 		//移除出通道组
  99. 		try {
  100. 			channelService.deleteBindUserIdAndIdChannel(ctx.channel().id().asShortText());
  101. 			channelService.deleteChannelBindUserId(ctx.channel());
  102. 		}catch (Exception e){
  103.  
  104. 		}
  105. 		clients.remove(ctx.channel());
  106. 	}
  107.  
  108. 	@Override
  109. 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
  110. 		// 获取参数
  111. 		super.channelActive(ctx);
  112. 	}
  113.  
  114. 	//检查客户端写心跳事件
  115. 	@Override
  116. 	public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
  117. 		Channel channel = ctx.channel();
  118. 		if (evt instanceof IdleStateEvent) {
  119. 			IdleStateEvent idleStateEvent = (IdleStateEvent) evt;
  120. 			if (idleStateEvent.state() == IdleState.READER_IDLE) {
  121. 				try {
  122. 					channelService.deleteBindUserIdAndIdChannel(ctx.channel().id().asShortText());
  123. 					channelService.deleteChannelBindUserId(ctx.channel());
  124. 				}catch (Exception e){
  125.  
  126. 				}
  127. 				clients.remove(channel);
  128. 				channel.close();
  129. 			}
  130. 		} else {
  131. 			super.userEventTriggered(ctx, evt);
  132. 		}
  133. 	}
  134.  
  135.  
  136. }

        说明：webSocketContext.executeWebSocketContext(jsonObject,ctx.channel()); 为自己定义的处理消息的类，textWebSocketFrame.text()为对应的消息，可自行处理

4.缓存用户Channel接口和对应实现类

1.接口

  1. package com.pzg.chat.service;
  2.  
  3. import io.netty.channel.Channel;
  4.  
  5. public interface ChannelService {
  6.  
  7. 	void setUserIdBindChannel(Channel channel);
  8.  
  9. 	void setIdBindChannel(String id,Channel channel);
  10.  
  11. 	void setChannelBindUserId(Channel channel);
  12.  
  13. 	String getChannelBindUserId(Channel channel);
  14.  
  15. 	void deleteChannelBindUserId(Channel channel);
  16.  
  17. 	void deleteBindUserIdChannel();
  18.  
  19. 	void deleteBindIdChannel(String id);
  20.  
  21. 	void setUserIdAndIdBindChannel(String id ,Channel channel);
  22.  
  23. 	void deleteBindUserIdAndIdChannel(String id);
  24.  
  25. 	Channel getUserIdChannel(String userId);
  26.  
  27. 	Channel getIdBindChannel(String Id);
  28. }

2.实现类 

  1. package com.pzg.chat.service.impl;
  2. import com.pzg.chat.service.ChannelService;
  3. import com.pzg.chat.utils.UserUtil;
  4. import io.netty.channel.Channel;
  5. import org.springframework.stereotype.Service;
  6.  
  7. import java.util.*;
  8.  
  9. @Service
  10. public class ChannelServiceImpl implements ChannelService {
  11.  
  12. 	//保存用户id和channel的映射
  13. 	public static HashMap<String,Channel> userIdChannel = new HashMap<>();
  14. 	//保存channelId和channel映射关系
  15. 	public static HashMap<String,Channel> idChannel = new HashMap<>();
  16. 	//保存channel和userID映射关系
  17. 	public static HashMap<Channel,String> ChannelUserId = new HashMap<>();
  18.  
  19. 	@Override
  20. 	public void setUserIdBindChannel(Channel channel) {
  21. 		String userId = String.valueOf(UserUtil.getUserDetailsDTO().getId());
  22. 		userIdChannel.put(userId,channel);
  23. 	}
  24.  
  25. 	@Override
  26. 	public void setIdBindChannel(String id, Channel channel) {
  27. 		idChannel.put(id,channel);
  28. 	}
  29.  
  30. 	@Override
  31. 	public void setChannelBindUserId(Channel channel) {
  32. 		String userId = String.valueOf(UserUtil.getUserDetailsDTO().getId());
  33. 		System.out.println("----------------------->"+userId);
  34. 		ChannelUserId.put(channel,userId);
  35. 	}
  36.  
  37. 	@Override
  38. 	public String getChannelBindUserId(Channel channel) {
  39. 		return ChannelUserId.get(channel);
  40. 	}
  41.  
  42. 	@Override
  43. 	public void deleteChannelBindUserId(Channel channel) {
  44. 		ChannelUserId.remove(channel);
  45. 	}
  46.  
  47. 	@Override
  48. 	public void deleteBindUserIdChannel() {
  49. 		String userId = String.valueOf(UserUtil.getUserDetailsDTO().getId());
  50. 		userIdChannel.remove(userId);
  51. 	}
  52.  
  53. 	@Override
  54. 	public void deleteBindIdChannel(String id) {
  55. 		idChannel.remove(id);
  56. 	}
  57.  
  58. 	@Override
  59. 	public void setUserIdAndIdBindChannel(String id, Channel channel) {
  60. 		setUserIdBindChannel(channel);
  61. 		setIdBindChannel(id,channel);
  62. 	}
  63.  
  64. 	@Override
  65. 	public void deleteBindUserIdAndIdChannel(String id) {
  66. 		deleteBindIdChannel(id);
  67. 		deleteBindUserIdChannel();
  68. 	}
  69.  
  70. 	@Override
  71. 	public Channel getUserIdChannel(String userId) {
  72. 		return userIdChannel.get(userId);
  73. 	}
  74.  
  75. 	@Override
  76. 	public Channel getIdBindChannel(String Id) {
  77. 		return idChannel.get(Id);
  78. 	}
  79.  
  80. }

        说明：缓存Channel主要保证消息能发送到对应的Channel中，消息可携带用户id通过id查找Channel,将信息存入即可 ，通过channel.writeAndFlush(new TextWebSocketFrame("消息内容"));刷出消息。

5.调用start()启动Netty服务

  1. package com.pzg.chat.listener;
  2.  
  3. import com.pzg.chat.communication.WebSocketNettyServer;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.ApplicationListener;
  6. import org.springframework.context.event.ContextRefreshedEvent;
  7. import org.springframework.stereotype.Component;
  8.  
  9. @Component
  10. public class NettyStartListener implements ApplicationListener<ContextRefreshedEvent> {
  11.  
  12. 	/**
  13. 	 * 注入启动器
  14. 	 */
  15. 	@Autowired
  16. 	private WebSocketNettyServer webSocketNettyServer;
  17.  
  18. 	@Override
  19. 	public void onApplicationEvent(ContextRefreshedEvent event) {
  20. 		//判断event上下文中的父级是否为空
  21. 		if (event.getApplicationContext().getParent() == null) {
  22. 			try {
  23. 				//为空则调用start方法
  24. 				webSocketNettyServer.start();
  25. 			} catch (Exception e) {
  26. 				e.printStackTrace();
  27. 			}
  28. 		}
  29. 	}
  30. }

6.Websocket配置

  1. // 导出socket对象
  2. import {getToken} from '@/utils/auth';
  3. export {
  4.     socket
  5. }
  6. import { Message } from 'element-ui'
  7. import {header} from "../../listening/header";
  8. import {asidefriend} from "../../listening/asidefriend";
  9. import {chatbox} from "../../listening/chatbox";
  10. import {chatcontent} from "../../listening/chatcontent";
  11. import {videocalls} from "../../listening/videocalls";
  12. import {voicecalls} from "../../listening/voicecalls";
  13. // socket主要对象
  14. var socket = {
  15.     websock: null,
  16.     ws_url: "ws://localhost:8089/ws",
  17.     /**
  18.      * 开启标识
  19.      * */
  20.     socket_open: false,
  21.     /**
  22.      * 心跳timer
  23.      * */
  24.     hearbeat_timer: null,
  25.     /**
  26.      * 心跳发送频率
  27.      * */
  28.     hearbeat_interval: 5000,
  29.     /**
  30.      * 是否开启重连
  31.      * */
  32.     is_reonnect: true,
  33.     /**
  34.      * 重新连接的次数
  35.      * */
  36.     reconnect_count: 3,
  37.     /**
  38.      * 当前重新连接的次数，默认为：1
  39.      * */
  40.     reconnect_current: 1,
  41.     /**
  42.      * 重新连接的时间类型
  43.      * */
  44.     reconnect_timer: null,
  45.     /**
  46.      * 重新连接的间隔
  47.      * */
  48.     reconnect_interval: 3000,
  49.  
  50.       i : 0,
  51.  
  52.      timer:null,
  53.     /**
  54.      * 初始化连接
  55.      */
  56.     init: () => {
  57.         if (!("WebSocket" in window)) {
  58.             Message({
  59.                 message: '当前浏览器与网站不兼容丫',
  60.                 type: 'error',
  61.             });
  62.             return null
  63.         }
  64.  
  65.         if (socket.websock && socket.websock.readyState===1) {
  66.             return socket.websock
  67.         }
  68.  
  69.         socket.websock = new WebSocket(socket.ws_url)
  70.         //接收消息
  71.         socket.websock.onmessage = function (e) {
  72.             //调用处理消息的方法
  73.             socket.receive(e)
  74.         }
  75.  
  76.         // 关闭连接
  77.         socket.websock.onclose = function (e) {
  78.             clearInterval(socket.hearbeat_interval);
  79.             socket.socket_open = false;
  80.             if (socket.websock!=null){
  81.                 header.getWebsocketStatus(socket.websock.readyState);
  82.             }
  83.             // 需要重新连接
  84.             if (socket.is_reonnect) {
  85.                 socket.reconnect_timer = setTimeout(() => {
  86.                     // 超过重连次数
  87.                     if (socket.reconnect_current > socket.reconnect_count) {
  88.                         clearTimeout(socket.reconnect_timer)
  89.                         return
  90.                     }
  91.                     // 记录重连次数
  92.                     socket.reconnect_current++
  93.                     socket.reconnect()
  94.                 }, socket.reconnect_interval)
  95.             }
  96.         }
  97.  
  98.         // 连接成功
  99.         socket.websock.onopen = function () {
  100.             // Message({
  101.             //     message: '连接成功',
  102.             //     type: 'success',
  103.             // });
  104.             header.getWebsocketStatus(socket.websock.readyState);
  105.             let data = {
  106.                 "action": 10002,
  107.                 "token":getToken(),
  108.                 "chatMsg": null,
  109.                 "extend": 1,
  110.             };
  111.             socket.send(data);
  112.             socket.socket_open = true;
  113.             socket.is_reonnect = true;
  114.             //重修刷新好友内容
  115.             window.dispatchEvent(new CustomEvent('connectInit'));
  116.             // 开启心跳
  117.             socket.heartbeat()
  118.         };
  119.         // 连接发生错误
  120.         socket.websock.onerror = function (err) {
  121.             Message({
  122.                 message: '服务连接发送错误！',
  123.                 type: 'error',
  124.             });
  125.         }
  126.     },
  127.     /**
  128.      * 获取websocket对象
  129.      * */
  130.  
  131.     getSocket:()=>{
  132.         //创建了直接返回，反之重来
  133.         if (socket.websock) {
  134.             return socket.websock
  135.         }else {
  136.             socket.init();
  137.         }
  138.     },
  139.  
  140.     getStatus:()=> {
  141.         if (socket.websock.readyState === 0) {
  142.             return "未连接";
  143.         } else if (socket.websock.readyState === 1) {
  144.             return "已连接";
  145.         } else if (socket.websock.readyState === 2) {
  146.             return "连接正在关闭";
  147.         } else if (socket.websock.readyState === 3) {
  148.             return "连接已关闭";
  149.         }
  150.     },
  151.  
  152.     /**
  153.      * 发送消息
  154.      * @param {*} data 发送数据
  155.      * @param {*} callback 发送后的自定义回调函数
  156.      */
  157.     send: (data, callback = null) => {
  158.         // 开启状态直接发送
  159.         if (socket.websock!=null && socket.websock.readyState === socket.websock.OPEN) {
  160.             try {
  161.                 socket.websock.send(JSON.stringify(data));
  162.             }catch (e) {
  163.                 if (socket.timer !=null){
  164.                     return
  165.                 }
  166.                 socket.timer = setInterval(()=>{
  167.                    if (i>=6){
  168.                        clearInterval(socket.timer);
  169.                        socket.timer = null;
  170.                        socket.i = 0;
  171.                        return
  172.                    }
  173.                   socket.websock.send(JSON.stringify(data));
  174.                     socket.i++;
  175.                },2000)
  176.             }
  177.             if (callback) {
  178.                 callback()
  179.             }
  180.  
  181.             // 正在开启状态，则等待1s后重新调用
  182.         } else if (socket.websock!=null && socket.websock.readyState === socket.websock.CONNECTING) {
  183.             setTimeout(function () {
  184.                 socket.send(data, callback)
  185.             }, 1000)
  186.  
  187.             // 未开启，则等待1s后重新调用
  188.         } else if (socket.websock!=null){
  189.             socket.init();
  190.             setTimeout(function () {
  191.                 socket.send(data, callback)
  192.             }, 1000)
  193.         }
  194.     },
  195.  
  196.     /**
  197.      * 接收消息
  198.      * @param {*} message 接收到的消息
  199.      */
  200.     receive: (message) => {
  201.         var recData = JSON.parse(message.data);
  202.         /**
  203.          *这部分是我们具体的对消息的处理
  204.          * */
  205.            console.log(recData)
  206.         // 自行扩展其他业务处理...
  207.     },
  208.  
  209.     /**
  210.      * 心跳
  211.      */
  212.     heartbeat: () => {
  213.         if (socket.hearbeat_timer) {
  214.             clearInterval(socket.hearbeat_timer)
  215.         }
  216.         socket.hearbeat_timer = setInterval(() => {
  217.             //发送心跳包
  218.             let data = {
  219.                 "action": 10000,
  220.                 "token":getToken(),
  221.                 "chatMsg": null,
  222.                 "extend": null,
  223.             };
  224.             socket.send(data)
  225.         }, socket.hearbeat_interval)
  226.     },
  227.  
  228.     /**
  229.      * 主动关闭连接
  230.      */
  231.     close: () => {
  232.         if (socket.websock==null){
  233.             return
  234.         }
  235.         let data = {
  236.             "action": 10002,
  237.             "token":getToken(),
  238.             "chatMsg": null,
  239.             "extend": 0,
  240.         };
  241.         socket.send(data);
  242.         clearInterval(socket.hearbeat_interval);
  243.         socket.is_reonnect = false;
  244.         socket.websock.close();
  245.         header.getWebsocketStatus(socket.websock.readyState);
  246.         socket.websock=null
  247.     },
  248.  
  249.     /**
  250.      * 重新连接
  251.      */
  252.     reconnect: () => {
  253.         if (socket.websock && socket.socket_open) {
  254.             socket.websock.close()
  255.         }
  256.         socket.init()
  257.     },
  258. }

        说明：通过登入后，在某个全局页面中调用socket.start()即可连接netty服务器，通过socket.send("消息")来发送消息。

三、结束语

        以上就是整个的使用教程，如果报错或者有异常，可以在私信我，看到消息第一时间帮你解决，坚持就是胜利，加油！。

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

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

  

闽ICP备14008679号