What is the difference between an Observer and a Subscriber?

By | July 15, 2019


I am trying to decipher the following function:

Subscription getCar(id, Observer<Car> observer) {
    return getCarDetails(id, new Observer<CarDetails> {
                             onNext(CarDetails details) {           
                             } });

I got a good intro to rxjava from http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/ but it only mentioned Observer in passing, saying you’ll be using Subscriber most of the time to consumer items emitted from an Observable.

Can someone explain to me

  1. What is an observer?
  2. How is an observer different than a subscriber?
  3. What does the above code snippet do?

Javadoc made it seem just like a subscriber. The javadoc for subscriber says it implements observer and subscription. I am very confused.


EDITED: with @Alrid’s comment


public abstract class Subscriber<T> implements Observer<T>, Subscription

So a Subscriber is an implementation of the Observer, with additional semantics on subscription (it’s more about un-subscription).
The code in your question just shows that it passes the Observer interface, instead of the implementation (usual programming practice).

Also this code returns a Subscription, that may be because the author of this code thought that the client should only have access to Subscription methods, without access to elements produced by the observable. That may be a programmer error.

long story

Really you should read the content of this website (or book) : http://www.introtorx.com
It is about Rx.Net, but the concepts are the very same, they were created by Erik Meijer and RxJava implementors followed them (if applicable to the Java language).

This page will interest you (it is the second chapter) : KeyTypes

Here you’ll read in the first paragraphs :

There are two key types to understand when working with Rx, and a subset of auxiliary types that will help you to learn Rx more effectively. The IObserver and IObservable form the fundamental building blocks for Rx, while implementations of ISubject reduce the learning curve for developers new to Rx.

Essentially Rx is built upon the foundations of the Observer pattern. .NET already exposes some other ways to implement the Observer pattern such as multicast delegates or events (which are usually multicast delegates).

Even if types / API are a bit different, you will learn a lot with this book, probably way more than with some blogs.

What this book do not say (…because it is in the RxJava implementation)

RxJava main developer at this time introduced a slight variation (see PR #792) that allowed to distinguish two types of contracts :

  • notification -> Observer
  • (un)subscription -> Subscription

This change allowed to better express/split these concerns of the implementing classes of the RxJava library.

However as a library user, using actual implementations of the RxJava library should be good enough.

Implementing a subscriber require much more knowledge, work and care, indeed the subscription semantics are very important depending on the type of the source observable (Hot or cold? Expensive to create ?)

Exposing Subscriber rather than Observer in cases such as above will not interfere with the code in in most cases, but it is not the intended use for it unless those un-subscription semantics are needed. But in the end implementing a Subscriber, and may involve to fall in some pitfalls such as :

  1. spend resources for functionality you will not use
  2. cannot inherit from another class
  3. write incorrect un-subscription code
  4. copy/paste code an incorrect code or correct code written for a different context

Rate this post

Leave a Reply

Your email address will not be published. Required fields are marked *