Designing with Swift: Chain of Responsibility Pattern

By /

Designing with Swift: Chain of Responsibility Pattern

Swift is a powerful, modern, and intuitive programming language that allows developers to design applications quickly and efficiently. One of the most useful design patterns that can be used when developing with Swift is the Chain of Responsibility pattern. This pattern can be used to create a linear sequence of objects, each responsible for handling a specific request. In this blog post, we’ll explore the Chain of Responsibility pattern and how it can be used in Swift applications.

The Chain of Responsibility pattern is a behavioral design pattern that allows multiple objects to handle a request. The objects in the chain are linked together in a linear sequence, each one responsible for handling a specific request. If a request cannot be handled by the first object, it is passed down the chain until it is handled or rejected. This pattern is often used in software development to decouple client objects from server objects, allowing for a more modular and extensible application design.

To illustrate the Chain of Responsibility pattern, let’s consider a simple example. Suppose we have an application that handles customer orders. We have three objects in the chain: the OrderHandler, the PaymentHandler, and the DeliveryHandler. The OrderHandler is responsible for processing the customer’s order. If the order is valid, the OrderHandler passes the order to the PaymentHandler, which is responsible for processing the payment. If the payment is successful, the PaymentHandler passes the order to the DeliveryHandler, which is responsible for delivering the order to the customer.

In Swift, we can implement this pattern using protocols and classes. Let’s start by defining a protocol for our chain of responsibility: 

protocol Handler {
   func handle(_ order: Order)
}

This protocol defines a single method, handle(), which is responsible for handling a given order. We can now define a concrete class for each object in the chain. The OrderHandler class might look something like this: 

class OrderHandler: Handler {
   private let paymentHandler: PaymentHandler
   private let deliveryHandler: DeliveryHandler

   init(paymentHandler: PaymentHandler, deliveryHandler: DeliveryHandler) {
      self.paymentHandler = paymentHandler
      self.deliveryHandler = deliveryHandler
   }

   func handle(_ order: Order) {
      // Process the order
      if order.isValid() {
         paymentHandler.handle(order)
      } else {
         // Handle invalid order
      }
   }
}

The OrderHandler class is responsible for processing the order and deciding whether it is valid or not. If the order is valid, it passes it to the PaymentHandler. The PaymentHandler class might look something like this: 

class PaymentHandler: Handler {
   private let deliveryHandler: DeliveryHandler

   init(deliveryHandler: DeliveryHandler) {
      self.deliveryHandler = deliveryHandler
   }

   func handle(_ order: Order) {
      // Process the payment
      if order.paymentIsSuccessful() {
         deliveryHandler.handle(order)
      } else {
         // Handle failed payment
      }
   }
}

The PaymentHandler is responsible for processing the payment and deciding whether it was successful or not. If the payment was successful, it passes the order to the DeliveryHandler. Finally, the DeliveryHandler class might look something like this: 

class DeliveryHandler: Handler {
   func handle(_ order: Order) {
      // Deliver the order
   }
}

The DeliveryHandler is responsible for delivering the order to the customer.

Now that we have defined our classes, we can create an instance of the OrderHandler and pass it the other two handlers: 

let paymentHandler = PaymentHandler(deliveryHandler: deliveryHandler)
let deliveryHandler = DeliveryHandler()
let orderHandler = OrderHandler(paymentHandler: paymentHandler, deliveryHandler: deliveryHandler)

We can now pass an order to the OrderHandler, and it will be processed and delivered as expected.

The Chain of Responsibility pattern is a powerful and flexible pattern that can be used to create extensible and maintainable applications. By decoupling objects in the chain, we can easily add new objects or modify existing ones without having to make changes to the other objects in the chain. This pattern can be used in many different contexts, from web requests to UI events.

In this blog post, we’ve explored the Chain of Responsibility pattern and how it can be used in Swift applications. We’ve seen how this pattern can be implemented using protocols and classes, and how it can be used to create a linear sequence of objects that can handle a specific request. With the Chain of Responsibility pattern, we can create extensible and maintainable applications that are easy to modify and extend.

Scroll to Top