T - the value typepublic abstract class DefaultObserver<T> extends Object implements Observer<T>
Observer with support for cancelling a
subscription via cancel() (synchronously) and calls onStart()
when the subscription happens.
All pre-implemented final methods are thread-safe.
Use the protected cancel() to dispose the sequence from within an
onNext implementation.
Like all other consumers, DefaultObserver can be subscribed only once.
Any subsequent attempt to subscribe it to a new source will yield an
IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.".
Implementation of onStart(), Observer.onNext(Object), Observer.onError(Throwable)
and Observer.onComplete() are not allowed to throw any unchecked exceptions.
If for some reason this can't be avoided, use Observable.safeSubscribe(io.reactivex.rxjava3.core.Observer)
instead of the standard subscribe() method.
Example
Observable.range(1, 5)
.subscribe(new DefaultObserver<Integer>() {
@Override public void onStart() {
System.out.println("Start!");
}
@Override public void onNext(Integer t) {
if (t == 3) {
cancel();
}
System.out.println(t);
}
@Override public void onError(Throwable t) {
t.printStackTrace();
}
@Override public void onComplete() {
System.out.println("Done!");
}
});
| Constructor and Description |
|---|
DefaultObserver () |
| Modifier and Type | Method and Description |
|---|---|
protected void |
cancel ()
Cancels the upstream's disposable.
|
protected void |
onStart ()
Called once the subscription has been set on this observer; override this
to perform initialization.
|
void |
onSubscribe (@NonNull Disposable d)
Provides the
Observer with the means of cancelling (disposing) the
connection (channel) with the Observable in both
synchronous (from within Observer.onNext(Object)) and asynchronous manner. |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait onComplete, onError, onNext public DefaultObserver()
public final void onSubscribe(@NonNull @NonNull Disposable d)
Observer Observer with the means of cancelling (disposing) the
connection (channel) with the Observable in both
synchronous (from within Observer.onNext(Object)) and asynchronous manner.onSubscribe in interface Observer<T>d - the Disposable instance whose Disposable.dispose() can
be called anytime to cancel the connectionprotected final void cancel()
protected void onStart()