favorite product<\/a> (which may be currently out of stock) and get notification once the product is available in stock or the product is available at discount or when its price decreases.<\/p>\nFor easy understanding let’s see how to develop one of the above feature using observer design pattern.<\/p>\n
Requirement<\/b><\/p>\n
While visiting our ecommerce site, a customer found one product very interesting and he has a great desire to buy that product.Unfortunately that product is currently out of stock. To avoid the customer disappointment, there is an option available for the customer to get subscribed to that product. So once the product is available in stock, subscribed user can be notified for its availability.<\/p>\n
So here user is an observer who wants to observe the Product for its availability. In other words whenever the state of subject i.e product changes from ‘out of stock’ to ‘in stock’, the observer (user) should be notified.<\/p>\n
Here product(subject) and user(observer) are two separate component and want to interact with each other.<\/span><\/p>\nImplementation<\/b><\/p>\n
There are four participants in the Observer pattern: <\/span><\/p>\n\n- Subject<\/i><\/b>, which is used to register observers. Objects use this interface to register as observers and also to remove themselves \u00a0from being observers.<\/span><\/li>\n
- Observer<\/i><\/b>, defines an updating interface for objects that should be notified of changes in a subject. All observers need to \u00a0implement the Observer interface. This interface has a method update(), which gets called when the Subject\u2019s state changes. <\/span><\/li>\n
- ConcreteSubject<\/i><\/b>, stores the state of interest to ConcreteObserver objects. It sends a notification to its observers when its state \u00a0changes. A concrete subject always implements the Subject interface. The notifyObservers() method is used to update \u00a0all the current observers whenever the state changes. <\/span><\/li>\n
- ConcreteObserver<\/i><\/b>, maintains a reference to a ConcreteSubject object and implements the Observer interface. Each observer \u00a0registers with a concrete subject to receive updates. \u00a0<\/span><\/li>\n<\/ul>\n
Although we can define all the above mentioned participants our self but Java brings a lot to the table. There are already methods, classes and interfaces defined in <\/span>java.util<\/span> package meant for easy implementation of this pattern. We can use these components of <\/span>java.util<\/span> package and customise it as per our requirement.<\/span><\/p>\nFollowing component are used from java.util package to implement this pattern:-<\/b><\/p>\n\n- public interface Observer- <\/b>All observer needs to implement this interface to get notification about the state change of subject.
\n<\/span>Note-<\/strong> In our case User is an observer so user class needs to implement this interface.
\nThis interface has one method- void update(Observable o, Object arg): This method is called whenever the observed object is changed. An application calls an Observable object’s notifyObservers() method to have all the object’s observers notified of the change.<\/li>\n- public class Observable- <\/b>It is basically a subject to whom observer wants to observe. So it can be sub-classed to represent an object that the application wants to have observed.
\n<\/span>Note- In our case Product is a subject that needs to be observed. So Product class needs to be the sub-class of Observable class.<\/span><\/li>\n<\/ol>\nObservable class has below useful methods-<\/b><\/p>\n\n- public synchronized void addObserver(Observer o)- <\/b>Adds an observer to the set of observers for this object, provided that it is not the same as some observer already in the set.
\n<\/span>Note- <\/b>The order in which notifications will be delivered to multiple observers is not specified.<\/span><\/li>\n- public synchronized void deleteObserver(Observer o)- <\/b>Deletes an observer from the set of observers of this object. <\/span><\/li>\n
- public synchronized void deleteObservers()- <\/b>Clears the observer list so that this object no longer has any observers.<\/span><\/li>\n
- public void notifyObservers()<\/b><\/li>\n
- public void notifyObservers(Object arg) – <\/b>If this object has changed, as indicated by the <\/span>hasChanged() <\/b>method, then notify all of its observers and then call the clearChanged() method to indicate that this object has no longer changed.
\n<\/span>Note- <\/b>Each observer has its update() method called with two arguments.<\/span><\/li>\n- protected synchronized void setChanged()- <\/b>Marks this Observable object as having been changed; the hasChanged() method will now return true.<\/span><\/li>\n
- protected synchronized void clearChanged()- <\/b>Indicates that this object has no longer changed, or that it has already notified all of its observers of its most recent change. <\/span><\/li>\n
- public synchronized boolean hasChanged()- <\/b>Tests if this object has changed. <\/span><\/li>\n
- public synchronized int countObservers()- <\/b>Returns the number of observers of this Observable object. <\/span><\/li>\n<\/ol>\n
Sample Code of our use case<\/b><\/p>\n
Step 1:- Define Subject<\/b><\/p>\n
For simplicity and better understanding we will be using ‘Observable’ interface as Subject, provided in <\/span>java.util<\/span> package meant for implementing observer design pattern. \u00a0<\/span><\/p>\nStep 2:- Define Observer<\/b><\/p>\n
We will be using ‘Observer’ interface as provided in <\/span>java.util<\/span> package. <\/span><\/p>\nStep 3:- Define \u00a0<\/b>ConcreteSubject
\n<\/b><\/p>\n
[js]package com.intelligrape;
\nimport java.util.Observable;
\nimport java.util.Observer;
\npublic class Product extends Observable {
\nString productId;
\nString productName;
\nInteger stockQuantity;
\npublic Product(String productId, String productName, Integer stockQuantity) {
\nsuper();
\nthis.productId = productId;
\nthis.productName = productName;
\nthis.stockQuantity = stockQuantity;
\n}
\n\/\/ Getters and Setters of the field…
\npublic void setStockQuantity(Integer stockQuantity) {
\nthis.stockQuantity = stockQuantity;
\nSystem.out.println("Setting stock quantity of " + this.toString());
\nif (this.stockQuantity > 0) {
\n\/\/ Whenever stock quantity of current product is set to
\n\/\/ greater than zero, notify the subscribed user
\nthis.setChanged();
\nthis.notifyObservers();
\n}
\n}
\n@Override
\npublic String toString() {
\nreturn "Product [productId=" +productId + ", productName=" + productName
\n}
\n@Override
\npublic synchronized void addObserver(Observer o) {
\nSystem.out.println("Subscribing " + o.toString() + " for notification of " + this.toString());
\nsuper.addObserver(o);
\n}
\n@Override
\npublic synchronized void deleteObserver(Observer o) {
\nSystem.out.println("Un-subscribing "+ o.toString() + " from notification of " +
\nthis.toString());
\nsuper.deleteObserver(o);
\n}
\n@Override
\npublic void notifyObservers() {
\nSystem.out.println("Notifying observers for availability of " + this.toString());
\nsuper.notifyObservers();
\n\/\/ if it requires to notify observer only for one time, then delete
\n\/\/ all the observers after notification by un-commenting below line.
\n\/\/ this.deleteObservers();
\n}
\n}[\/js]<\/p>\n
Step 4:- Define \u00a0ConcreteObserver<\/b><\/p>\n
[js]package com.intelligrape;
\nimport java.util.Observable;
\nimport java.util.Observer;
\npublic class User implements Observer {
\nString id;
\nString name;
\npublic User(String id, String name) {
\nsuper();
\nthis.id = id;
\nthis.name = name;
\n}
\n\/\/ Getters and Setters…
\n@Override
\npublic String toString() {
\nreturn "User [id=" + id + ",name=" + name + "]";
\n}
\n@Override
\npublic void update(Observable o, Object arg) {
\nSystem.out.println(this.toString() + " is notified successfully about the availability of " + o.toString());
\n}
\n}[\/js]<\/p>\n
Define Main class<\/b><\/p>\n
\u00a0<\/span><\/p>\n[js]package com.intelligrape;
\npublic class Test {
\npublic static void main(String[] args) {
\nProduct product1 = new Product("P1","Jacket", 0);
\nProduct product2 = new Product("P2","Jeans", 5);
\nUser person1 = new User("customer 1","Ajay");
\nUser person2 = new User("customer 2","Saktiman");
\nUser person3 = new User("customer 3","Rajnikant");
\n\/\/ Adding observer for product1
\nproduct1.addObserver(person1);
\nproduct1.addObserver(person2);
\n\/\/ Setting stock quantity of product1 will notify all observer of product1
\nproduct1.setStockQuantity(8);
\n\/\/ Adding observer for product2
\nproduct2.addObserver(person1);
\nproduct2.addObserver(person2);
\nproduct2.addObserver(person3);
\nproduct2.setStockQuantity(0);
\n\/\/ Setting stock quantity of product2 will notify all observer of product2
\nproduct2.setStockQuantity(10);
\n\/\/ Removing person1 from observer list of product2
\n\/\/ Now person1 will not get notification about product2
\nproduct2.deleteObserver(person1);
\nproduct2.setStockQuantity(15);
\n}
\n}[\/js]<\/p>\n
Scope Of Further Improvement In Sample Code<\/b><\/p>\n
Instead of passing the entire subject, it is good to define a separate type and pass it as parameter to the handler method in the observer class. This type basically contains the meta information about the event. Eg source of event, time at which event was generated, what are the actual property of subject that leads to change in state of Subject etc. In our case subject domain is very small So we are not creating any separate type.<\/p>\n
Other Use Cases:-<\/b><\/p>\n\n- Consider an e-commerce business. This pattern can be used in following scenario:- <\/span>\n
\n- An admin user can be notified with the increase in demand of given product. Whenever the number of subscribed user for a given product increases more than a given threshold then the admin user can be notified for the increase in demand for that product and that product can be marked as highly demanded product. <\/span><\/li>\n
- Similarly whenever the quantity of highly demanded product falls below a given threshold then the admin user can be notified for that product. <\/span><\/li>\n
- An admin user can associate a discount\/coupon with multiple product. So any change in discount\/coupon (eg change in discount percentage\/value or associating\/disassociating product to\/from coupon) must be notified to its associated product. So that the associated product can be updated with new available discount\/coupon.<\/span><\/li>\n<\/ol>\n<\/li>\n
- Consider an excel sheet, data is shown to the user in different views. Generally data is shown in grid cells and as required different graphs, charts can be created for same data. Underlying data is same and when that data (subject) state changes all the different view (observer) are updated. <\/span><\/li>\n
- The observer pattern is used in the model view controller (MVC) architectural pattern. In MVC this pattern is used to decouple the model from the view. View represents the Observer and the model is the Observable object.
\n<\/span>Example- <\/b>Popular JSF technology also uses observer design pattern along with other design design pattern. The JSF framework implements the Observer pattern in UI components. JSF technology has two kinds of built-in events: ActionEvent and ValueChangedEvent. ActionEvent is useful in determining the activation of user interface components such as buttons. When a user clicks on the button, the JSF implementation notifies one or more action listeners added to the button. The button is activated or the state of the button (subject) changes. All listeners (or observers) are notified of the changes of state in subject that are added to the button. Similarly, when the value in the input UI component changes, the JSF implementation notifies ValueChangeListeners.<\/span><\/li>\n- A company can have many shareholders. So any change in policy of company needs to be notified to its shareholders. <\/span><\/li>\n
- A news agency gather news and publish them to different subscribers. \u00a0So when an event occurs, all the subscribers get notified. The solution need to be extensively enough to support new types of subscribers(maybe new communication technologies will appear). <\/span><\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"
Observer Design Pattern When we build applications using object oriented paradigm, we try to develop each of our component independent of all other component that exist in our system. Although component independency fixes a lot of problem and it’s very convenient, but sometime it makes difficult to establish interaction between these independent component. So the […]<\/p>\n","protected":false},"author":270,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":9},"categories":[446,1],"tags":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/37853"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/270"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=37853"}],"version-history":[{"count":0,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/37853\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=37853"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=37853"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=37853"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}