Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

uniapp。封装uniapp内置的websocket。并增加可选的:心跳检测、断线重连

  1. User

    uniapp。封装uniapp内置的websocket。并增加可选的:心跳检测、断线重连

  2. Assistant

    在 UniApp 中封装 WebSocket,以便支持心跳检测和断线重连功能,可以通过编写一个模块来实现。以下是一个示例代码,你可以根据需求对其进行修改和扩展。

    class WebSocketClient {
      constructor(url, options = {}) {
        this.url = url;
        this.heartBeatInterval = options.heartBeatInterval || 5000; // 心跳间隔
        this.reconnectInterval = options.reconnectInterval || 5000; // 重连间隔
        this.maxReconnectAttempts = options.maxReconnectAttempts || null; // 最大重连次数
        this.reconnectAttempts = 0;
        this.shouldReconnect = true;
        
        this.ws = null;
        this.heartBeatTimer = null;
    
        this.connect();
      }
    
      connect() {
        this.ws = uni.connectSocket({
          url: this.url,
          complete: () => {}
        });
    
        this.ws.onOpen(() => {
          console.log('WebSocket连接已打开');
          this.reconnectAttempts = 0; // 重置重连尝试计数
          this.startHeartBeat();
        });
    
        this.ws.onMessage((message) => {
          console.log('收到消息:', message.data);
          // 在这里可以添加对消息的处理逻辑
        });
    
        this.ws.onClose(() => {
          console.log('WebSocket连接已关闭');
          this.stopHeartBeat();
          if (this.shouldReconnect && (this.maxReconnectAttempts === null || this.reconnectAttempts < this.maxReconnectAttempts)) {
            this.reconnect();
          }
        });
    
        this.ws.onError((error) => {
          console.error('WebSocket连接错误:', error);
          // 可能的错误处理
        });
      }
    
      startHeartBeat() {
        if (this.heartBeatInterval > 0) {
          this.heartBeatTimer = setInterval(() => {
            if (this.ws && this.ws.readyState === this.ws.OPEN) {
              this.ws.send({
                data: 'ping' // 心跳消息,可以自定义
              });
            }
          }, this.heartBeatInterval);
        }
      }
    
      stopHeartBeat() {
        if (this.heartBeatTimer) {
          clearInterval(this.heartBeatTimer);
        }
      }
    
      reconnect() {
        this.reconnectAttempts++;
        setTimeout(() => {
          this.connect();
        }, this.reconnectInterval);
      }
    
      send(data) {
        if (this.ws && this.ws.readyState === this.ws.OPEN) {
          this.ws.send({
            data: data
          });
        } else {
          console.error('WebSocket连接未打开,无法发送消息');
        }
      }
    
      close() {
        this.shouldReconnect = false;
        if (this.ws) {
          this.ws.close();
        }
      }
    }
    
    export default WebSocketClient;
    

    使用说明

    1. 创建实例

      const wsClient = new WebSocketClient('wss://example.com/socket', {
        heartBeatInterval: 10000, // 心跳检测间隔
        reconnectInterval: 5000, // 断线重连间隔
        maxReconnectAttempts: 5 // 最大重连次数,null 表示无限制
      });
      
    2. 发送消息

      wsClient.send('Hello Server');
      
    3. 关闭连接

      wsClient.close();
      

    这个封装提供了基本的心跳检测和自动重连功能,可以在需要 WebSocket 连接的地方灵活使用。同时可以根据需要扩展功能,比如增加更多的事件处理等。

  3. User

    心跳检测、断线重连是选项

  4. Assistant

    要将心跳检测和断线重连设置为可选功能,我们可以改进之前的封装类,为这两个功能添加配置选项。下面是更新后的代码:

    class WebSocketClient {
      constructor(url, options = {}) {
        this.url = url;
        this.heartBeatInterval = options.heartBeatInterval || 5000; // 心跳间隔
        this.enableHeartBeat = options.enableHeartBeat || false; // 是否启用心跳检测
        this.reconnectInterval = options.reconnectInterval || 5000; // 重连间隔
        this.enableReconnect = options.enableReconnect || false; // 是否启用断线重连
        this.maxReconnectAttempts = options.maxReconnectAttempts || null; // 最大重连次数
        this.reconnectAttempts = 0;
        
        this.ws = null;
        this.heartBeatTimer = null;
        
        this.connect();
      }
    
      connect() {
        this.ws = uni.connectSocket({
          url: this.url,
          complete: () => {}
        });
    
        this.ws.onOpen(() => {
          console.log('WebSocket连接已打开');
          this.reconnectAttempts = 0; // 重置重连尝试计数
          if (this.enableHeartBeat) {
            this.startHeartBeat();
          }
        });
    
        this.ws.onMessage((message) => {
          console.log('收到消息:', message.data);
          // 在这里可以添加对消息的处理逻辑
        });
    
        this.ws.onClose(() => {
          console.log('WebSocket连接已关闭');
          this.stopHeartBeat();
          if (this.enableReconnect && 
              (this.maxReconnectAttempts === null || this.reconnectAttempts < this.maxReconnectAttempts)) {
            this.reconnect();
          }
        });
    
        this.ws.onError((error) => {
          console.error('WebSocket连接错误:', error);
          // 可能的错误处理
        });
      }
    
      startHeartBeat() {
        if (this.heartBeatInterval > 0) {
          this.heartBeatTimer = setInterval(() => {
            if (this.ws && this.ws.readyState === this.ws.OPEN) {
              this.ws.send({
                data: 'ping' // 心跳消息,可以自定义
              });
            }
          }, this.heartBeatInterval);
        }
      }
    
      stopHeartBeat() {
        if (this.heartBeatTimer) {
          clearInterval(this.heartBeatTimer);
        }
      }
    
      reconnect() {
        this.reconnectAttempts++;
        setTimeout(() => {
          this.connect();
        }, this.reconnectInterval);
      }
    
      send(data) {
        if (this.ws && this.ws.readyState === this.ws.OPEN) {
          this.ws.send({
            data: data
          });
        } else {
          console.error('WebSocket连接未打开,无法发送消息');
        }
      }
    
      close() {
        this.enableReconnect = false;
        if (this.ws) {
          this.ws.close();
        }
      }
    }
    
    export default WebSocketClient;
    

    使用说明

    1. 创建实例并启用心跳检测和断线重连

      const wsClient = new WebSocketClient('wss://example.com/socket', {
        enableHeartBeat: true, // 启用心跳检测
        heartBeatInterval: 10000, // 心跳检测间隔
        enableReconnect: true, // 启用断线重连
        reconnectInterval: 5000, // 断线重连间隔
        maxReconnectAttempts: 5 // 最大重连次数,null 表示无限制
      });
      
    2. 发送消息

      wsClient.send('Hello Server');
      
    3. 关闭连接

      wsClient.close();
      

    这样,心跳检测和断线重连都可以作为可选配置项,通过传入相应的选项来控制是否启用这些功能。

  5. User

    可以设置header

  6. Assistant

    为了在建立 WebSocket 连接时设置自定义的 HTTP 头,你可以利用 uni.connectSocket 的 header 选项。header 选项允许你在初始 WebSocket 握手请求中包含额外的 HTTP 头信息。

    下面是更新后的 WebSocketClient 类代码,其中包含了添加自定义头部的功能:

    class WebSocketClient {
      constructor(url, options = {}) {
        this.url = url;
        this.header = options.header || {}; // 自定义HTTP头
        this.heartBeatInterval = options.heartBeatInterval || 5000; // 心跳间隔
        this.enableHeartBeat = options.enableHeartBeat || false; // 是否启用心跳检测
        this.reconnectInterval = options.reconnectInterval || 5000; // 重连间隔
        this.enableReconnect = options.enableReconnect || false; // 是否启用断线重连
        this.maxReconnectAttempts = options.maxReconnectAttempts || null; // 最大重连次数
        this.reconnectAttempts = 0;
        
        this.ws = null;
        this.heartBeatTimer = null;
        
        this.connect();
      }
    
      connect() {
        this.ws = uni.connectSocket({
          url: this.url,
          header: this.header,
          complete: () => {}
        });
    
        this.ws.onOpen(() => {
          console.log('WebSocket连接已打开');
          this.reconnectAttempts = 0; // 重置重连尝试计数
          if (this.enableHeartBeat) {
            this.startHeartBeat();
          }
        });
    
        this.ws.onMessage((message) => {
          console.log('收到消息:', message.data);
          // 在这里可以添加对消息的处理逻辑
        });
    
        this.ws.onClose(() => {
          console.log('WebSocket连接已关闭');
          this.stopHeartBeat();
          if (this.enableReconnect && 
              (this.maxReconnectAttempts === null || this.reconnectAttempts < this.maxReconnectAttempts)) {
            this.reconnect();
          }
        });
    
        this.ws.onError((error) => {
          console.error('WebSocket连接错误:', error);
          // 可能的错误处理
        });
      }
    
      startHeartBeat() {
        if (this.heartBeatInterval > 0) {
          this.heartBeatTimer = setInterval(() => {
            if (this.ws && this.ws.readyState === this.ws.OPEN) {
              this.ws.send({
                data: 'ping' // 心跳消息,可以自定义
              });
            }
          }, this.heartBeatInterval);
        }
      }
    
      stopHeartBeat() {
        if (this.heartBeatTimer) {
          clearInterval(this.heartBeatTimer);
        }
      }
    
      reconnect() {
        this.reconnectAttempts++;
        setTimeout(() => {
          this.connect();
        }, this.reconnectInterval);
      }
    
      send(data) {
        if (this.ws && this.ws.readyState === this.ws.OPEN) {
          this.ws.send({
            data: data
          });
        } else {
          console.error('WebSocket连接未打开,无法发送消息');
        }
      }
    
      close() {
        this.enableReconnect = false;
        if (this.ws) {
          this.ws.close();
        }
      }
    }
    
    export default WebSocketClient;
    

    使用说明

    1. 创建实例并设置自定义头

      const wsClient = new WebSocketClient('wss://example.com/socket', {
        header: {
          'Custom-Header': 'CustomValue', // 自定义HTTP头
        },
        enableHeartBeat: true, // 启用心跳检测
        heartBeatInterval: 10000, // 心跳检测间隔
        enableReconnect: true, // 启用断线重连
        reconnectInterval: 5000, // 断线重连间隔
        maxReconnectAttempts: 5 // 最大重连次数,null 表示无限制
      });
      
    2. 发送消息

      wsClient.send('Hello Server');
      
    3. 关闭连接

      wsClient.close();
      

    通过指定 header 选项,你可以在连接时发送额外的 HTTP 头信息,这在涉及身份验证或其他需要的请求头的场景中通常很有用。

  7. User

    可以修改header

  8. Assistant

    在建立 WebSocket 连接时设置自定义 HTTP 头是一项常用需求,但修改已经建立连接的 HTTP 头是不可能的,因为 HTTP 头仅在 WebSocket 握手阶段发送。所以,如果你想修改这些头部信息,需要关闭当前连接并使用新的头信息重新建立一个新的 WebSocket 连接。

    如果你希望在运行时更新连接头部信息,你可以通过重新实例化 WebSocket 连接来实现。以下是一个示例,展示如何调整代码以实现头部信息的更新:

    class WebSocketClient {
      constructor(url, options = {}) {
        this.url = url;
        this.header = options.header || {}; // 自定义HTTP头
        this.heartBeatInterval = options.heartBeatInterval || 5000; // 心跳间隔
        this.enableHeartBeat = options.enableHeartBeat || false; // 是否启用心跳检测
        this.reconnectInterval = options.reconnectInterval || 5000; // 重连间隔
        this.enableReconnect = options.enableReconnect || false; // 是否启用断线重连
        this.maxReconnectAttempts = options.maxReconnectAttempts || null; // 最大重连次数
        this.reconnectAttempts = 0;
        
        this.ws = null;
        this.heartBeatTimer = null;
        
        this.connect();
      }
    
      connect() {
        this.ws = uni.connectSocket({
          url: this.url,
          header: this.header,
          complete: () => {}
        });
    
        this.ws.onOpen(() => {
          console.log('WebSocket连接已打开');
          this.reconnectAttempts = 0; // 重置重连尝试计数
          if (this.enableHeartBeat) {
            this.startHeartBeat();
          }
        });
    
        this.ws.onMessage((message) => {
          console.log('收到消息:', message.data);
          // 在这里可以添加对消息的处理逻辑
        });
    
        this.ws.onClose(() => {
          console.log('WebSocket连接已关闭');
          this.stopHeartBeat();
          if (this.enableReconnect && 
              (this.maxReconnectAttempts === null || this.reconnectAttempts < this.maxReconnectAttempts)) {
            this.reconnect();
          }
        });
    
        this.ws.onError((error) => {
          console.error('WebSocket连接错误:', error);
          // 可能的错误处理
        });
      }
    
      startHeartBeat() {
        if (this.heartBeatInterval > 0) {
          this.heartBeatTimer = setInterval(() => {
            if (this.ws && this.ws.readyState === this.ws.OPEN) {
              this.ws.send({
                data: 'ping' // 心跳消息,可以自定义
              });
            }
          }, this.heartBeatInterval);
        }
      }
    
      stopHeartBeat() {
        if (this.heartBeatTimer) {
          clearInterval(this.heartBeatTimer);
        }
      }
    
      reconnect() {
        this.reconnectAttempts++;
        setTimeout(() => {
          this.connect();
        }, this.reconnectInterval);
      }
    
      send(data) {
        if (this.ws && this.ws.readyState === this.ws.OPEN) {
          this.ws.send({
            data: data
          });
        } else {
          console.error('WebSocket连接未打开,无法发送消息');
        }
      }
    
      close() {
        this.enableReconnect = false;
        if (this.ws) {
          this.ws.close();
        }
      }
    
      updateHeader(newHeader) {
        this.header = { ...this.header, ...newHeader };
        this.reconnectAttempts = 0; // 重置重连尝试计数
        this.close();
        this.connect();
      }
    }
    
    export default WebSocketClient;
    

    修改和重新连接示例

    1. 创建实例

      const wsClient = new WebSocketClient('wss://example.com/socket', {
        header: {
          'Initial-Header': 'InitialValue',
        },
        enableHeartBeat: true,
        heartBeatInterval: 10000,
        enableReconnect: true,
        reconnectInterval: 5000,
        maxReconnectAttempts: 5
      });
      
    2. 更新头并重新建立连接

      wsClient.updateHeader({
        'New-Header': 'NewValue'
      });
      

    在这种方式下,可以随时更新头信息并重新连接到 WebSocket 服务器。请注意,这将中断当前的 WebSocket 连接,并创建一个新的连接。

  9. User

    uniapp nfc定时读写

  10. Assistant

    在 UniApp 中使用 NFC 功能来实现定时读写,目前需要借助第三方插件或者在特定平台上使用原生能力,因为 UniApp 自身并不直接支持 NFC 功能。对于想要实现定时的 NFC 读写操作,你可能需要结合以下几步来设计:

    1. 使用第三方插件: 找一个支持 NFC 功能的 UniApp 插件,确保该插件能够支持你目标平台(如安卓)的 NFC 读写功能。

    2. 平台差异处理: 确保目标平台(如安卓)支持 NFC 功能,并且设备开启了 NFC 开关。

    3. 创建定时任务: 利用 JavaScript 的 setInterval 来实现定期执行 NFC 读写操作。

    下面是一个简化的示例代码结构,假设你有一个支持 NFC 的插件:

    // 假设插件已经安装,并提供以下接口
    import nfcUtil from '@your-nfc-plugin';
    
    class NFCTask {
      constructor(intervalTime) {
        this.intervalTime = intervalTime || 5000; // 默认间隔5秒
        this.nfcTimer = null;
      }
    
      start() {
        // 检查 NFC 支持
        nfcUtil.isNFCSupported((supported) => {
          if (supported) {
            this.setupInterval();
          } else {
            console.error('NFC不被支持');
          }
        });
      }
    
      setupInterval() {
        this.nfcTimer = setInterval(() => {
          this.readNFC();
          this.writeNFC();
        }, this.intervalTime);
      }
    
      readNFC() {
        nfcUtil.readNFC((data) => {
          console.log('读取到的NFC数据:', data);
          // 处理读取的数据
        }, (error) => {
          console.error('读取NFC出错:', error);
        });
      }
    
      writeNFC() {
        const dataToWrite = { /* 需要写入的数据 */ };
        
        nfcUtil.writeNFC(dataToWrite, () => {
          console.log('写入NFC成功');
        }, (error) => {
          console.error('写入NFC出错:', error);
        });
      }
    
      stop() {
        if (this.nfcTimer) {
          clearInterval(this.nfcTimer);
        }
      }
    }
    
    // 使用示例
    const nfcTask = new NFCTask(10000); // 创建NFC任务,每10秒执行一次
    nfcTask.start();
    
    // 当需要停止任务时
    // nfcTask.stop();
    

    注意事项

    1. 权限和用户提示:在访问 NFC 功能之前,确保获取用户同意,尤其是在 Android 平台上,需要声明相应的权限。

    2. 平台兼容性:在调试阶段,请核对设备和平台是否支持 NFC 功能。

    3. 插件选择:选择成熟的 NFC 插件,并仔细阅读插件的文档,了解如何在 UniApp 中集成和使用。

    4. 应用场景:考虑到 NFC 通信的局限性,应用场景不应对通信速度有太高要求,这类操作适合于简单数据的读写。

    通过了解和选择合适的插件,你可以在 UniApp 应用中实现 NFC 的读写功能,并结合 JavaScript 的定时器功能实现定时操作。