重新连接后是否立即完成Rx.Observable.webSocket（）？

使用

Rx.Observable.webSocket

暴露的

主题时遇到一些问题。虽然WebSocket在
complete
后会重新连接，但对
主题的后续订阅也会立即完成，而不是通过套接字推送下一条消息

我想我遗漏了一些基本的东西，关于这是如何工作的

这里有一个requirebin/paste，我希望它能更好地说明我的意思，以及我所期望的行为。我想这会是一件非常简单的事情，但我忽略了


我最终没有使用Rx.Observable.webSocket，而是选择了一些代码，以便在套接字关闭后重新连接：



const observesesocket=require（'observeble-socket'））
常数Rx=require（'rxjs'）
const EventEmitter=require（'events'）
函数makeobserveLoop（socketEmitter、send、receive）{
socketEmitter.once（'open'，函数onSocketEmit（wSocket）{
const oSocket=可观察到的ocket（wSocket）
const sendSubscription=send.subscribe（msg=>oSocket.next（msg））
oSocket.subscribe(
函数onNext（msg）{
receive.next（msg）
},
函数ONERR（错误）{
错误（err）
sendSubscription.Unsubscripte（）
makeobserveLoop（socketEmitter、send、receive）
},
函数onComplete（）{
sendSubscription.Unsubscripte（）
makeobserveLoop（socketEmitter、send、receive）
}
)
})
}
函数makeSocketLoop（发射器）{
常量websocket=新websocket（'wss://echo.websocket.org')
函数onOpen（）{
emit（'open'，websocket）
setTimeout（函数（）{
websocket.close（）
}, 5000)
}
函数onClose（）{
makeSocketLoop（发射器）
}
websocket.onopen=onopen
websocket.onclose=onclose
}
函数初始化（socketEmitter）{
const_send=新接收对象（）
const_receive=新接收对象（）
makeobserveloop（socketEmitter、\u send、\u receive）
const send=msg=>_send.next（JSON.stringify（msg））
const receive=\u receive.asObservable（）
返回{
发送：发送，
阅读：接收，
}
}
常量发射器=新的EventEmitter（）
makeSocketLoop（发射器）
const theSubjectz=init（发射器）
setInterval（函数（）{
subjectz.send（'echo，你在吗？'））
}, 1000)
subjectz.read.subscribe（函数（el）{
控制台日志（el）
})
另一个简洁的解决方案是在
WebSocketSubject
上使用包装器

class RxWebsocketSubject<T> extends Subject<T> {
  private reconnectionObservable: Observable<number>;
  private wsSubjectConfig: WebSocketSubjectConfig;
  private socket: WebSocketSubject<any>;
  private connectionObserver: Observer<boolean>;
  public connectionStatus: Observable<boolean>;

  defaultResultSelector = (e: MessageEvent) => {
    return JSON.parse(e.data);
  }

  defaultSerializer = (data: any): string => {
    return JSON.stringify(data);
  }

  constructor(
    private url: string,
    private reconnectInterval: number = 5000,
    private reconnectAttempts: number = 10,
    private resultSelector?: (e: MessageEvent) => any,
    private serializer?: (data: any) => string,
    ) {
    super();

    this.connectionStatus = new Observable((observer) => {
      this.connectionObserver = observer;
    }).share().distinctUntilChanged();

    if (!resultSelector) {
      this.resultSelector = this.defaultResultSelector;
    }
    if (!this.serializer) {
      this.serializer = this.defaultSerializer;
    }

    this.wsSubjectConfig = {
      url: url,
      closeObserver: {
        next: (e: CloseEvent) => {
          this.socket = null;
          this.connectionObserver.next(false);
        }
      },
      openObserver: {
        next: (e: Event) => {
          this.connectionObserver.next(true);
        }
      }
    };
    this.connect();
    this.connectionStatus.subscribe((isConnected) => {
      if (!this.reconnectionObservable && typeof(isConnected) == "boolean" && !isConnected) {
        this.reconnect();
      }
    });
  }

  connect(): void {
    this.socket = new WebSocketSubject(this.wsSubjectConfig);
    this.socket.subscribe(
      (m) => {
        this.next(m);
      },
      (error: Event) => {
        if (!this.socket) {
          this.reconnect();
        }
      });
  }

  reconnect(): void {
    this.reconnectionObservable = Observable.interval(this.reconnectInterval)
      .takeWhile((v, index) => {
        return index < this.reconnectAttempts && !this.socket
    });
    this.reconnectionObservable.subscribe(
      () => {
        this.connect();
      },
      null,
      () => {
        this.reconnectionObservable = null;
        if (!this.socket) {
          this.complete();
          this.connectionObserver.complete();
        }
      });
  }

  send(data: any): void {
    this.socket.next(this.serializer(data));
  }
}

RxWebsocketSubject类扩展了Subject{
可观察的私人重新连接：可观察；
私有wsSubjectConfig:WebSocketSubjectConfig；
私有套接字：WebSocketSubject

听起来您可能正在处理热观测与冷观测。
class RxWebsocketSubject<T> extends Subject<T> {
  private reconnectionObservable: Observable<number>;
  private wsSubjectConfig: WebSocketSubjectConfig;
  private socket: WebSocketSubject<any>;
  private connectionObserver: Observer<boolean>;
  public connectionStatus: Observable<boolean>;

  defaultResultSelector = (e: MessageEvent) => {
    return JSON.parse(e.data);
  }

  defaultSerializer = (data: any): string => {
    return JSON.stringify(data);
  }

  constructor(
    private url: string,
    private reconnectInterval: number = 5000,
    private reconnectAttempts: number = 10,
    private resultSelector?: (e: MessageEvent) => any,
    private serializer?: (data: any) => string,
    ) {
    super();

    this.connectionStatus = new Observable((observer) => {
      this.connectionObserver = observer;
    }).share().distinctUntilChanged();

    if (!resultSelector) {
      this.resultSelector = this.defaultResultSelector;
    }
    if (!this.serializer) {
      this.serializer = this.defaultSerializer;
    }

    this.wsSubjectConfig = {
      url: url,
      closeObserver: {
        next: (e: CloseEvent) => {
          this.socket = null;
          this.connectionObserver.next(false);
        }
      },
      openObserver: {
        next: (e: Event) => {
          this.connectionObserver.next(true);
        }
      }
    };
    this.connect();
    this.connectionStatus.subscribe((isConnected) => {
      if (!this.reconnectionObservable && typeof(isConnected) == "boolean" && !isConnected) {
        this.reconnect();
      }
    });
  }

  connect(): void {
    this.socket = new WebSocketSubject(this.wsSubjectConfig);
    this.socket.subscribe(
      (m) => {
        this.next(m);
      },
      (error: Event) => {
        if (!this.socket) {
          this.reconnect();
        }
      });
  }

  reconnect(): void {
    this.reconnectionObservable = Observable.interval(this.reconnectInterval)
      .takeWhile((v, index) => {
        return index < this.reconnectAttempts && !this.socket
    });
    this.reconnectionObservable.subscribe(
      () => {
        this.connect();
      },
      null,
      () => {
        this.reconnectionObservable = null;
        if (!this.socket) {
          this.complete();
          this.connectionObserver.complete();
        }
      });
  }

  send(data: any): void {
    this.socket.next(this.serializer(data));
  }
}