Understanding The Chain of Responsibility Pattern by Nisal Pubudu Geek Culture

Table Of Content

• Chain of Responsibility Design Pattern - Base Classes and Interface
• Step 4
• Structure Classes
• Key Components

This class inherits from the Handler abstract class and implements the abstract DispatchNote method. Yes, the order of handlers in the Chain of Responsibility pattern can be changed dynamically. This is one of the pattern’s strengths, as it provides flexibility in how requests are handled. By changing the order of handlers, you can prioritize certain types of requests, add new handlers, or remove existing ones without affecting the rest of the chain. If improperly implemented, the Chain of Responsibility pattern can lead to infinite loops. This can happen if a request is passed along the chain without any handler being able to process it, and the chain is structured in such a way that the request cycles back to the start.

Chain of Responsibility Design Pattern - Base Classes and Interface

We know that we can have multiple catch blocks in a try-catch block code. Here every catch block is kind of a processor to process that particular exception. So when any exception occurs in the try block, its send to the first catch block to process. If the catch block is not able to process it, it forwards the request to next object in chain i.e next catch block. If even the last catch block is not able to process it, the exception is thrown outside of the chain to the calling program.

Step 4

The Chain of Responsibility pattern is commonly used in software systems where multiple objects may handle a request, but the exact handler isn’t known at compile time. This is a strict definition of the Responsibility concept in the GoF book. However, many implementations (such as loggers below, or UI event handling, or servlet filters in Java, etc.) allow several elements in the chain to take responsibility. Like many other behavioral design patterns, the Chain of Responsibility relies on transforming particular behaviors into stand-alone objects called handlers. In our case, each check should be extracted to its own class with a single method that performs the check. The request, along with its data, is passed to this method as an argument.

Structure Classes

Which handler will finally handle the request is unknown to the client. The Chain of Responsibility, Command, Mediator and Observer offers various ways of connecting senders and receivers of requests. In essence, the Chain of Responsibility pattern offers a flexible and modular way to handle requests in a way that promotes code reusability and maintains a clear separation of concerns. On the other hand, if the developer is asking for 5 days’ leave, then this can be handled by the Team Leader, and once the Team Leader handles this, he will not forward this request to the Project Leader. Extracting the logic for configuring the chain’s handlers helps keep the code clean and allows for easy changes.

Design Patterns in Python: A Series

But when it comes to the HR and Manager level, they will check the reason for requesting a leave. If an employee request up to 21 days, the HR will handle that and if its more than 21 days, the Manager will handle that. When they are handling the request, they will check if the reason is a regular, critical, or special one. The pattern lets you link several handlers into one chain and, upon receiving a request, “ask” each handler whether it can process it.

Design Patterns: Magic or Myth? - InfoQ.com

Design Patterns: Magic or Myth?.

Posted: Sat, 04 Jan 2014 08:00:00 GMT [source]

The first thing you hear is the robotic voice of the autoresponder. It suggests nine popular solutions to various problems, none of which are relevant to your case. You’ve just bought and installed a new piece of hardware on your computer.

Suppose we have to handle authentication requests with a chain of handlers. Depending on the type of authentication request, the appropriate handler in the chain handles it, or it is passed along the chain until a handler can process it or until the end of the chain is reached. These will be classes, and they should implement the EmployeeLeaveHandler abstract class and need to provide implementations for the ApplyLeave method.

Please look at the following diagram, which shows the reporting hierarchy in a software organization. The Team Leader reports to the Project Leader, and the Project Leader reports to HR. The Project Leader can approve leave for a maximum of 20 Days, and the HR can approve leave for 30 Days. First, as part of the DispatchNote() method, we calculate the number of 2000 notes to be dispatched.

Relations with Other Patterns

Similarly, supervisor will try to solve the issue and if he is able to then he will solve; else pass to manager. This request can be handled at front desk level, supervisor level or any higher level. Correct handler of request is only known at runtime when request is traversing at various levels. Extra handlers can be added or removed from chain without modifying the logic inside any of concrete handler. The sender is responsible for initiating requests, while the recipient is composed of a series of one or more objects. Each of these objects has the authority to decide whether to directly respond to the request or delegate it to the next object in the chain.

The example above minimizes the methods inside the Concrete Handler (increasing the cohesion) despite the constraint on a not null response. In this article, we’ll explain and demonstrate the Chain of Responsibility pattern. Indeed, this represents the contract of the Filter interface within the javax.servletpackage. A simple component can show brief contextual tooltips, as long as the component has some help text assigned. But more complex components define their own way of showing contextual help, such as showing an excerpt from the manual or opening a page in a browser.

During the next few months, you implemented several more of those sequential checks. It also shares the best practices, algorithms & solutions and frequently asked interview questions. To download the sourecode of above example application, click on below link. Let us now understand the Chain of Responsibility pattern in JavaScript with a code example. Let us implement the above-discussed example step by step using the Chain of Responsibility Design Pattern in C#. There are several modifications to the CoR – for example, combining this pattern with others, like the Factory or Decorator pattern to obtain an incremental construction/change of the Response.