zmdms-utils 0.0.81 → 0.0.83

package/src/stompClient.ts

@@ -1,449 +0,0 @@
-import Stomp from "zt-stompjs";
-import SockJS from "zt-sockjs-client";
-import { getToken } from "./auth";
-
-// 连接ws需要的参数
-interface IConnectWsConfig {
-  baseUrl: string; // ws基础url
-  userId: string; // 用户id
-  clientType: string | number; // 客户端类型
-  systemType?: string; // 系统类型
-  token?: string; // token
-  debug?: boolean; // 是否开启debug
-  heartbeat?: {
-    outgoing?: number; // 客户端将每10000ms发送一次心跳
-    incoming?: number; // 客户端不希望从服务器接收心跳
-  };
-  reconnectionTime?: number; // 重连耗时
-}
-
-type IConnectSuccessCallback = () => void;
-type IConnectErrorCallback = (err: any) => void;
-
-class StompClient {
-  static getInstance: (connectWsConfig?: IConnectWsConfig) => StompClient; // 静态属性，作为单例模式返回调用的方法
-  connectWsConfig: IConnectWsConfig;
-  client: any;
-
-  isClient: any = false; // 是否连接上了
-  clearIsClient: any = null;
-  clearIsClientNo: any = null; // 连接10秒内未建立，重新连接
-  clearIsClientYes: any = null; // 连接已建立重新连接
-
-  subscriptions: any = {}; // 连接通道的返回值存储对象
-  subscriptionsFn: any = {}; // 连接通道的函数存储对象
-
-  successCallbacks: any = {}; // 连接成功执行的回调存储对象
-  errorCallbacks: any = {}; // 连接失败执行的回调存储对象
-
-  reconnectionNum: number = 0; // 重连次数
-  reconnectiontime: number = 5000; // 重连时间
-  maxReconnectiontime: number = 60000; // 最大重连时间 60s
-
-  userClose: boolean = false; // 是否用户主动关闭
-
-  isInit: boolean = false;
-  constructor(connectWsConfig: IConnectWsConfig) {
-    this.connectWsConfig = connectWsConfig;
-  }
-
-  // 连接初始化
-  init() {
-    this.isInit = true;
-    const token = this.connectWsConfig.token || getToken();
-    // 建立连接对象，还未发起连接
-    const socket = new SockJS(
-      `${this.connectWsConfig.baseUrl}/api/zmdms-csc-ztim/ws?token=${token}&system=${this.connectWsConfig.systemType}&clientType=${this.connectWsConfig.clientType}`
-    );
-    // 获取 STOMP 子协议的客户端对象
-    this.client = Stomp.over(socket);
-    this.isClient = false;
-    if (!this.subscriptions) {
-      this.subscriptions = {};
-    }
-    if (!this.subscriptionsFn) {
-      this.subscriptionsFn = {};
-    }
-    if (!this.successCallbacks) {
-      this.successCallbacks = {};
-    }
-    if (!this.errorCallbacks) {
-      this.errorCallbacks = {};
-    }
-
-    // 如果存在 证明已经初始化过，直接删除
-    if (this.clearIsClient) {
-      clearTimeout(this.clearIsClient);
-      this.clearIsClient = null;
-    }
-    if (this.clearIsClientNo) {
-      clearTimeout(this.clearIsClientNo);
-      this.clearIsClientNo = null;
-    }
-    if (this.clearIsClientYes) {
-      clearTimeout(this.clearIsClientYes);
-      this.clearIsClientYes = null;
-    }
-    this.clearIsClient = setTimeout(() => {
-      this.clearIsClient = null;
-      if (!this.isClient) {
-        console.log(
-          `连接已发起，但是10秒后未成功建立连接，手动断开重连!system=${this.connectWsConfig.systemType}`
-        );
-        try {
-          this.client.disconnect(() => {
-            this.client = null;
-          });
-        } catch (err) {
-          console.log("---连接未建立的关闭出错---", err);
-        }
-        this.reconnectionNum++;
-        const timeInterval = this.getReconnectionTime();
-        console.log(
-          `---第${this.reconnectionNum}次重连！time=${Date.now()}system=${
-            this.connectWsConfig.systemType
-          }---`
-        );
-        if (this.clearIsClientNo) {
-          clearTimeout(this.clearIsClientNo);
-          this.clearIsClientNo = null;
-        }
-        this.clearIsClientNo = setTimeout(
-          () => {
-            this.init();
-          },
-          timeInterval > this.maxReconnectiontime
-            ? this.maxReconnectiontime
-            : timeInterval
-        );
-      }
-    }, 10000);
-
-    // 拦截输出的一大堆垃圾信息
-    this.client.debug = null;
-    // if (this.connectWsConfig.debug) {
-    //   this.client.debug = (str: string) => {
-    //     if (this.connectWsConfig.debug) {
-    //       console.log(str);
-    //     }
-    //   };
-    // }
-
-    // 心跳检测 stompjs 底层使用window.setInterval() 定期发送心跳检测
-    this.client.heartbeat.outgoing =
-      this.connectWsConfig.heartbeat?.outgoing ?? 2000; // 客户端将每2000ms发送一次心跳
-    this.client.heartbeat.incoming =
-      this.connectWsConfig.heartbeat?.incoming ?? 2000; // 客户端不希望从服务器接收心跳
-
-    this.client.connect(
-      {},
-      // 连接成功回调
-      () => {
-        this.isClient = true;
-        if (this.clearIsClient) {
-          clearTimeout(this.clearIsClient);
-          this.clearIsClient = null;
-        }
-        if (this.clearIsClientNo) {
-          clearTimeout(this.clearIsClientNo);
-          this.clearIsClientNo = null;
-        }
-        if (this.clearIsClientYes) {
-          clearTimeout(this.clearIsClientYes);
-          this.clearIsClientYes = null;
-        }
-        this.reconnectionNum = 0;
-        console.log(
-          `---------连接成功 time=${Date.now()} system=${
-            this.connectWsConfig.systemType
-          } time=${Date.now()}--------`
-        );
-        this.executeSubscribe();
-      },
-      // 连接失败回调
-      (err: any) => {
-        console.log(
-          `---------连接失败 system=${
-            this.connectWsConfig.systemType
-          } time=${Date.now()}--------`
-        );
-        console.log(err);
-        if (this.userClose) {
-          this.userClose = false; // 重新初始化 重新计算
-          if (this.clearIsClient) {
-            clearTimeout(this.clearIsClient);
-            this.clearIsClient = null;
-          }
-          if (this.clearIsClientNo) {
-            clearTimeout(this.clearIsClientNo);
-            this.clearIsClientNo = null;
-          }
-          if (this.clearIsClientYes) {
-            clearTimeout(this.clearIsClientYes);
-            this.clearIsClientYes = null;
-          }
-          // 连接失败后，将所有注册过的订阅、回调执行状态置为未执行状态。
-          this.setExecuteFail();
-          console.log("用户主动关闭");
-          return;
-        }
-        this.isClient = true;
-        if (this.clearIsClient) {
-          clearTimeout(this.clearIsClient);
-          this.clearIsClient = null;
-        }
-        if (this.clearIsClientNo) {
-          clearTimeout(this.clearIsClientNo);
-          this.clearIsClientNo = null;
-        }
-        if (this.clearIsClientYes) {
-          clearTimeout(this.clearIsClientYes);
-          this.clearIsClientYes = null;
-        }
-        // 连接失败后，将所有注册过的订阅、回调执行状态置为未执行状态。
-        this.setExecuteFail();
-        // 重连逻辑, 默认3秒后重连
-        // 重连间隔，每隔5秒递增，超过最大间隔时间后，取最大间隔时间重连
-        try {
-          this.client.disconnect(() => {
-            this.client = null;
-          });
-        } catch (err) {
-          console.log(
-            `---连接已建立的关闭出错 time=${Date.now()}system=${
-              this.connectWsConfig.systemType
-            }---`,
-            err
-          );
-        }
-        this.reconnectionNum++;
-        const timeInterval = this.getReconnectionTime();
-        console.log(
-          `---第${this.reconnectionNum}次重连！time=${Date.now()}system=${
-            this.connectWsConfig.systemType
-          }`
-        );
-        this.clearIsClientYes = setTimeout(
-          () => {
-            this.init();
-          },
-          timeInterval > this.maxReconnectiontime
-            ? this.maxReconnectiontime
-            : timeInterval
-        );
-      }
-    );
-  }
-
-  /**
-   * 连接失败后，将所有注册过的订阅、回调执行状态置为未执行状态。
-   * @param isExecute 连接通道、回调的执行状态
-   */
-  setExecuteFail() {
-    // 连接失败后，将当前已注册的 连接通道 全部置为未执行状态
-    const subscriptionsFnKeys = Object.keys(this.subscriptionsFn);
-    if (Array.isArray(subscriptionsFnKeys)) {
-      subscriptionsFnKeys.forEach((key) => {
-        this.subscriptionsFn[key].isExecute = false;
-      });
-    }
-    // 连接失败后，统一执行连接失败函数
-    const errorCallbackKeys = Object.keys(this.errorCallbacks);
-    if (Array.isArray(errorCallbackKeys)) {
-      errorCallbackKeys.forEach((key) => {
-        const { isExecute, callback } = this.errorCallbacks[key];
-        if (!isExecute) {
-          callback && callback();
-        }
-        this.errorCallbacks[key].isExecute = true;
-      });
-    }
-    // 将成功回调 的执行状态 重置为未执行状态
-    const successCallbackKeys = Object.keys(this.successCallbacks);
-    if (Array.isArray(successCallbackKeys)) {
-      successCallbackKeys.forEach((key) => {
-        this.successCallbacks[key].isExecute = false;
-      });
-    }
-  }
-
-  /**
-   * 连接成功后，需要将当前已注册的，未执行的连接通道重新执行连接
-   * 还有成功回调
-   * 失败回调的执行状态重置为未执行状态
-   * @returns 执行订阅相关回调
-   */
-  executeSubscribe() {
-    // 连接成功后，将当前已注册的，未执行的 连接通道 连接
-    const subscriptionsFnKeys = Object.keys(this.subscriptionsFn);
-    if (Array.isArray(subscriptionsFnKeys)) {
-      subscriptionsFnKeys.forEach((key) => {
-        const { isExecute, subscriptionsFn } = this.subscriptionsFn[key];
-        if (!isExecute) {
-          subscriptionsFn?.();
-          this.subscriptionsFn[key].isExecute = true;
-        }
-      });
-    }
-    // 连接成功后，统一执行连接成功函数
-    const successCallbackKeys = Object.keys(this.successCallbacks);
-    if (Array.isArray(successCallbackKeys)) {
-      successCallbackKeys.forEach((key) => {
-        const { isExecute, callback } = this.successCallbacks[key];
-        if (!isExecute) {
-          callback && callback();
-        }
-        this.successCallbacks[key].isExecute = true;
-      });
-    }
-    // 将失败回调 的执行状态 重置为未执行状态
-    const errorCallbackKeys = Object.keys(this.errorCallbacks);
-    if (Array.isArray(errorCallbackKeys)) {
-      errorCallbackKeys.forEach((key) => {
-        this.errorCallbacks[key].isExecute = false;
-      });
-    }
-  }
-
-  // 重连时间计算
-  getReconnectionTime() {
-    const timeInterval =
-      Math.ceil(this.reconnectionNum / 5) *
-      (this.connectWsConfig.reconnectionTime ?? this.reconnectiontime);
-    return timeInterval;
-  }
-
-  // 订阅连接成功回调
-  subscribeSuccessCall(subscribeId: string, callback: () => void) {
-    this.successCallbacks[subscribeId] = {
-      isExecute: false,
-      callback,
-    };
-  }
-
-  // 订阅连接失败回调
-  subscribeErrorCall(subscribeId: string, callback: () => void) {
-    this.errorCallbacks[subscribeId] = {
-      isExecute: false,
-      callback,
-    };
-  }
-
-  // 订阅通道逻辑
-  subscribe(
-    subscribeId: string,
-    pipe: string,
-    callback?: (response: any) => void,
-    headers?: any
-  ) {
-    // 兼容不传callback 的方案
-    if (typeof callback !== "function") {
-      headers = callback;
-      callback = undefined;
-    }
-    let subscriptionsFn = () => {
-      if (this.client) {
-        let subscription = this.client.subscribe(
-          pipe,
-          (response: any) => {
-            callback && callback(response);
-          },
-          headers
-        );
-        this.subscriptions[subscribeId] = subscription;
-      }
-    };
-    if (this.client?.connected) {
-      // 如果是连接状态 正常执行函数
-      subscriptionsFn();
-      // 是否已执行
-      this.subscriptionsFn[subscribeId] = {
-        isExecute: true,
-        subscriptionsFn,
-      };
-    } else {
-      // 缓存连接函数
-      this.subscriptionsFn[subscribeId] = {
-        isExecute: false,
-        subscriptionsFn,
-      };
-    }
-  }
-
-  getSubscriptions(key: any) {
-    const subscriptionKey = this.subscriptions[key];
-    Reflect.deleteProperty(this.subscriptions, key);
-    Reflect.deleteProperty(this.subscriptionsFn, key);
-    return subscriptionKey;
-  }
-
-  // 关闭连接逻辑
-  disconnect(callback: () => void) {
-    this.isInit = false;
-    this.userClose = true;
-    this.subscriptions = null;
-    this.subscriptionsFn = null;
-    this.successCallbacks = null;
-    this.errorCallbacks = null;
-    return new Promise((resolve, reject) => {
-      try {
-        this.client.disconnect(() => {
-          this.client = null;
-          callback && callback();
-          resolve(null);
-        });
-      } catch (err) {
-        callback && callback();
-        resolve(null);
-      }
-    });
-  }
-
-  // 手动重新连接
-  reconnect() {
-    this.isInit = false;
-    this.userClose = true;
-    return new Promise((resolve, reject) => {
-      try {
-        this.setExecuteFail();
-        this.client.disconnect(() => {
-          this.client = null;
-          resolve(null);
-        });
-        setTimeout(() => {
-          this.userClose = false;
-          this.init();
-        }, 400);
-      } catch (err) {
-        resolve(null);
-      }
-    });
-  }
-
-  // 发送消息
-  send(pipe: string, headers: object, message: string) {
-    if (typeof headers === "string") {
-      message = headers;
-      headers = {};
-    }
-    this.client.send(pipe, headers, message);
-  }
-}
-
-StompClient.getInstance = (function () {
-  let instance: StompClient;
-  return function (connectWsConfig?: IConnectWsConfig) {
-    if (!instance && connectWsConfig) {
-      instance = new StompClient(connectWsConfig);
-      // ws 初始化
-      instance.init();
-    }
-    // 如果没有初始化，那么初始化一下
-    if (instance && !instance.isInit) {
-      instance.init();
-    }
-    return instance;
-  };
-})();
-
-export default StompClient;