The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Observer

Next ►
►

Introduction

The Observer pattern is a behavioral design pattern that defines a one-to-many dependency between objects. When one object (the subject) changes state, all its dependents (observers) are notified and updated automatically. This pattern is particularly useful for implementing distributed event-handling systems.

Key Concepts

  • Subject: The object that holds the state and notifies observers of any changes.
  • Observer: The object that needs to be updated when the subject's state changes.
  • Subscription Mechanism: The process by which observers register and unregister themselves with the subject.

Structure

The Observer pattern involves the following components:

  1. Subject Interface: Declares methods for attaching and detaching observer objects.
  2. Concrete Subject: Stores state and notifies observers of state changes.
  3. Observer Interface: Declares the update method, which is called by the subject.
  4. Concrete Observer: Implements the update method to keep its state consistent with the subject's state.

UML Diagram

+----------------+       +----------------+
|    Subject     |       |    Observer    |
+----------------+       +----------------+
| +attach()      |       | +update()      |
| +detach()      |       +----------------+
| +notify()      |
+----------------+
        |
        |
+----------------+
|ConcreteSubject |
+----------------+
| -state         |
| +getState()    |
| +setState()    |
+----------------+
        |
        |
+----------------+
|ConcreteObserver|
+----------------+
| -subject       |
| -observerState |
| +update()      |
+----------------+

Example

Let's implement a simple example in Python where we have a WeatherStation (subject) and WeatherDisplay (observer).

Code Implementation

Subject Interface

from abc import ABC, abstractmethod

class Subject(ABC):
    @abstractmethod
    def attach(self, observer):
        pass

    @abstractmethod
    def detach(self, observer):
        pass

    @abstractmethod
    def notify(self):
        pass

Concrete Subject

class WeatherStation(Subject):
    def __init__(self):
        self._observers = []
        self._temperature = 0

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update(self)

    def set_temperature(self, temperature):
        self._temperature = temperature
        self.notify()

    def get_temperature(self):
        return self._temperature

Observer Interface

class Observer(ABC):
    @abstractmethod
    def update(self, subject):
        pass

Concrete Observer

class WeatherDisplay(Observer):
    def update(self, subject):
        if isinstance(subject, WeatherStation):
            print(f"WeatherDisplay: The current temperature is {subject.get_temperature()}°C")

Usage

if __name__ == "__main__":
    weather_station = WeatherStation()
    display = WeatherDisplay()

    weather_station.attach(display)

    weather_station.set_temperature(25)
    weather_station.set_temperature(30)

Explanation

  1. Subject Interface: Defines the methods attach, detach, and notify.
  2. Concrete Subject: Implements the Subject interface and maintains a list of observers. It notifies all observers when its state changes.
  3. Observer Interface: Defines the update method that will be called by the subject.
  4. Concrete Observer: Implements the Observer interface and updates its state based on the subject's state.

Output

WeatherDisplay: The current temperature is 25°C
WeatherDisplay: The current temperature is 30°C

Practical Exercise

Exercise

Implement an observer pattern where a StockMarket (subject) notifies Investor (observer) objects about stock price changes.

Steps

  1. Create a StockMarket class that implements the Subject interface.
  2. Create an Investor class that implements the Observer interface.
  3. The StockMarket should have methods to set and get stock prices.
  4. The Investor should print the updated stock price when notified.

Solution

StockMarket Class

class StockMarket(Subject):
    def __init__(self):
        self._observers = []
        self._stock_price = 0

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update(self)

    def set_stock_price(self, price):
        self._stock_price = price
        self.notify()

    def get_stock_price(self):
        return self._stock_price

Investor Class

class Investor(Observer):
    def update(self, subject):
        if isinstance(subject, StockMarket):
            print(f"Investor: The current stock price is {subject.get_stock_price()}")

Usage

if __name__ == "__main__":
    stock_market = StockMarket()
    investor = Investor()

    stock_market.attach(investor)

    stock_market.set_stock_price(100)
    stock_market.set_stock_price(150)

Output

Investor: The current stock price is 100
Investor: The current stock price is 150

Common Mistakes and Tips

  1. Forgetting to Notify Observers: Always ensure that the subject calls the notify method after changing its state.
  2. Circular Dependencies: Be cautious of creating circular dependencies between subjects and observers.
  3. Performance Issues: If there are many observers, notifying all of them can be time-consuming. Consider optimizing the notification mechanism if performance becomes an issue.

Conclusion

The Observer pattern is a powerful tool for creating systems where changes in one object need to be reflected in others. By understanding and implementing this pattern, you can create more modular, maintainable, and scalable software. In the next section, we will explore the State pattern, another behavioral design pattern that helps manage an object's state.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved