Collapsing an Inheritance Hierarchy into a Chain-of-Command in PHP

In this blog post, we are going to learn how can we Collapsing an Inheritance Hierarchy into a Chain-of-Command in PHP.

The Chain of Responsibility pattern allows multiple objects to handle a request, each object deciding whether to handle it or pass it along. This can simplify complex inheritance hierarchies and make the code more flexible.

Photo by Ben Griffiths on Unsplash

You have a class hierarchy for handling requests:

abstract class RequestHandler {
    abstract public function handle($request);
}

class RequestHandlerA extends RequestHandler {
    public function handle($request) {
        if ($request === 'A') {
            echo "Handled by A";
        } else {
            parent::handle($request); // Pass to next handler
        }
    }
}

class RequestHandlerB extends RequestHandler {
    public function handle($request) {
        if ($request === 'B') {
            echo "Handled by B";
        } else {
            parent::handle($request);
        }
    }
}

Refactored into a Chain of Command:

abstract class Handler {
    protected $nextHandler;

    public function setNext(Handler $handler) {
        $this->nextHandler = $handler;
        return $handler;
    }

    public function handle($request) {
        if ($this->nextHandler) {
            $this->nextHandler->handle($request);
        }
    }
}

class HandlerA extends Handler {
    public function handle($request) {
        if ($request === 'A') {
            echo "Handled by A";
        } else {
            parent::handle($request);
        }
    }
}

class HandlerB extends Handler {
    public function handle($request) {
        if ($request === 'B') {
            echo "Handled by B";
        } else {
            parent::handle($request);
        }
    }
}

// Setup the chain of responsibility
$handlerA = new HandlerA();
$handlerB = new HandlerB();
$handlerA->setNext($handlerB);

// Usage
$handlerA->handle('B'); // Handled by B

In this case, each handler checks whether it can process the request. If not, it passes the request to the next handler in the chain. This reduces the complexity of inheritance and makes the chain dynamic.

Benefits of using chain of command

Collapsing an inheritance hierarchy into a Chain-of-Command design pattern offers several advantages, especially in terms of flexibility, maintainability, and scalability. Let’s break down the benefits of using a Chain of Command over a deep inheritance hierarchy:

1. Improved Flexibility

• Chain-of-Command: Each handler in the chain can dynamically determine whether to process the request or pass it to the next handler. This allows you to easily modify, add, or reorder responsibilities without changing the overall structure.
• Inheritance Hierarchy: Inheritance creates a static and rigid structure where behavior is locked into a specific class. Extending or modifying this structure often requires making changes in multiple places, which can lead to tight coupling and complexity.

2. Decoupling of Components

• Chain-of-Command: This pattern decouples senders and receivers by allowing multiple objects to process a request. The sender doesn’t need to know which specific object will handle the request.
• Inheritance Hierarchy: In an inheritance model, classes are tightly coupled since behavior is passed down the hierarchy. Changing a superclass may unintentionally affect all its subclasses.

3. Easier to Extend and Modify

• Chain-of-Command: Adding or removing handlers in a chain doesn’t require altering existing code. You can introduce new handlers without touching the existing ones, adhering to the Open/Closed Principle (code is open for extension but closed for modification).
• Inheritance Hierarchy: Extending an inheritance hierarchy often requires modifying existing classes or overriding methods, which can lead to fragility and increased complexity over time.

4. Avoiding Deep Inheritance and Complexity

• Chain-of-Command: Flattening a deep inheritance hierarchy into a chain simplifies the structure. It helps avoid the diamond problem or confusion from multiple layers of inheritance, which can make it hard to track the flow of control and behavior.
• Inheritance Hierarchy: A deep hierarchy can become cumbersome as it grows. It can be difficult to understand which class is responsible for which functionality, and resolving bugs or making changes may require navigating through multiple levels of inheritance.

5. Better Control Over Responsibility

• Chain-of-Command: Each handler in the chain can focus on a specific responsibility. It can decide whether to handle the request, modify it, or pass it to the next handler. This gives more granular control over how and when responsibilities are handled.
• Inheritance Hierarchy: In an inheritance structure, responsibilities are inherited, and it may not always be clear which class is responsible for handling specific behavior. Subclasses may have to override behavior they don’t need or inherit functionality that is not relevant to them.

6. Increased Reusability

• Chain-of-Command: Handlers can be reused in different contexts or chains since they are not tightly bound to a specific hierarchy. You can easily compose different chains by rearranging or substituting handlers.
• Inheritance Hierarchy: Reusability in an inheritance hierarchy is limited, as classes often inherit unwanted behavior or rely on specific parent class implementations. This can lead to code duplication or unnecessary complexity.

7. Reduction of Redundant Code

• Chain-of-Command: The same handler can be reused in different chains, reducing the need for duplicate code. You avoid the issue of duplicating logic across multiple levels of a hierarchy.
• Inheritance Hierarchy: Inheritance often leads to code duplication when subclasses need slightly different behavior but have to override methods from their superclass.

8. Easier to Test

• Chain-of-Command: Since each handler in the chain is self-contained, testing becomes easier. Each handler can be tested individually, ensuring that specific behavior works as intended.
• Inheritance Hierarchy: Testing an inheritance hierarchy can be complex, especially when testing interactions between classes. Changes in a parent class can cause unexpected side effects in child classes, making it harder to isolate and test individual behaviors.

9. Handling Requests Dynamically

• Chain-of-Command: Requests can be handled dynamically based on conditions. Each handler can decide at runtime whether to process a request or pass it along the chain, allowing for more adaptive systems.
• Inheritance Hierarchy: Inheritance requires the behavior to be defined at compile time, making it harder to adapt to dynamic situations or conditions without overriding methods in subclasses.