Mastering the Chain of Responsibility Pattern in Go: A Hands‑On Guide

The Chain of Responsibility pattern decouples request senders from receivers by arranging multiple handler objects in a linked sequence, allowing each handler to either process the request or forward it to the next handler.

Pattern Structure

The pattern defines three main roles:

Handler : declares the request‑handling method and a method to set the next handler.

Concrete Handler : implements the handling logic; if it cannot process the request, it forwards it to the next handler.

Client : builds the chain and initiates the request.

Go Implementation

Using Go’s flexible interfaces, the pattern can be implemented concisely. First, define the Handler interface and the ConcreteHandler struct:

type Handler interface {
    HandleRequest(request string) bool
    SetNext(handler Handler)
}

type ConcreteHandler struct {
    next Handler
}

func (h *ConcreteHandler) HandleRequest(request string) bool {
    // processing logic
    // return true if handled, otherwise forward
    return false // placeholder: current handler does not handle
}

func (h *ConcreteHandler) SetNext(handler Handler) {
    h.next = handler
}

Then, assemble the chain and trigger the request in main:

func main() {
    handler1 := &ConcreteHandler{}
    handler2 := &ConcreteHandler{}
    handler1.SetNext(handler2) // set up the chain

    if !handler1.HandleRequest("request") {
        fmt.Println("request not handled")
    }
}

Typical Use Cases

When multiple objects may handle a request and the concrete handler is determined at runtime.

When the sender should not know which object will ultimately process the request.

When the set of potential handlers needs to be configurable dynamically.

Conclusion

The Chain of Responsibility pattern offers a flexible way to process requests, allowing handlers to be added, removed, or reordered without changing client code. In Go, interfaces and structs make the pattern straightforward to implement, resulting in more modular and extensible software.