Mastering the Observer Pattern: From Theory to Android Implementation

Observer Pattern Definition

The observer pattern defines a one‑to‑many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

Key Terms

Observable (also called Subject) is the object being observed. It typically provides methods to register observers, remove them, and notify them.

Observer is the entity that receives updates from the observable. It registers to receive updates and can unregister when no longer needed.

Examples and Applications

A real‑world example is a newspaper subscription: users (observers) subscribe to a newspaper (observable); the newspaper sends new issues to all subscribers, and users can unsubscribe.

In Android, libraries such as EventBus and RxJava implement the observer pattern, as do callback mechanisms like button click listeners.

Implementing the Observer Pattern in Code

Below is a custom Java implementation that mimics the newspaper subscription example.

public interface MyObserverable {
    void register(MyObserver myObserver);
    void remove(MyObserver myObserver);
    void send(NewsModel model);
}

public interface MyObserver {
    void receive(NewsModel model);
}

public class NewsProvider implements MyObserverable {
    private static final long DELAY = 2 * 1000;
    private List<MyObserver> mObservers = new ArrayList<>();

    public NewsProvider() {
        generateNews();
    }

    private void generateNews() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            int titleCount = 1;
            int contentCount = 1;
            @Override
            public void run() {
                send(new NewsModel("title:" + titleCount++, "content:" + contentCount++));
            }
        }, DELAY, 1000);
    }

    @Override
    public void register(MyObserver myObserver) {
        if (myObserver == null) return;
        synchronized (this) {
            if (!mObservers.contains(myObserver)) {
                mObservers.add(myObserver);
            }
        }
    }

    @Override
    public synchronized void remove(MyObserver myObserver) {
        mObservers.remove(myObserver);
    }

    @Override
    public void send(NewsModel model) {
        for (MyObserver observer : mObservers) {
            observer.receive(model);
        }
    }
}

public class User implements MyObserver {
    private String mName;
    public User(String name) { mName = name; }
    @Override
    public void receive(NewsModel model) {
        System.out.println(mName + " receive news:" + model.getTitle() + " " + model.getContent());
    }
}

public class Test {
    public static void main(String[] args) {
        NewsProvider provider = new NewsProvider();
        for (int i = 0; i < 10; i++) {
            User user = new User("user:" + i);
            provider.register(user);
        }
    }
}

The program outputs each user receiving news updates every two seconds, demonstrating a simple observer pattern.

Using JDK’s Built‑in Observable

Java’s java.util.Observable and java.util.Observer provide a ready‑made implementation. By extending Observable and implementing Observer, you can achieve the same behavior with less code. The JDK version also includes a boolean changed flag to control notifications.

public class NewsProvider extends Observable {
    private static final long DELAY = 2 * 1000;
    public NewsProvider() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            int titleCount = 1;
            int contentCount = 1;
            @Override
            public void run() {
                setChanged();
                notifyObservers(new NewsModel("title:" + titleCount++, "content:" + contentCount++));
            }
        }, DELAY, 1000);
    }
}

public class User implements Observer {
    private String mName;
    public User(String name) { mName = name; }
    @Override
    public void update(Observable o, Object arg) {
        NewsModel model = (NewsModel) arg;
        System.out.println(mName + " receive news:" + model.getTitle() + " " + model.getContent());
    }
}

Callback Functions and the Observer Pattern

A callback can be viewed as a special case of the observer pattern. In Android, view click listeners are callbacks registered via setOnClickListener. The view acts as the observable, the listener as the observer, and the click event triggers the notification.

xxxView.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        // do something
    }
});

The Android framework defines the OnClickListener interface and the setOnClickListener method registers the callback. When the view is clicked, performClick() invokes the listener’s onClick method.