Introduction to the Chain of Responsibility Pattern

Welcome back! Building on our exploration of various behavioral patterns, we will delve into the Chain of Responsibility Pattern in this lesson. This pattern allows a request to pass through a chain of handlers, giving multiple objects a chance to process the request. It's an excellent way to achieve loose coupling in your code by enabling the request to be processed by different handlers independently.

In this lesson, you will learn how to implement the Chain of Responsibility Pattern in Go. This pattern allows you to handle requests flexibly and dynamically. Specifically, you will learn to:

1. Create a Handler Interface: Define a common interface for all your handlers.
2. Implement Concrete Handlers: Learn to create specific handlers that deal with different levels of requests.
3. Set Up the Chain: Understand how to link these handlers together so that a request passes from one to another until it's handled.

Let's quickly go through an example to understand these concepts:

We start by defining a Request struct and a Handler interface. The Request struct contains the message and the level of the request, while the Handler interface defines the common methods that all handlers must implement:

type Request struct {
    message string
    level   int
}

type Handler interface {
    Handle(request Request) bool
    SetNext(handler Handler)
}

Next, we create a BaseHandler struct that implements the Handler interface. Notice, the BaseHandler contains a reference to the next handler in the chain by using the next field. The Handle method in the BaseHandler passes the request to the next handler if it exists:

// Base Handler
type BaseHandler struct {
    next Handler
}

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

func (h *BaseHandler) Handle(request Request) bool {
    if h.next != nil {
        return h.next.Handle(request)
    }
    return false
}

Now, we create specific handlers that extend the BaseHandler and implement the Handle method. In our example, we have FrontDeskHandler, ManagerHandler, and DirectorHandler. Each handler checks if it can handle the request based on the request level. If it can't, it passes the request to the next handler in the chain:

// Front Desk Handler
type FrontDeskHandler struct {
    BaseHandler
}

func (h *FrontDeskHandler) Handle(request Request) bool {
    if request.level == 1 {
        fmt.Println("Request handled by Front Desk")
        return true
    }
    return h.BaseHandler.Handle(request)
}

// Manager Handler
type ManagerHandler struct {
    BaseHandler
}

func (h *ManagerHandler) Handle(request Request) bool {
    if request.level == 2 {
        fmt.Println("Request handled by Manager")
        return true
    }
    return h.BaseHandler.Handle(request)
}

// Director Handler
type DirectorHandler struct {
    BaseHandler
}

func (h *DirectorHandler) Handle(request Request) bool {
    if request.level == 3 {
        fmt.Println("Request handled by Director")
        return true
    }
    return h.BaseHandler.Handle(request)
}

Finally, we set up the chain of handlers and initiate the request by calling the Handle method of the first handler in the chain:

func main() {
    frontDesk := &FrontDeskHandler{}
    manager := &ManagerHandler{}
    director := &DirectorHandler{}

    frontDesk.SetNext(manager)
    manager.SetNext(director)

    request := Request{message: "General inquiry", level: 1}
    frontDesk.Handle(request) // Output: Request handled by Front Desk

    request = Request{message: "Complaint", level: 2}
    frontDesk.Handle(request) // Output: Request handled by Manager

    request = Request{message: "High-level issue", level: 3}
    frontDesk.Handle(request) // Output: Request handled by Director
}

Notice how the request passes through the chain of handlers until it's processed. This is the essence of the Chain of Responsibility Pattern! As you can see, this pattern allows you to handle requests flexibly and dynamically by passing them through a chain of handlers. Therefore, the first request with level 1 is handled by the FrontDeskHandler, the second request with level 2 is handled by the ManagerHandler as front desk can't handle it, and the third request with level 3 is handled by the DirectorHandler as the manager can't handle it.

Let's understand the key components of the Chain of Responsibility Pattern:

1. Handler Interface: This interface defines the common methods that all handlers must implement. In our example, the Handle method processes the request, and the SetNext method sets the next handler in the chain.
2. BaseHandler: This is a base class that implements the Handler interface. It contains the logic to pass the request
3. Concrete Handlers: These are specific handlers that extend the BaseHandler and implement the Handle method. They decide whether to handle the request or pass it to the next handler in the chain. In our example, we have FrontDeskHandler, ManagerHandler, and DirectorHandler.
4. Client Code: This is where you set up the chain of handlers and initiate the request. In our example, we create instances of the handlers, link them together, and pass the request to the first handler in the chain.

Let's now understand the flow of the request in our example:

1. The Request object is passed to the FrontDeskHandler. If the request level matches the handler's level, it handles the request; otherwise, it passes the request to the next handler in the chain.
2. The ManagerHandler receives the request and checks if it can handle it. If not, it passes the request to the DirectorHandler.
3. The DirectorHandler processes the request if it matches its level.
4. If none of the handlers can handle the request, it remains unhandled.
5. The client code initiates the request by calling the Handle method of the first handler in the chain.