How to Implement the Observer Pattern in Rust with Examples

Amza

Amza

— 4 min read

In software development, keeping different parts of your application in sync can be tricky. How can you ensure that one part of your code is automatically updated when something else changes? This is where the Observer Pattern comes in handy, allowing an object (the subject) to notify other objects (the observers) about changes to its state.

In this article, we'll explore the Observer Pattern in Rust, walking you through a simple, practical example. By the end, you'll understand how to implement the pattern, and how it can help you create flexible, decoupled systems.

Step 1: Introduction to the Observer Pattern

The Observer Pattern is a behavioral design pattern. It enables one object (the subject) to notify other objects (the observers) about changes to its state, without those objects being tightly coupled to the subject. This pattern is particularly useful when you want to maintain loose coupling between components but still need them to communicate when state changes occur.

When Would You Use the Observer Pattern?

  • In event-driven systems, where multiple components need to react to events.
  • In situations where an object’s state change needs to be communicated to multiple other objects without explicitly linking them together.
  • When creating UI frameworks or handling networked services.

Now, let’s dive into Rust, a systems programming language, and see how to implement the Observer Pattern from scratch.

Step 2: Start with the Basics: Define the Subject and Observer

2.1 The Subject (Observable)

Let’s start by creating a basic Subject struct. The Subject will hold some state and have a method to notify its observers whenever the state changes. But first, we need to define what makes something observable.

pub struct Subject {
    state: String,
}

impl Subject {
    pub fn new(state: &str) -> Self {
        Self {
            state: state.into(),
        }
    }

    pub fn state(&self) -> &str {
        &self.state
    }

    // We'll add methods for attaching and notifying observers soon
}

Here, we've created a basic Subject struct with a state field and methods to create a new subject (new) and access its state (state).

2.2 The Observer

Next, we define what an Observer is. In the Observer Pattern, observers will react when the subject’s state changes. We can define a simple Observer trait that any observer will implement.

pub trait Observer {
    fn update(&self, state: &str);
}

This Observer trait defines a method update, which will be called whenever the subject's state changes. It takes the state of the subject as an argument.

Step 3: Enhancing the Subject with Observer Management

Now that we have the subject and observer, we need to add functionality to allow observers to subscribe and unsubscribe from the subject. We also need a way to notify the observers when the subject’s state changes.

3.1 Attach and Notify Observers

We will store a list of observers in the subject, and when the state changes, we’ll call the update method of each observer. But first, we need a way to manage observers.

pub struct Subject {
    state: String,
    observers: Vec<Box<dyn Observer>>, // Store observers in a vector
}

impl Subject {
    pub fn new(state: &str) -> Self {
        Self {
            state: state.into(),
            observers: Vec::new(),
        }
    }

    pub fn attach(&mut self, observer: Box<dyn Observer>) {
        self.observers.push(observer);
    }

    pub fn update_state(&mut self, state: &str) {
        self.state = state.into();
        self.notify();
    }

    fn notify(&self) {
        for observer in &self.observers {
            observer.update(&self.state);
        }
    }
}

Here, we’ve added:

  • observers: a vector to hold all attached observers.
  • attach: a method that allows adding observers.
  • update_state: a method that updates the subject’s state and then notifies all observers.

3.2 Implementing an Observer

Next, let’s implement an actual observer. We'll create a simple MyObserver struct that implements the Observer trait.

pub struct MyObserver {
    name: String,
}

impl MyObserver {
    pub fn new(name: &str) -> Self {
        Self {
            name: name.into(),
        }
    }
}

impl Observer for MyObserver {
    fn update(&self, state: &str) {
        println!("{} noticed that the state changed to: {}", self.name, state);
    }
}

Here, MyObserver has a name field, and when it’s notified about a state change, it prints a message to the console.

Step 4: Testing the Observer Pattern

Now that we have our Subject and Observer implementations, let’s see how this works in action.

fn main() {
    let mut subject = Subject::new("Initial State");

    let observer1 = Box::new(MyObserver::new("Observer 1"));
    let observer2 = Box::new(MyObserver::new("Observer 2"));

    subject.attach(observer1);
    subject.attach(observer2);

    // Change the state and notify observers
    subject.update_state("New State");
}

Expected Output:

Observer 1 noticed that the state changed to: New State
Observer 2 noticed that the state changed to: New State

In the example above:

  • We create a Subject with an initial state.
  • We create two observers (observer1 and observer2) and attach them to the subject.
  • When we call update_state, the subject’s state changes, and both observers are notified of the change.

Step 5: Challenges and Next Steps

5.1 Challenge: Detaching Observers

Currently, observers are always notified. What if you wanted to detach an observer? Try adding a detach method to the Subject struct. It would remove an observer from the observers vector.

5.2 Extending the Observer Pattern

The Observer Pattern can be extended to suit different needs:

  • Multiple Subjects: You could allow observers to subscribe to multiple subjects.
  • Different Types of Observers: You could have different types of observers that react differently to the same state change.

5.3 Use Cases

  • UI Frameworks: Observers could represent different parts of a UI that need to be updated when the underlying data changes.
  • Event-Driven Systems: Observers can be used to handle events in systems like messaging or network services.

Conclusion

In this article, we built an Observer Pattern in Rust from scratch, step by step. We:

  • Defined a Subject and Observer trait.
  • Added functionality for observers to subscribe to the subject and be notified when the state changes.
  • Demonstrated how observers react to state changes.

By using the Observer Pattern, we can decouple different parts of a system while ensuring they remain synchronized when state changes. This pattern is powerful for event-driven architectures and situations where multiple components need to respond to changes independently.

If you’re eager to explore more, try modifying the code to detach observers, add new types of observers, or handle more complex states! The Observer Pattern is a versatile tool to add to your design pattern toolkit.

Happy coding!

Read more