Observer Pattern (Publisher-Subscriber Pattern)

Code Structure

Code Example

Click here to expand...

Create Publisher and Subscriber interfaces

public interface Subscriber<T> {
    void notify(T t);
	void unsubscribe();
}
 
public interface Publisher<T> {
    void addSubscriber(Subscriber<T> s);
    void removeSubscriber(Subscriber<T> s);
    void notifySubscribers();
}

Implement the interfaces

public class IncomeSubscriber implements Subscriber<Float> {
 
    private final Publisher<Float> stockData;
 
    public IncomeSubscriber(Publisher<Float> stockData) {
        this.stockData = stockData;
        stockData.addSubscriber(this);
    }
 
    @Override
    public void unsubscribe() {
        this.stockData.removeSubscriber(this);
    }
 
    @Override
    public void notify(Float t) {
        System.out.println("IncomeObserver received changes: " + t);
    }
}
  
public class StockDataPublisher implements Publisher<Float> {
 
    private final List<Subscriber<Float>> subscribers;
    private Float stockValue;
 
    public StockDataPublisher() {
        subscribers = new ArrayList<>();
    }
 
    @Override
    public void addSubscriber(final Subscriber<Float> s) {
        subscribers.add(s);
    }
 
    @Override
    public void removeSubscriber(final Subscriber<Float> s) {
        subscribers.remove(s);
    }
 
    @Override
    public void notifySubscribers() {
        for (Subscriber<Float> s: subscribers) {
            s.notify(stockValue);
        }
    }
 
    public void setStockData(final Float stockValue) {
        this.stockValue = stockValue;
        notifySubscribers();
    }
}

Use case

public static void main(String[] args) {
    StockDataPublisher publisher = new StockDataPublisher();
 
    Subscriber subscriber1 = new IncomeSubscriber(publisher);
    Subscriber subscriber2 = new IncomeSubscriber(publisher);
 
    System.out.println("state change 1");
    publisher.setStockData(123f);
 
    subscriber1.unsubscribe();
 
    System.out.println("state change 2");
    publisher.setStockData(321f);
} 

Comparisons

Click here to expand...

Chain of Responsibility, Command, Mediator, and Observer address various ways of connecting senders and receivers of requests:

• Chain of Responsibility passes a request sequentially along a dynamic chain of potential receivers until one of them handles it
• Command establishes unidirectional connections between senders and receivers
• Mediator eliminates direct connections between senders and receivers, forcing them to communicate indirectly via a mediator object
• Observer lets receivers dynamically subscribe to and unsubscribe from receiving requests

Link to original

Mediator Pattern and Observer Pattern (Publisher-Subscriber Pattern) differences are often elusive. In most cases, you can implement either of these patterns; but sometimes you can apply both simultaneously. Let’s see how we can do that.

• The primary goal of Mediator is to eliminate mutual dependencies among a set of system components. Instead, these components become dependent on a single mediator object. The goal of Observer is to establish dynamic one-way connections between objects, where some objects act as subordinates of others
• There’s a popular implementation of the Mediator pattern that relies on Observer. The mediator object plays the role of publisher, and the components act as subscribers which subscribe to and unsubscribe from the mediator’s events. When Mediator is implemented this way, it may look very similar to Observer.
• When you’re confused, remember that you can implement the Mediator pattern in other ways. For example, you can permanently link all the components to the same mediator object. This implementation won’t resemble Observer but will still be an instance of the Mediator pattern.
• Now imagine a program where all components have become publishers, allowing dynamic connections between each other. There won’t be a centralized mediator object, only a distributed set of observers.

Link to original

Resources

• https://refactoring.guru/design-patterns/observer