The most common analogy for the observer design pattern is a newspaper subscription. Households can subscribe to particular newspapers. When a new paper is printed the news organization delivers that paper to all of its subscribers.
The observer design pattern implements a similar approach. Objects, called observers, can watch other objects for state changes. These objects that can broadcast changes are known as observables. In this example, a stoplight is an observable object. Other objects can subscribe to the stoplight and watch it for state changes.
For example, a bike, a car, a bus. They’re all different types of objects, but they can all watch the stoplight object for changes and respond accordingly. When the state of the stoplight changes, say from red to green, it can notify every object that has subscribed to it of this state change.
The key is that each observer object implements a method that the observable can invoke when there is a change. In this case it’s the notify method. Observers are a very common design pattern, and they are extremely important to wrangling the asynchronous nature of node JS.
The Gang of Four defines the intent of the observer pattern as, “Defining a one-to-many dependency between objects “so that when one object changes state, “all of its dependents are notified “and updated automatically.” Let’s take a look at some code. So I’m inside our exercise files in our exercise files under chapter 4, under chapter 4 lesson 8 within the start folder. We already have some objects created. We have a simple shopper class, that just saves the name of each shopper. We also have a mall class. It saves an array of sales.
So the idea is we want the mall to keep track of any stores that have ongoing sales. That means that our store class can announce sales. So on line seven we have a method for announcing the sale. Now right now, all the store does when it announces a sale is log that information to the console. If you take a look at the index.js file, you’ll notice that we’ve created two instances of stores, Cats & Things and Ins and Outs; and four instances of shoppers, Alex, Eve, Sharon, and Mike; and one instance of the mall, the Valley Mall.
Now observers is really concerned about how all of these objects communicate with one another. Alex, Eve, Sharon, Mike and the Valley Mall need to listen for new sales at Cats & Things and Ins and Outs. Let’s go ahead and add some code to implement the observer pattern. So I’m going to take the store Cats & Things and I’m going to subscribe a few observers. So we’ll subscribe Alex and I will go ahead and copy this line and paste it a few more times. And we’ll also subscribe Eve and Mike. Now, when we subscribe an object to Cats & Things, that means that that object can listen for the announcement of new sales.
Now Cats & Things isn’t concerned with the type of object that can listen for sales. Shoppers can listen for sales. But the mall can also listen for sales. So we will also subscribe the Valley Mall as an observer to Cats & Things. Let’s go ahead and add some subscriptions to Ins and Outs. Ins and Outs can subscribe Sharon, and we also want Ins and Outs to subscribe the Valley Mall. So the idea is that the mall is going to listen to any new sale announcement, so that it can keep track of it.
We should see what sales are going on by logging the Valley Mall sales field, and that should be the array of ongoing sales. The idea here is that the observer objects, the shoppers and the mall, will listen for state changes on the observables, Cats & Things and Ins and Outs. So what this means is, if we come up here above where we’re listing the sales, and declare a few sales, so we can give Cats & Things a sale of 20% off everything or Ins and Outs a sale of 50% off everything.
All of our observers should have been notified of these sales. That means Alex, Eve, Mike should be notified of the Cats & Things sale, Sharon should be notified of the Ins and Outs sale, and the Valley Mall should be keeping track of all of the sales. We want to run this code and have the observers be notified of any new sales that occur at the mall. Now before we can do that we must add the code to the observable object, the store, and the observers, the mall and the shopper. In the next lesson we will actually implement the observable design pattern by coding these objects.