Design Patterns in Swift: Mediator Pattern Explained

By /

Design Patterns in Swift: Mediator Pattern Explained

Design Patterns are essential for software development, as they help to improve the quality of code and make it more maintainable. They provide developers with the ability to create complex systems by using proven solutions to common problems. The Mediator Pattern is one of the most important design patterns used in software engineering. It is used to simplify communication between objects and to decouple their behavior from each other.

The Mediator Pattern is a behavioral design pattern that defines a one-to-many relationship between objects. It provides a centralized point of communication between objects, which allows them to interact without knowing anything about each other. This means that the objects can be completely decoupled, so that changes in one object will not affect the other objects.

In this article, we will discuss the Mediator Pattern and explain how to implement it in Swift. We will also look at an example of how the pattern can be used to improve the design of an application.

The Mediator Pattern is used to create a single point of communication between objects. This point of communication is known as the mediator. The mediator acts as a broker between objects, allowing them to communicate without knowing anything about each other. This decouples the objects and makes it easier to modify and maintain the code.

The mediator can also be used to control the flow of communication between objects. For example, if one object needs to send a message to another object, it can do so through the mediator. The mediator can then decide whether or not the message should be sent, and if so, how it should be sent. This allows the system to be more flexible and allows the objects to be modified without affecting the other objects.

To implement the Mediator Pattern in Swift, we need to define a protocol that all objects can conform to. This protocol should define the methods that the mediator will use to communicate with the objects. For example, we could define a protocol like this:

protocol MediatorProtocol {
    func send(message: Any, from: Any)
}

The protocol defines a single method, send(), which takes two parameters: a message and a sender. The message can be any type of data, such as a string, integer, or custom object. The sender is the object that is sending the message.

Now that we have defined the protocol, we can create a mediator class that conforms to it. This class will act as the broker between the objects. Here is an example of a mediator class in Swift:

class Mediator: MediatorProtocol {
    private var objects = [Any]()
    
    func register(_ object: Any) {
        objects.append(object)
    }
    
    func send(message: Any, from: Any) {
        for object in objects {
            if object !== from {
                object.receive(message: message)
            }
        }
    }
}

The mediator class has two methods: register() and send(). The register() method is used to add objects to the mediator. The send() method is used to send a message from one object to all of the other objects.

Now that we have defined the mediator, we need to define a protocol for the objects that will be communicating with each other. The protocol should define a receive() method that the objects can use to receive messages from the mediator. Here is an example of such a protocol:

protocol ReceiverProtocol {
    func receive(message: Any)
}

Now that we have defined the protocols, we can create objects that conform to them. Here is an example of two objects that use the mediator to communicate:

class ObjectA: ReceiverProtocol {
    private let mediator: MediatorProtocol
    
    init(mediator: MediatorProtocol) {
        self.mediator = mediator
        mediator.register(self)
    }
    
    func send(message: Any) {
        mediator.send(message: message, from: self)
    }
    
    func receive(message: Any) {
        print("ObjectA received: \(message)")
    }
}

class ObjectB: ReceiverProtocol {
    private let mediator: MediatorProtocol
    
    init(mediator: MediatorProtocol) {
        self.mediator = mediator
        mediator.register(self)
    }
    
    func send(message: Any) {
        mediator.send(message: message, from: self)
    }
    
    func receive(message: Any) {
        print("ObjectB received: \(message)")
    }
}

The objects have a reference to the mediator and register themselves when they are created. They also have a send() method which is used to send messages to other objects via the mediator. Finally, they have a receive() method which is used to receive messages from the mediator.

Now that we have created the objects and the mediator, we can use them to communicate. Here is an example of how to do this:

let mediator = Mediator()
let objectA = ObjectA(mediator: mediator)
let objectB = ObjectB(mediator: mediator)

objectA.send(message: "Hello World!")
// ObjectA sent: Hello World!
// ObjectB received: Hello World!

In this example, we have used the Mediator Pattern to create a simple system for communication between objects. The objects are decoupled, so changes to one object will not affect the other objects. The mediator also allows us to control the flow of communication between objects, making the system more flexible.

The Mediator Pattern is a powerful design pattern that can be used to improve the design of an application. It allows objects to be decoupled and simplifies communication between them. By using the Mediator Pattern, we can create systems that are more maintainable and easier to modify.

Scroll to Top