Rx java 我可以跟踪RxJava订阅服务器中事件的消耗吗？

我想跟踪订阅服务器何时开始使用事件以及何时完成。

---

是否有任何通用方法适用于所有可观察对象/订阅者？

是适用于1.x还是2.x？对于2.x，它可能变得非常复杂，因为必须考虑所有内部协议，以避免意外地对流进行去优化

否则，它可以简单地编写一个

观察者

，在真实的

观察者

和操作员之间填充：

import io.reactivex.Observer;

RxJavaPlugins.setOnObservableSubscribe((observable, observer) -> {
    if (!observable.getClass().getName().toLowerCase().contains("map")) {
        return observer;
    }

    System.out.println("Started");

    class SignalTracker implements Observer<Object>, Disposable {
        Disposable upstream;
        @Override public void onSubscribe(Disposable d) {
            upstream = d;
            // write the code here that has to react to establishing the subscription
            observer.onSubscribe(this);
        }
        @Override public void onNext(Object o) {
            // handle onNext before or aftern notifying the downstream
            observer.onNext(o);
        }
        @Override public void onError(Throwable t) {
            // handle onError
            observer.onError(t);
        }
        @Override public void onComplete() {
            // handle onComplete
            System.out.println("Completed");
            observer.onComplete();
        }
        @Override public void dispose() {
            // handle dispose
            upstream.dispose();
        }
        @Override public boolean isDisposed() {
            return upstream.isDisposed();
        }
    }
    return new SignalTracker();
  });

  Observable<Integer> observable = Observable.range(1, 5)
      .subscribeOn(Schedulers.io())
      .observeOn(Schedulers.computation())
      .map(integer -> {
        try {
          TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        return integer * 3;
      });

  observable.subscribe(System.out::println);

  Thread.sleep(6000L);

编辑：RxJava 1版本需要更多的lambdas，但可行：

RxJavaHooks.setOnObservableStart((observable, onSubscribe) -> {
    if (!onSubscribe.getClass().getName().toLowerCase().contains("map")) {
        return onSubscribe;
    }

    System.out.println("Started");

    return (Observable.OnSubscribe<Object>)observer -> {
        class SignalTracker extends Subscriber<Object> {
            @Override public void onNext(Object o) {
                // handle onNext before or aftern notifying the downstream
                observer.onNext(o);
            }
            @Override public void onError(Throwable t) {
                // handle onError
                observer.onError(t);
            }
            @Override public void onCompleted() {
                // handle onComplete
                System.out.println("Completed");
                observer.onCompleted();
            }
            @Override public void setProducer(Producer p) {
                observer.setProducer(p);
            }
        }
        SignalTracker t = new SignalTracker()
        observer.add(t);
        onSubscribe.call(t);
    };
  });

  Observable<Integer> observable = Observable.range(1, 5)
      .subscribeOn(Schedulers.io())
      .observeOn(Schedulers.computation())
      .map(integer -> {
        try {
          TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        return integer * 3;
      });

  observable.subscribe(System.out::println);

  Thread.sleep(6000L);

RxJavaHooks.setOnObservableStart（（可观察，onSubscribe）->{
如果（！onSubscribe.getClass（）.getName（）.toLowerCase（）包含（“映射”））{
认购回报；
}
System.out.println（“已启动”）；
返回（可观察的。订阅的）观察者->{
类SignalTracker扩展了订阅服务器{
@覆盖公共void onNext（对象o）{
//在通知下游之前或之后处理onNext
观察员onNext（o）；
}
@覆盖公共无效onError（可丢弃的t）{
//处理一个错误
观察员：onError（t）；
}
@覆盖已完成的公共void（）{
//未完成的处理
系统输出打印项次（“完成”）；
observer.onCompleted（）；
}
@覆盖公共无效setProducer（Producer p）{
观察员：setProducer（p）；
}
}
SignalTracker t=新的SignalTracker（）
加（t）；
认购电话（t）；
};
});
可观察=可观察范围（1,5）
.subscribeOn（Schedulers.io（））
.observeOn（Schedulers.computation（））
.map（整数->{
试一试{
时间单位。秒。睡眠（1）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
返回整数*3；
});
订阅（System.out:：println）；
线程。睡眠（6000L）；

是1.x版还是2.x版？对于2.x，它可能变得非常复杂，因为必须考虑所有内部协议，以避免意外地对流进行去优化

否则，它可以简单地编写一个

观察者

，在真实的

观察者

和操作员之间填充：

import io.reactivex.Observer;

RxJavaPlugins.setOnObservableSubscribe((observable, observer) -> {
    if (!observable.getClass().getName().toLowerCase().contains("map")) {
        return observer;
    }

    System.out.println("Started");

    class SignalTracker implements Observer<Object>, Disposable {
        Disposable upstream;
        @Override public void onSubscribe(Disposable d) {
            upstream = d;
            // write the code here that has to react to establishing the subscription
            observer.onSubscribe(this);
        }
        @Override public void onNext(Object o) {
            // handle onNext before or aftern notifying the downstream
            observer.onNext(o);
        }
        @Override public void onError(Throwable t) {
            // handle onError
            observer.onError(t);
        }
        @Override public void onComplete() {
            // handle onComplete
            System.out.println("Completed");
            observer.onComplete();
        }
        @Override public void dispose() {
            // handle dispose
            upstream.dispose();
        }
        @Override public boolean isDisposed() {
            return upstream.isDisposed();
        }
    }
    return new SignalTracker();
  });

  Observable<Integer> observable = Observable.range(1, 5)
      .subscribeOn(Schedulers.io())
      .observeOn(Schedulers.computation())
      .map(integer -> {
        try {
          TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        return integer * 3;
      });

  observable.subscribe(System.out::println);

  Thread.sleep(6000L);

编辑：RxJava 1版本需要更多的lambdas，但可行：

RxJavaHooks.setOnObservableStart((observable, onSubscribe) -> {
    if (!onSubscribe.getClass().getName().toLowerCase().contains("map")) {
        return onSubscribe;
    }

    System.out.println("Started");

    return (Observable.OnSubscribe<Object>)observer -> {
        class SignalTracker extends Subscriber<Object> {
            @Override public void onNext(Object o) {
                // handle onNext before or aftern notifying the downstream
                observer.onNext(o);
            }
            @Override public void onError(Throwable t) {
                // handle onError
                observer.onError(t);
            }
            @Override public void onCompleted() {
                // handle onComplete
                System.out.println("Completed");
                observer.onCompleted();
            }
            @Override public void setProducer(Producer p) {
                observer.setProducer(p);
            }
        }
        SignalTracker t = new SignalTracker()
        observer.add(t);
        onSubscribe.call(t);
    };
  });

  Observable<Integer> observable = Observable.range(1, 5)
      .subscribeOn(Schedulers.io())
      .observeOn(Schedulers.computation())
      .map(integer -> {
        try {
          TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        return integer * 3;
      });

  observable.subscribe(System.out::println);

  Thread.sleep(6000L);

RxJavaHooks.setOnObservableStart（（可观察，onSubscribe）->{
如果（！onSubscribe.getClass（）.getName（）.toLowerCase（）包含（“映射”））{
认购回报；
}
System.out.println（“已启动”）；
返回（可观察的。订阅的）观察者->{
类SignalTracker扩展了订阅服务器{
@覆盖公共void onNext（对象o）{
//在通知下游之前或之后处理onNext
观察员onNext（o）；
}
@覆盖公共无效onError（可丢弃的t）{
//处理一个错误
观察员：onError（t）；
}
@覆盖已完成的公共void（）{
//未完成的处理
系统输出打印项次（“完成”）；
observer.onCompleted（）；
}
@覆盖公共无效setProducer（Producer p）{
观察员：setProducer（p）；
}
}
SignalTracker t=新的SignalTracker（）
加（t）；
认购电话（t）；
};
});
可观察=可观察范围（1,5）
.subscribeOn（Schedulers.io（））
.observeOn（Schedulers.computation（））
.map（整数->{
试一试{
时间单位。秒。睡眠（1）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
返回整数*3；
});
订阅（System.out:：println）；
线程。睡眠（6000L）；

有一个

onSubscribe（一次性）

方法将在可观察到的开始发出事件后调用。当调用onComplete（）/

onError

意味着它被终止。谢谢，但我正在寻找像RxJavaHooks这样的通用解决方案。所以我不需要访问每个可观察的对象。在当前jvm实例中，它应该像间谍一样工作。你可以在RxJavaPlugin中使用

setOnObservableSubscribe

。对不起，我不太明白如何使用它。此挂钩仅适用于“订阅”事件。我需要跟踪订户何时开始使用事件以及何时完成。一旦可观察到开始发出事件，将调用

onSubscribe（一次性）

方法。当调用onComplete（）/

onError

意味着它被终止。谢谢，但我正在寻找像RxJavaHooks这样的通用解决方案。所以我不需要访问每个可观察的对象。在当前jvm实例中，它应该像间谍一样工作。你可以在RxJavaPlugin中使用

setOnObservableSubscribe

。对不起，我不太明白如何使用它。此挂钩仅适用于“订阅”事件。我需要跟踪订户何时开始使用事件以及何时完成。我在描述中添加了示例。此解决方案不适用于它。“已完成”在订阅者完成所有事件的处理之前打印。钩子将跟踪添加到所有操作符：range、subscribeOn、observeOn、map，因此您得到了4个“开始”。另外，如果你睡6秒钟，你可以看到4秒完成。@smalafeev这正是我告诉你需要为你的可观察状态设置条件的原因。每个操作符都将从中生成一个新的可观察对象，例如：ObservaleMap。您的上游可观察到已收到未完成事件，但您的下游尚未收到。所以你看到了地图前面的未完成部分。现在我有一个问题要建立一个链。我找不到生成的观测值之间的关系。我在描述中添加了示例。此解决方案不适用于它。“已完成”在订阅者完成所有事件的处理之前打印。t