책임연쇄(Chain of Responsibility) 패턴The Chain of Responsibility Pattern

The Chain of Responsibility Pattern

The Chain of Responsibility pattern is a behavioral design pattern that works by passing a request along a chain of objects, each of which can handle it. It’s commonly used in situations like the ones below.

Use Cases

• Logging systems
• Event handling systems
• Request filtering and processing (e.g. web server middleware)
• Approval processes (e.g. report approval)

Report Approval

Here, we’ll learn about the Chain of Responsibility pattern by implementing ‘report approval handling’.

The Situation

A report written by an employee gets final approval by going through the team lead and then the president. For reports that don’t need the president’s sign-off, the team lead sometimes gives the final approval.

The Report Class

First, let’s create the report class. A report has a content attribute and a required_approval_level attribute that indicates the approval level needed for final approval.

from enum import Enum, auto

class ApprovalLevel(Enum):
    TEAM_LEAD = auto()
    PRESIDENT = auto()

class Report:
    def __init__(self, content, required_approval_level: ApprovalLevel):
        self.content = content
        self.required_approval_level = required_approval_level

The Approver Interface

Next, we define the handler interface that processes requests. An approver has an approval level and a next approver (next_approver). Through this chain of next values, the report gets approved step by step.

from abc import ABC, abstractmethod
from enum import Enum, auto

class Approver(ABC):
    def __init__(self, level: ApprovalLevel):
        self.level = level
        self.next_approver = None

    def set_next(self, approver):
        self.next_approver = approver
        return approver

    def process_report(self, report):
        is_approved = False
        if self.level.value <= report.required_approval_level.value:
            is_approved = self.approve(report)

        if self.next_approver and is_approved:
            return self.next_approver.process_report(report)
        return False

    @abstractmethod
    def approve(self, report):
        pass

• set_next : Sets the next approver and returns that approver object. Used to build the chain
• process_report
  1. Checks the report’s required level against the approver’s authority.
  2. Depending on the approval result,
  3. Requests approval from the next approver
• approve : The specific approval logic for each approver

Each Approver

Now we create the approver classes, the concrete handlers that actually implement the handler interface above. Each approver implements approve.

from random import choice

class TeamLead(Approver):
    def __init__(self):
        super().__init__(ApprovalLevel.TEAM_LEAD)

    def approve(self, report):
        is_approved = choice([True, False])
        approve_msg = 'approved' if is_approved else 'rejected'

        print(f'The team lead {approve_msg} the ~{report.content}~ report')
        return is_approved

class President(Approver):
    def __init__(self):
        super().__init__(ApprovalLevel.PRESIDENT)

    def approve(self, report):
        is_approved = choice([True, False])
        approve_msg = 'finalized' if is_approved else 'rejected'

        print(f'The president {approve_msg} the ~{report.content}~ report')

        return is_approved

Building the Chain

Now we link the handler objects into a chain using set_next. What matters here is the order in which you connect the chain. Just as the team lead reviews the report first and the president signs off afterward, you need to decide carefully which object links to which.

You can create and add as many other approvers as you need and link them into the chain.

def setup_approval_chain():
    team_lead = TeamLead()
    president = President()

    team_lead.set_next(president)

    return team_lead

Client Code

The client creates a report object and passes it in. The report is passed along the chain to the next approver object to go through the approval process. If there’s no next approver, the chain ends.

There are many ways to implement this, depending on the handler logic. For a report like ‘Annual Strategic Plan’, with the process_report implementation above, if the team lead rejects it, the report never reaches the president and the chain simply ends there.

approval_chain = setup_approval_chain()

report1 = Report("Daily Work Report", ApprovalLevel.TEAM_LEAD)
report3 = Report("Annual Strategic Plan", ApprovalLevel.PRESIDENT)

approval_chain.process_report(report1)
approval_chain.process_report(report2)

The team lead rejected the ~Daily Work Report~ report

The team lead approved the ~Annual Strategic Plan~ report
The president finalized the ~Annual Strategic Plan~ report

Class Diagram

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'primaryColor': '#2a3844',
      'lineColor': '#fff',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#fff'
    }
  }
}%%

classDiagram
    direction LR

    class Approver {
        <<abstract>>

        -level: ApprovalLevel
        -next_approver: Approver
        +set_next(approver: Approver)
        +approve(report: Report)*
    }

    class TeamLead {
        +approve(report: Report)
    }
    class President {
        +approve(report: Report)
    }

    Approver <|-- TeamLead
    Approver <|-- President

    TeamLead o-- President

Wrapping Up

Structure

• Handler: Defines the interface for handling requests
• Concrete Handler: Implements the actual request handling
• Client: Sends the request to the first handler

How It Works

Each handler holds a reference to the next handler. When a request comes in, each handler decides whether it can handle it. It does its processing and passes the request on to the next handler. This continues until the end of the chain is reached or the request has been handled.

Things to Consider When Implementing

• Clearly define when the chain ends
• Design the order of the chain carefully, since it can matter

Things to Try Next

It could be fun to tackle other problems with the Chain of Responsibility pattern, too. 😊

• Coin calculator: Starting from the 500-won coin, calculate how many of each coin are needed for a given amount
• Logger: Depending on the given level, pass the log along escalating stages such as the console, a file, and email