Observer design pattern

By Sidd Bhattacharjee -

Type : Behavioral Design Pattern

Summary

In Observer design pattern, an object called subject maintains one to many relationship with Observers, so that once the state of the Subject changes it can automatically inform Observers registered with the subject.

Advantage

An Object(Subject) can notify other Objects(Observer) without being tightly coupled with Observer and depend on Observer Class.

Different instances of the same Subject can register its own list of Observers.

Disadvantage

Due to the indirect communication between Subject and Observer's it can lead to performance issues.

Important Points

Multiple Subscribers for a Subject.
Subjects know its Subscribers.
Generally the Subject triggers the method that updates Observers.
New Observers can be added to the System with minimal changes.

Details

Following are different participants in Observer Pattern

Subject(Interface)
 Keeps track of its observers
 Provides an interface for attaching and detaching Observer objects

Observer(Interface)
 Defines an interface for update notification

ConcreteSubject
  The object being observed
  Sends a notification to its observers when its state changes

ConcreteObserver
  The observing object
  Stores state that should stay consistent with the subject's
  Implements the Observer update interface to process any changes in Subject


Simple Example

Let's think about a simple use case for Ordering Food in Restaurant. We have a subject RestaurantOder. And a list of Observers like (DoMenuAvailabilityObserver, DoFoodPrepareObserver, DoBillPaymentObserver etc.)

Class Diagram





Source Code


/**
 * Interface Subject
 */
public interface Subject {

  public void registerObserver(Observer observer);

  public void notifyObserver();

}


/**
 * Interface Observer
 */
public interface Observer {
  
  public void update(Subject sub);

}

// concrete Subject
public class RestaurantOrder implements Subject {

  public String order;

  public RestaurantOrder(String order) {
    this.order = order;
  }


  List observersList = new ArrayList();

  @Override
  public void notifyObserver() {
    for (Observer observer : observersList) {
      observer.update(this);
    }
  }

  @Override
  public void registerObserver(Observer observer) {
    observersList.add(observer);
  }

}

// concrete Observer which initiate payment processing
public class DoBillPaymentObserver implements Observer {

  @Override
  public void update(Subject subject) {

    System.out.println("Process payment for " + ((RestaurantOrder) subject).order);

  }

}

Comments

Post a Comment

Popular posts from this blog

Difference between volatile and synchronized

By -
volatile is a field modifier, while synchronized modifies code blocks and methods. So we can specify three variations of a simple accessor using those two keywords: int i1; int geti1() {return i1;} volatile int i2; int geti2() {return i2;} int i3; synchronized int geti3() {return i3;} geti1() accesses the value currently stored in i1 in the current thread . Threads can have local copies of variables, and the data does not have to be the same as the data held in other threads. In particular, another thread may have updated i1 in it's thread, but the value in the current thread could be different from that updated value. In fact Java has the idea of a "main" memory, and this is the memory that holds the current "correct" value for variables. Threads can have their own copy of data for variables, and the thread copy can be different from the "main" memory. So in fact, it is possible for the "main"
Read more

Converting Java Map to String

By -
Java Collections framework, String manipulation etc is something that we often encounter in Development process. For processing collections (like checking null/empty, Intersection, Disjunction) We do have some of the very use full libraries. Some of the Collection related libraries are Apche Commons Collections and Google  Collections(Guava). Problem Use Case This article explains how to convert a Java Map to String(and vice versa) using different libraries and technique. One way is to use StringBuilder(Or String) and loop though the Map and build the String by applying some sort of separator ( for key:value and entry). Here we have to take care of the null value etc. Without Any Library If we want to convert the map to a String with key value separator and also individual entry seperator in the resulting String, we have to write code for that. For a simple Map, we have to iterate though the map, take care of the null values etc. Following is a sample to get String built
Read more

Masking Credit Card number in Java

By -
Sometimes we need to mask crucial information like Credit Card Numbers, CVV numbers etc before storing  or logging the information. This example mask Credit Card Number (Except last 4 Digit) from a Text which contains information along with Credit Card Number. The following example demonstrates how we can easily mask the credit card with Matcher and Pattern Classes. This Sample Code uses Matcher and Pattern. Pattern Used in this sample is not optimized for Credit Card Numbers, this pattern will get any numerical numbers in the String Content.  Based on the Credit Card Type a more efficient and Strict RegEx can be used to mask the Credit Card. /**Mask the Credit card number but last four digit value **/   Pattern PATTERN = Pattern.compile( "[0-9]+" ); String message = content; Matcher matcher = PATTERN.matcher(message); String maskingChar = "*"; StringBuilder finalMask = new StringBuilder(maskingChar);
Read more