Class DefaultObserver<T>

java.lang.Object
io.reactivex.rxjava3.observers.DefaultObserver<T>
Type Parameters:
T - the value type
All Implemented Interfaces:
Observer<T>
Direct Known Subclasses:
BlockingObservableMostRecent.MostRecentObserver

public abstract class DefaultObserver<T> extends Object implements Observer<T>
Abstract base implementation of an 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!");
         }
     });
 
  • Field Details

  • Constructor Details

    • DefaultObserver

      public DefaultObserver()
  • Method Details

    • onSubscribe

      public final void onSubscribe(@NonNull @NonNull Disposable d)
      Description copied from interface: Observer
      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.
      Specified by:
      onSubscribe in interface Observer<T>
      Parameters:
      d - the Disposable instance whose Disposable.dispose() can be called anytime to cancel the connection
    • cancel

      protected final void cancel()
      Cancels the upstream's disposable.
    • onStart

      protected void onStart()
      Called once the subscription has been set on this observer; override this to perform initialization.