职责链模式

---

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。通过这种模式将请求的发送者和请求的处理者解耦了。

在HTTP请求过来时，会有多个处理这进行处理，比如权限验证处理，日志处理，业务 处理等等。如果采用非职责链模式的话，我们客户端，会调用权限处理模块、日志 处理模块等去处理该请求，即定义中说的与多个请求矗立着耦合在一起。

采用责任链模式，即我们客户端，调用权限处理模块处理后，权限处理模块会自动调用它后面的处理者。每一个处理者都有下一个处理者的引用。这样，客户端，只需要要调用责任链中的第一个，就可以延着这条链传递，直到处理完毕。

image.png image.png

package main

import (
    "fmt"
)

func main() {
    //组装责任链
    logHandler := new(LogHandler)
    authoHandler := new(AuthoHandler)
    authoHandler.SetNext(logHandler)

    //责任链间传递的信息
    info := RequestInfo{Name: "test"}

    //客户调用责任链的入口责任
    authoHandler.Handle(info)
}

type RequestInfo struct {
    Name string
}

//责任链接口，所有的责任链实现者都应实现该接口
type Handler interface {
    //责任链中的处理方法
    Handle(info RequestInfo)
    //设置下一个
    SetNext(handler Handler)
    //获取下一个
    GetNext() (next Handler, ok bool)
}

//记录日志
type LogHandler struct {
    next Handler
}

func (handler *LogHandler) Handle(info RequestInfo) {
    fmt.Println("日志记录：", info.Name)
    //接着调用后续处理
    if next, ok := handler.GetNext(); ok {
        next.Handle(info)
    }
}

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

func (handler *LogHandler) GetNext() (next Handler, ok bool) {
    if handler.next != nil {
        return handler.next, true
    }
    return nil, false
}

//权限验证
type AuthoHandler struct {
    next Handler
}

func (handler *AuthoHandler) Handle(info RequestInfo) {
    fmt.Println("权限验证：", info.Name)
    if next, ok := handler.GetNext(); ok {
        next.Handle(info)
    }
}

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

func (handler *AuthoHandler) GetNext() (next Handler, ok bool) {
    if handler.next != nil {
        return handler.next, true
    }
    return nil, false
}