Observer pattern

UML class diagram of Observer pattern

The observer pattern is a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods. It is mainly used to implement distributed event handling systems. The Observer pattern is also a key part in the familiar Model View Controller (MVC) architectural pattern. In fact the observer pattern was first implemented in Smalltalk's MVC based user interface framework. The observer pattern is implemented in numerous programming libraries and systems, including almost all GUI toolkits.

Related patterns: Publish–subscribe pattern, mediator, singleton.

Example

Below is an example written in Java that takes keyboard input and treats each input line as an event. The example is built upon the library classes java.util.Observer and java.util.Observable. When a string is supplied from System.in, the method notifyObservers is then called, in order to notify all observers of the event's occurrence, in the form of an invocation of their 'update' methods - in our example, ResponseHandler.update(...).

The file MyApp.java contains a main() method that might be used in order to run the code.

/* File Name : EventSource.java */
package org.wikipedia.obs;
 
import java.util.Observable;          //Observable is here
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class EventSource extends Observable implements Runnable {
    @Override
    public void run() {
        try {
            final InputStreamReader isr = new InputStreamReader(System.in);
            final BufferedReader br = new BufferedReader(isr);
            while (true) {
                String response = br.readLine();
                setChanged();
                notifyObservers(response);
            }
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/* File Name: ResponseHandler.java */
 
package org.wikipedia.obs;
 
import java.util.Observable;
import java.util.Observer;  /* this is Event Handler */
 
public class ResponseHandler implements Observer {
    private String resp;
    public void update(Observable obj, Object arg) {
        if (arg instanceof String) {
            resp = (String) arg;
            System.out.println("\nReceived Response: " + resp );
        }
    }
}

/* Filename : MyApp.java */
/* This is the main program */
 
package org.wikipedia.obs;
 
public class MyApp {
    public static void main(String[] args) {
        System.out.println("Enter Text >");
 
        // create an event source - reads from stdin
        final EventSource eventSource = new EventSource();
 
        // create an observer
        final ResponseHandler responseHandler = new ResponseHandler();
 
        // subscribe the observer to the event source
        eventSource.addObserver(responseHandler);
 
        // starts the event thread
        Thread thread = new Thread(eventSource);
        thread.start();
    }
}

See also

• Design Patterns (book), the book which gave rise to the study of design patterns in computer science
• Design pattern (computer science), a standard solution to common problems in software design
• Implicit invocation
• Model-view-controller (MVC)
• Client–server model
• Lapsed listener problem

References

• http://www-01.ibm.com/software/ucd/designpatterns.html
• http://msdn.microsoft.com/en-us/library/Ee817669(pandp.10).aspx
• "Speaking on the Observer pattern" - JavaWorld

External links

• Observer Pattern implementation in JDK 7
• Observer Pattern in Java
• Definition, C# example & UML diagram
• Subject Observer example in C++
• Observer Pattern recipe in Python
• SourceMaking Tutorial
• Observer Pattern in Objective-C
• Observer Pattern in Java (Portuguese)
• Deprecating the Observer Pattern by Ingo Maier, Tiark Rompf, Martin Odersky (2010) PDF
• For an open source event system which uses the observer pattern and is in production on Bing.com, MSN.com, and Microsoft.com, see version 3.0 Distributed Publish/Subscribe Event System