Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

What is the difference between an Observer and a Subscriber?

Tags:

java

rx-java

I am trying to decipher the following function:

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

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.

like image 976
MarcusH Avatar asked Dec 27 '14 04:12

MarcusH


People also ask

What is the difference between an Observable and a subscription?

Both techniques define notification handlers, and use them to process multiple values delivered over time. Subscribing to an observable is equivalent to adding an event listener. One significant difference is that you can configure an observable to transform an event before passing the event to the handler.

Is observer Pub Sub?

In the observer pattern, the source of data itself (the Subject) knows who all are its observers. So, there is no intermediate broker between Subject and Observers. Whereas in pub-sub, the publishers and subscribers are loosely coupled, they are unaware of even the existence of each other.

What is difference between observer and Observable?

Observer : Any object that wishes to be notified when the state of another object changes. Observable : Any object whose state may be of interest, and in whom another object may register an interest.

What does subscribing to an Observable mean?

The Subscribe operator is the glue that connects an observer to an Observable. In order for an observer to see the items being emitted by an Observable, or to receive error or completed notifications from the Observable, it must first subscribe to that Observable with this operator.


2 Answers

EDITED: with @Alrid's comment

tl;dr

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
like image 157
Brice Avatar answered Oct 23 '22 12:10

Brice


(Edit: This is apparently only true of RxJava 1.)

  1. An Observer is an object that can get data from a data source (an Observable). The data source pushes data to it by calling the observer's onNext().

  2. A Subscriber is an Observer that can also unsubscribe from that data source (through the Subscription interface).

  3. The getCar() function is trying to return cars, but there's no direct method to do that. But there is a function to get car details (getCarDetails()) which will call an observer with all the car details. So it calls that function and passes it an observer that, when it gets data, will fetch the car data from the details and pass it on to its own observer.

like image 44
Lawrence Kesteloot Avatar answered Oct 23 '22 11:10

Lawrence Kesteloot