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!

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.

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.

First, to allow different ways of processing messages, we implement the Strategy pattern through a MessageProcessor trait and concrete implementations:

Scala
Copy to clipboard
1// Strategy trait for processing messages
2trait MessageProcessor:
3  def processMessage(message: String): String
4
5// Concrete strategy for plain text processing
6class PlainTextProcessor extends MessageProcessor:
7  def processMessage(message: String): String = message
8
9// Concrete strategy for encrypted message processing
10class EncryptedProcessor extends MessageProcessor:
11  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.

Next, we'll formalize the Observer pattern by defining an Observer trait, which will be implemented by the User class. Users subscribe to the chat room and receive updates when new messages are posted. Here's how we can implement this:

Scala
Copy to clipboard
1// Observer trait defining the update method
2trait Observer:
3  def update(message: String): Unit
4  
5// User class acting as an observer
6case class User(name: String) extends Observer:
7  // Method called when a message is received
8  def update(message: String): Unit =
9    println(s"$name received message: $message")

Here, the update method is called when the user receives a new message notification.

In this example, the Observer pattern allows us to add or remove User instances without altering the ChatRoom's code. It promotes loose coupling between the subject (ChatRoom) and observers (Users), enhancing flexibility and scalability.

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
Copy to clipboard
1// Subject trait defining methods for managing observers
2trait Subject:
3  def addObserver(observer: Observer): Unit
4  def removeObserver(observer: Observer): Unit
5  def notifyObservers(message: String): Unit
6
7// ChatRoom class acting as the subject in Observer pattern
8class ChatRoom extends Subject:
9  private var observers = List[Observer]()
10
11  // Register a new observer
12  def addObserver(observer: Observer): Unit =
13    observers = observer :: observers
14
15  // Remove an observer
16  def removeObserver(observer: Observer): Unit =
17    observers = observers.filterNot(_ == observer)
18
19  // Notify all observers with a message
20  def notifyObservers(message: String): Unit =
21    observers.foreach(_.update(message))
22
23  // Display a message in the chat room
24  def showMessage(message: String): Unit =
25    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.

At this point, we're missing only the Command pattern. We'll define the Command trait, which encapsulates actions as objects. This trait serves as the base for all command objects in our application:

Scala
Copy to clipboard
1// Command trait representing an executable action
2trait Command:
3  def execute(): Unit

In our chat application, commands will represent actions like sending a message.

Now, we'll create the ChatCommand class, which implements the Command trait. This class encapsulates the action of sending a message to the chat room.

Scala
Copy to clipboard
1// Command class encapsulating the action of sending a message
2class ChatCommand(chatRoom: ChatRoom, message: String, processor: MessageProcessor) extends Command:
3  def execute(): Unit =
4    // Process the message using the strategy
5    val processedMessage = processor.processMessage(message)
6    // Display the message in the chat room
7    chatRoom.showMessage(processedMessage)
8    // Notify all observers with the processed message
9    chatRoom.notifyObservers(processedMessage)

In the execute method, we process the message using the MessageProcessor strategy before displaying it and notifying observers.

The Command pattern decouples the object that invokes the operation from the one that knows how to perform it. This separation allows for greater flexibility in extending and maintaining the application, such as adding new commands or features without modifying existing code.

Finally, we'll integrate all components in our main function, demonstrating how the patterns work together.

Scala
Copy to clipboard
1// Main application integrating all patterns
2@main def main(): Unit =
3  val chatRoom = ChatRoom()
4
5  // Create users and register them as observers
6  val user1 = User("Alice")
7  val user2 = User("Bob")
8
9  chatRoom.addObserver(user1)
10  chatRoom.addObserver(user2)
11
12  // Choose the message processing strategy
13  val processor: MessageProcessor = EncryptedProcessor()
14
15  // Create a command to send a message
16  val chatCommand: Command = ChatCommand(chatRoom, "Hello, everyone!", processor)
17
18  // Execute the command
19  chatCommand.execute()

In the main application:

• We create a ChatRoom instance, which acts as the subject in the Observer pattern.
• We create two User instances and add them as observers to the chat room.
• We choose a MessageProcessor strategy (EncryptedProcessor in this case), demonstrating the Strategy pattern.
• We create a ChatCommand, encapsulating the action of sending a message, following the Command pattern.
• We execute the command, which processes the message, displays it, and notifies all users.

By integrating the Command, Observer, and Strategy patterns, we've built a simple yet effective chat application. This demonstrates how combining design patterns can create modular, flexible, and maintainable software solutions. Understanding how these patterns interact helps in designing systems that are easy to extend and adapt to new requirements. The use of these patterns:

• Enhances Flexibility: The application can easily switch strategies for processing messages or extend with new commands.
• Promotes Maintainability: Clear separation of concerns makes the codebase easier to understand and modify.
• Facilitates Scalability: Adding new users or message processing algorithms requires minimal changes.

Keep experimenting with these patterns to strengthen your Scala programming skills! 🦾