myWebSocketSubject.multiplex（..）.subscribe（）.unsubscribe（）关闭连接，事件存在

以下代码将关闭连接，myWebSocketSubject上存在其他事件观察者：

myWebSocketSubject.Observable.webSocket('ws://mysocket');
myWebSocketSubject.subscribe();
myWebSocketSubject.multiplex(..).subscribe().unsubscribe()
// the connection closed now

我的期望是，最后一次unsubscribe（）调用（而不是第一次）会关闭连接

用例

如果我做对了，使用

multiplex（..）

操作符，在创建并完成时，会向套接字发送一条消息，例如，允许在服务器端取消订阅特定事件

因此，我首选的Web套接字服务可能如下所示。只有一个连接，这个连接提供多个流。在首次订阅web套接字时，将创建连接；最后一次取消订阅呼叫时，连接关闭。对于每个数据流，发送一次un-/subscribe消息

我还没有找到使用

WebSocketSubject.multiplex（..）

方法的解决方案

首选示例Web套接字服务

export class WebSocketService {
    connection: WebSocketSubject<any>;
    constructor() {
        this.connection = Observable.webSocket<any>(_createConfig())
    }

    dataStream(eventType: string): Observable<WebSocketMessage> {
        return connection.multiplex(
            () => new WebSocketMessage("WebSocket.Subscribe." + eventType),
            () => new WebSocketMessage("WebSocket.Unsubscribe." + eventType),
            message => (message.type == eventType)
        )
        .retry() // reconnect on error and send subscription messages again
        .share(); // send messages on last/fist un-/subscribe on this stream
    }
    // ...
}

export class WebSocketMessage {
    type: string;
    data: any;
    constructor(command: string, data?:any) {
        this.type = command;
        this.data = data || undefined;
    }
}

导出类WebSocketService{
连接：WebSocketSubject；
构造函数（）{
this.connection=Observable.webSocket（_createConfig（））
}
数据流（eventType:string）：可观察{
多路复用回路连接(
（）=>新的WebSocketMessage（“WebSocket.Subscribe.+eventType），
（）=>新WebSocket消息（“WebSocket.Unsubscribe.”+eventType），
message=>（message.type==eventType）
)
.retry（）//出现错误时重新连接并再次发送订阅消息
.share（）；//在最后一次/第一次取消/订阅此流时发送消息
}
// ...
}
导出类WebSocketMessage{
类型：字符串；
资料：有；
构造函数（命令：字符串，数据？：任意）{
this.type=命令；
this.data=数据| |未定义；
}
}

我已经编写了以下失败的测试用例

it('should able to handle multiple subscriptions', () => {
      const subject = Observable.webSocket(<any>{url: 'ws://mysocket'});
      const sub1 = subject.subscribe();
      const sub2 = subject.subscribe();

      const socket = MockWebSocket.lastSocket;
      socket.open();

      sinon.spy(socket, 'close');

      sub1.unsubscribe();
      // Fails, because the socket gets closed on first unsubscribe
      expect(socket.close).have.not.been.called;

      sub2.unsubscribe();
      expect(socket.close).have.been.called;
    });

it（'应该能够处理多个订阅'，（）=>{
const subject=Observable.webSocket（{url:'ws://mysocket'}）；
const sub1=subject.subscribe（）；
const sub2=subject.subscribe（）；
const socket=MockWebSocket.lastSocket；
socket.open（）；
sinon.spy（套接字，'close'）；
sub1.取消订阅（）；
//失败，因为套接字在第一次取消订阅时关闭
expect（socket.close）.have.not.been.called；
sub2.取消订阅（）；
expect（socket.close）.have.been.called；
});

如果我做对了，

share

操作员会做这件事。但在使用该运算符后，无法使用多路复用方法

感谢您的反馈、意见和建议