Applying Behavioral Patterns in Scala

Introduction

Welcome to the fourth and final lesson of our course about Behavioral Patterns in Scala! 🎉 In this final lesson, we'll explore how to apply the behavioral design patterns you've learned about — specifically the Command, Observer, and Strategy patterns — to a real-world scenario by designing a simple chat application. We’ve covered each pattern individually in previous lessons, but now we'll combine them to build an interactive and dynamic application, showcasing the power of collaboration between these patterns. Let's dive in!

Recap of Behavioral Design Patterns

Before we begin designing our chat application, let's quickly revisit the key behavioral design patterns we'll be using: Command Pattern : Encapsulates a request as an object, allowing clients to parameterize and queue requests, and support undoable operations. Observer Pattern : Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. Strategy Pattern : Defines a family of algorithms, encapsulates each one, and makes them interchangeable. The strategy lets the algorithm vary independently from the clients that use it; that is, clients can choose the algorithm to use at runtime. These patterns help create flexible and loosely coupled designs, enabling us to address complex programming challenges effectively.

Designing the Chat Application

Our goal is to build a simple chat application where users can send messages to a chat room, and all registered users receive notifications of new messages. We'll use the Command pattern to encapsulate message sending, the Observer pattern for user notifications, and the Strategy pattern to process messages differently (e.g., plain text or encrypted). Let's see how each pattern fits into our application: Command Pattern : We'll create command objects to represent user actions (sending messages). Observer Pattern : Users will subscribe to the chat room to receive messages. Strategy Pattern : We'll process messages using different strategies before broadcasting.

Strategy Pattern: The `MessageProcessor`

First, to allow different ways of processing messages, we implement the Strategy pattern through a MessageProcessor trait and concrete implementations: Scala // Strategy trait for processing messages trait MessageProcessor: def processMessage(message: String): String // Concrete strategy for plain text processing class PlainTextProcessor extends MessageProcessor: def processMessage(message: String): String = message // Concrete strategy for encrypted message processing class EncryptedProcessor extends MessageProcessor: def processMessage(message: String): String = message.reverse The PlainTextProcessor returns the message as is. The EncryptedProcessor reverses the message to simulate encryption. This Strategy pattern allows us to change the message processing algorithm at runtime, providing flexibility in how messages are handled. In other words, by using the Strategy pattern we can introduce new message processing algorithms without modifying existing code; this promotes the Open/Closed Principle, one of the SOLID principles, making our application more maintainable and extensible.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Observer Pattern: The `Subject` Trait and the `ChatRoom` Class

The ChatRoom class serves as the subject in the Observer pattern. It maintains a list of observers (the users) and notifies them of new messages. We'll define a Subject trait to represent this role, and a ChatRoom class implementing this trait:

Scala

// Subject trait defining methods for managing observers
trait Subject:
  def addObserver(observer: Observer): Unit
  def removeObserver(observer: Observer): Unit
  def notifyObservers(message: String): Unit

// ChatRoom class acting as the subject in Observer pattern
class ChatRoom extends Subject:
  private var observers = List[Observer]()

  // Register a new observer
  def addObserver(observer: Observer): Unit =
    observers = observer :: observers

  // Remove an observer
  def removeObserver(observer: Observer): Unit =
    observers = observers.filterNot(_ == observer)

  // Notify all observers with a message
  def notifyObservers(message: String): Unit =
    observers.foreach(_.update(message))

  // Display a message in the chat room
  def showMessage(message: String): Unit =
    println(s"ChatRoom displays: $message")

// Subject trait defining methods for managing observers
trait Subject:
  def addObserver(observer: Observer): Unit
  def removeObserver(observer: Observer): Unit
  def notifyObservers(message: String): Unit

// ChatRoom class acting as the subject in Observer pattern
class ChatRoom extends Subject:
  private var observers = List[Observer]()

  // Register a new observer
  def addObserver(observer: Observer): Unit =
    observers = observer :: observers

  // Remove an observer
  def removeObserver(observer: Observer): Unit =
    observers = observers.filterNot(_ == observer)

  // Notify all observers with a message
  def notifyObservers(message: String): Unit =
    observers.foreach(_.update(message))

  // Display a message in the chat room
  def showMessage(message: String): Unit =
    println(s"ChatRoom displays: $message")

The addObserver and removeObserver methods manage the list of subscribed users, while notifyObservers sends updates to all users.

By implementing the Subject interface, ChatRoom clearly defines its observable behavior. This abstraction encourages reuse and simplifies the management of observers, contributing to a cleaner and more maintainable codebase.

Introduction

Recap of Behavioral Design Patterns

Designing the Chat Application

Strategy Pattern: The `MessageProcessor`

Join the 1M+ learners on CodeSignal

Observer Pattern: The `Observer` Trait and the `User` Class

Observer Pattern: The `Subject` Trait and the `ChatRoom` Class

Command Pattern: The `Command` Trait

Command Pattern: The `ChatCommand` Class

Putting It All Together: The Main Application

Conclusion