In a complex system, some requests need to be processed by multiple objects, and these objects may have different processing logic. If we use conditional statements in each object to handle these requests, it will not only increase the complexity of the code, but also make the system difficult to maintain.Chain of Responsibility PatternThis problem is solved elegantly by passing the request along the processing chain to achieve decoupling between objects. This article will introduce in detail the concept of the responsibility chain pattern, the difference from other patterns, the problems it solves, the implementation in Golang, and the precautions in practical applications.

What is the Chain of Responsibility Pattern?

Chain of Responsibility Patternis aBehavioral design patterns, which allows a request to be passed along a chain until an object in the chain handles the request. When using this pattern,The request sender does not need to know which object will ultimately process the request., multiple objects have the opportunity to process the request, but only one object will ultimately process it.

Components of the Chain of Responsibility pattern

1. Handler Interface: Defines the interface for processing requests, which each handler should implement.
2. Concrete Handler: Implement the processor interface and encapsulate specific processing logic.
3. Chain establishment: Connect multiple processors in sequence to form a chain of responsibility.

The difference between the responsibility chain pattern and other patterns

1. Mediator Pattern

• Target: The mediator pattern manages communication between objects through mediator objects, avoiding objects from directly referencing each other.
• the difference: The Mediator pattern focuses on collaboration between objects, while the Chain of Responsibility pattern is used to pass requests sequentially until a certain object handles it.
  For more information about the intermediary model, please refer to the article:In-depth analysis of the implementation and application of the Mediator Pattern in Golang

2. Command Pattern

• Target: The command pattern encapsulates the request as an object and supports undo and redo of the request.
• the difference: The command pattern mainly encapsulates operations, while the chain of responsibility pattern is used to deliver requests in sequence.
  For more information about command mode, please refer to the article:In-depth analysis of Go design pattern Command Pattern (Command Pattern) implementation and application in Golang

3. Decorator Pattern

• Target: The Decorator pattern is used to dynamically add new functionality to an object.

• the difference: The chain of responsibility pattern is to process requests in sequence, while the decorator pattern is used to enhance object functionality.
  The decoration mode can be viewed in detail:In-depth analysis of the implementation and application of the Decorator Pattern in Golang

What problem does the chain of responsibility pattern solve?

1. Decoupling requests from handlers: The request sender does not need to know which handler will handle the request, it only needs to pass the request to the first object in the chain.
2. Dynamically expandable processing chain: Processors can be easily added or removed to improve the flexibility and scalability of the system.
3. Simplify conditional judgment: Avoid using a lot ofif-elseorswitch caseStatements improve the readability of the code.

Application scenarios of the responsibility chain pattern

1. Logging System: Logs of different levels (such as INFO, DEBUG, ERROR) can be passed to different log processors in sequence.
2. Permission verification: In the Web system, different permission verification logics can verify requests in sequence through the chain of responsibility model.
3. Form Validation: In the front-end or back-end system, the data verification of the form can be performed in sequence.
4. Middleware system: In a web framework, middleware can process requests in sequence through the chain of responsibility pattern.

Implementation of the Chain of Responsibility Pattern in Golang

Next, we will use a specificRequest logging systemThis example shows how to implement the chain of responsibility pattern in Golang. The system contains logs of different levels (such as INFO, DEBUG, and ERROR), and the log processor of each level checks the request in sequence and decides whether to process it.

Example: Log processing system

1. Define the handler interface

package main import "fmt" // Handler interface: defines methods for processing requests type Handler interface { SetNext(handler Handler) HandleRequest(level string, message string) }

2. Implement specific handlers

// BaseHandler structure: implements the general SetNext method and serves as the base class for other handlers type BaseHandler struct { next Handler } func (b *BaseHandler) SetNext(handler Handler) { b.next = handler } func (b *BaseHandler) HandleNext(level string, message string) { if b.next != nil { b.next.HandleRequest(level, message) } } // InfoHandler structure: handles INFO level logs type InfoHandler struct { BaseHandler } func (h *InfoHandler) HandleRequest(level string, message string) { if level == "INFO" { fmt.Printf("[INFO] %s\n", message) } else { h.HandleNext(level, message) } } // DebugHandler structure: handles DEBUG level logs type DebugHandler struct { BaseHandler } func (h *DebugHandler) HandleRequest(level string, message string) { if level == "DEBUG" { fmt.Printf("[DEBUG] %s\n", message) } else { h.HandleNext(level, message) } } // ErrorHandler structure: handles ERROR level logs type ErrorHandler struct { BaseHandler } func (h *ErrorHandler) HandleRequest(level string, message string) { if level == "ERROR" { fmt.Printf("[ERROR] %s\n", message) } else { h.HandleNext(level, message) } }

3. Sample code using the chain of responsibility pattern

func main() { // Create a log handler infoHandler := &InfoHandler{} debugHandler := &DebugHandler{} errorHandler := &ErrorHandler{} // Build a chain of responsibility: info -> debug -> error infoHandler.SetNext(debugHandler) debugHandler.SetNext(errorHandler) // Send log requests of different levels infoHandler.HandleRequest("INFO", "This is an info message.") infoHandler.HandleRequest("DEBUG", "This is a debug message.") infoHandler.HandleRequest("ERROR", "This is an error message.") }

Output

[INFO] This is an info message. [DEBUG] This is a debug message. [ERROR] This is an error message.

Code Analysis

1. Handler Interface: Defines methods for setting the next handler and processing the request.
2. BaseHandler Structure: AchievedSetNextandHandleNextMethod to set the next handler and pass the request.
3. InfoHandler, DebugHandler, ErrorHandler: Specific log processors that process INFO, DEBUG, and ERROR level logs respectively.
4. main function: Builds a responsibility chain for log processing and sends log requests at different levels.

Application in actual development

1. Middleware in Web Frameworks: In a web framework, middleware can process HTTP requests in sequence through the chain of responsibility pattern, such as authentication, logging, and error handling.
2. Permission verification system: Permission verification can be performed at different levels. If a certain level of verification fails, the request will be rejected.
3. Transaction Processing System: In a complex transaction system, different transaction steps can be executed sequentially through the chain of responsibility pattern.
4. Form Validation: The various validation logics of the form data can be processed in sequence through the chain of responsibility model.

Things to note when using the chain of responsibility pattern

1. Avoid chain lengths：A chain that is too long may cause performance problems, so the length of the responsibility chain needs to be reasonably controlled.
2. Chain order problem: Pay attention to the order of the processors, as different orders may affect the logic of the system.
3. Loop call: When building a chain of responsibility, ensure that no circular calls are generated, otherwise the program will enter an infinite loop.

Comparison between the chain of responsibility pattern and the command pattern

Summarize

Chain of Responsibility PatternIt is a very practical design pattern, suitable for scenarios where multiple objects are required to process requests in sequence. Through the chain of responsibility pattern, we can decouple requests from handlers and improve the flexibility and scalability of the system. In Golang, the implementation of the chain of responsibility pattern is very simple, and the request delivery can be easily realized through the combination of interfaces and structures. In actual development, the chain of responsibility pattern is widely used in scenarios such as logging systems, middleware, permission verification, and form verification. Reasonable use of the chain of responsibility pattern can improve the readability and maintainability of the code. If multiple objects are required to process requests in sequence in the project, the chain of responsibility pattern will be a very suitable choice.

Reference Links

• Design Patterns - Chain of Responsibility
• Go Design Patterns