As the name suggests it is used for observing some objects.Observer
watch for any change in state or property of subject.Suppose you are
interested in particular object and want to get notified when its state
changes then you observe that object and when any state or property
change happens to that object,it get notified to you.
As described by GoF:
"Define
a one-to-many dependency between objects so that when one object
changes state, all its dependents are notified and updated
automatically".
You can think of observer design pattern in two ways
- Subject-Observer relationship:Object which is being observed is refereed as Subject and classes which observe subject are called Observer
- Publisher-Subscriber relationship:A publisher is one who
publish data and notifies it to the list of subscribers who have
subscribed for the same to that publisher. A simple example is
Newspaper. Whenever a new edition is published by the publisher,it will
be circulated among subscribers whom have subscribed to publisher.
The observers will not monitor every time whether there is any
change in state of subject or not, since they will be notified for every
state change of subject, until they stop observing subject. So it
follows hollywood principle-"Don't call us,we will call you".
Some real life examples:
You might
have surfed "Flipkart.com-Online megastore".So when you search for any
product and it is unavailable then there is option called "Notify me
when product is available".If you subscribe to that option then when
state of product changes i.e. it is available,you will get notification
mail "Product is available now you can buy it".In this case,Product is
subject and You are an observer.
Lets
say,your permanent address is changed then you need to notify passport
authority and pan card authority.So here passport authority and pan card
authority are observers and You are a subject.
On facebook also,If you subscribe someone then whenever new updates happen then you will be notified.
When to use it:
- When one object changes its state,then all other dependents object must automatically change their state to maintain consistency
- When subject doesn't know about number of observers it has.
- When an object should be able to notify other objects without knowing who objects are.
UML diagram for observer design pattern:
Components:
Subject
- Knows its observers
- Has any number of observer
- Provides an interface to attach and detaching observer object at run
time
Observer
- Provides an update interface to receive signal from subject
ConcreteSubject
- Stores state of interest to ConcreteObserver objects.
- Send notification to it's observer
ConcreteObserver
- Maintains reference to a ConcreteSubject object
- Maintains observer state consistent with subjects.
- Implements update operation
Java in-built API for observer pattern:
The java API provides one class and one inteface for implementing observer pattern.
1. java.util.Observable-class
2. java.util.Observer-interface
java.util.Observable:
For being
observed,class must extend this class. The subclass becomes observable
and override methods of java.util.Observable and other objects can
"observe" changes in state of this object.
addObserver(Observer o) :add Observer to the list of observers for this subject.
deleteObserver(Observer o) :delete Observers from the list of observers .
notifyObservers() : notify all the observers if object has changed.
hasChanged() :return true if object has changed.
setChanged() :This method marks object has changed
clearChanged() :this method will indicate that subject has no changes or all the observers has been notified.
java.util.Observer:
The class that performs the "observing" must implement the java.util.Observer interface. There is a single method:
public void update(Observable obj, Object arg)
:This method is called whenever the observed object is changed. An
application calls an Observable object's notifyObservers method for
notifying to all the observers of change.
Example:
You might have surfed "Flipkart.com-Online megastore".So when you search
for any product and it is unavailable then there is option called
"Notify me when product is available".If you subscribe to that option
then when state of product changes i.e. it is available,you will get
notification mail "Product is available now you can buy it".
Java code:
Below interface is our
subject interface.It consists of method for adding or removing observers
and also in condition of state change,notify all observer.
1.Subject.java:
package org.arpit.javapostsforlearning;
public interface Subject {
public void registerObserver(Observer observer);
public void removeObserver(Observer observer);
public void notifyObservers();
}Below
class is our ConcreteSubject class.It implements subject interface thus
provide implementation of all above three methods.
2.Product.java:
package org.arpit.javapostsforlearning;
import java.util.ArrayList;
public class Product implements Subject{
private ArrayList<Observer> observers = new ArrayList<Observer>();
private String productName;
private String productType;
String availability;
public Product(String productName, String productType,String availability) {
super();
this.productName = productName;
this.productType = productType;
this.availability=availability;
}
public ArrayList<Observer> getObservers() {
return observers;
}
public void setObservers(ArrayList<Observer> observers) {
this.observers = observers;
}
public String getProductName() {
return productName;
}
public void setProductName(String productName) {
this.productName = productName;
}
public String getProductType() {
return productType;
}
public void setProductType(String productType) {
this.productType = productType;
}
public String getAvailability() {
return availability;
}
public void setAvailability(String availability) {
this.availability = availability;
notifyObservers();
}
public void notifyObservers() {
System.out.println("Notifying to all the subscribers when product became available");
for (Observer ob : observers) {
ob.update(this.availability );
}
}
public void registerObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
} Below interface is our observer interface.It consists of single method called "update"
3.Observer.java:
package org.arpit.javapostsforlearning;
public interface Observer {
public void update(String availability);
}Below
class is our ConcreteObserver class.It implements observer interface
and provide implementation for update and other ConcreteObserver
specific methods.
4.Person.java:
package org.arpit.javapostsforlearning;
public class Person implements Observer{
String personName;
public Person(String personName) {
this.personName = personName;
}
public String getPersonName() {
return personName;
}
public void setPersonName(String personName) {
this.personName = personName;
}
public void update(String availabiliy) {
System.out.println("Hello "+personName+", Product is now "+availabiliy+" on flipkart");
}
}
5.ObserverPatternMain.java:
package org.arpit.javapostsforlearning;
public class ObserverPatternMain {
public static void main(String[] args) {
Person arpitPerson=new Person("Arpit");
Person johnPerson=new Person("John");
Product samsungMobile=new Product("Samsung", "Mobile", "Not available");
samsungMobile.registerObserver(arpitPerson);
samsungMobile.registerObserver(johnPerson);
samsungMobile.setAvailability("Available");
}
}
Run it:
Notifying to all the subscribers when product became available
Hello Arpit, Product is now Available on flipkart
Hello John, Product is now Available on flipkart
Now in above program,when availability of samsung mobile changes,it get notified subscribers who has subscribed for it.
Using java inbuilt APIs:
1.Product.java:
package org.arpit.javapostsforlearning;
import java.util.ArrayList;
import java.util.Observable;
import java.util.Observer;
public class Product extends Observable{
private ArrayList<Observer> observers = new ArrayList<Observer>();
private String productName;
private String productType;
String availability;
public Product(String productName, String productType,String availability) {
super();
this.productName = productName;
this.productType = productType;
this.availability=availability;
}
public ArrayList<Observer> getObservers() {
return observers;
}
public void setObservers(ArrayList<Observer> observers) {
this.observers = observers;
}
public String getProductName() {
return productName;
}
public void setProductName(String productName) {
this.productName = productName;
}
public String getProductType() {
return productType;
}
public void setProductType(String productType) {
this.productType = productType;
}
public String getAvailability() {
return availability;
}
public void setAvailability(String availability) {
if(!(this.availability.equalsIgnoreCase(availability)))
{
this.availability = availability;
setChanged();
notifyObservers(this,availability);
}
}
public void notifyObservers(Observable observable,String availability) {
System.out.println("Notifying to all the subscribers when product became available");
for (Observer ob : observers) {
ob.update(observable,this.availability);
}
}
public void registerObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
}
package org.arpit.javapostsforlearning;
import java.util.Observable;
import java.util.Observer;
public class Person implements Observer{
String personName;
public Person(String personName) {
this.personName = personName;
}
public String getPersonName() {
return personName;
}
public void setPersonName(String personName) {
this.personName = personName;
}
public void update(Observable arg0, Object arg1) {
System.out.println("Hello "+personName+", Product is now "+arg1+" on flipkart");
}
}
3.ObserverPatternMain.java:
package org.arpit.javapostsforlearning;
public class ObserverPatternMain {
public static void main(String[] args) {
Person arpitPerson=new Person("Arpit");
Person johnPerson=new Person("John");
Product samsungMobile=new Product("Samsung", "Mobile", "Not available");
samsungMobile.registerObserver(arpitPerson);
samsungMobile.registerObserver(johnPerson);
samsungMobile.setAvailability("Available");
}
}
Run it:
Notifying to all the subscribers when product became available
Hello Arpit, Product is now Available on flipkart
Hello John, Product is now Available on flipkart
Some important points about observer pattern:
- Loose coupling between Subject and Observer:Only thing
subject know about its observers is that observer implements Observer
interface.You can register or delete any observer without affecting
subject.
- Support for broadcast communication:Notification about
subject state change does not need to specify its receiver.This
notification is broadcasted to all interested object that subscribed to
it.
- The one of the problem with this pattern is that debugging become
very hard,if you have large number of subscribers because flow of
control is implicit between subject and observers.
- Spurious updates:If criteria for state change is not well defined then sometimes it lead to spurious updates.
