zmdms-utils 0.0.80 → 0.0.81

package/src/stompClient.ts

@@ -0,0 +1,449 @@
+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;

package/tsconfig.json

@@ -28,5 +28,5 @@
     "jsx": "react-jsx",
     "outDir": "dist"
   },
-  "include": ["src"]
+  "include": ["src", "declarations.d.ts"]
 }