笔记大全

go如何实现职责链模式

更新时间：2023-11-24

什么是职责链模式

职责链模式（Chain of Responsibility Pattern），又叫责任链模式。它是一种对象行为型模式，其主要功能是将多个接收者对象连成一条链，让请求在链中依次传递，直到有一个对象能够处理该请求为止。“责任链”名字中的“链”表明了这种联系的连贯性和高度，而“责任”则表示这种联系的责任传递转移和分担。

摘自菜鸟教程。

职责链模式的实现

职责链模式的实现需要用到一个链表，将多个对象串联在一起。在 Go 语言中，职责链模式的实现会用到代理模式（Proxy Pattern）和反射（Reflect），下面我们分别介绍一下。

使用代理模式的职责链模式示例

type handler interface {
    setNextHandler(next handler)
    handle(req int) string
}

type baseHandler struct {
    next handler
}

func (bh *baseHandler) setNextHandler(next handler) {
    bh.next = next
}

func (bh *baseHandler) handle(req int) string {
    if bh.next != nil {
        return bh.next.handle(req)
    }
    return ""
}

type concreteHandlerA struct {
    baseHandler
}

func (cha *concreteHandlerA) handle(req int) string {
    if req < 10 {
        return fmt.Sprintf("%d handled by concreteHandlerA\n", req)
    }
    return cha.baseHandler.handle(req)
}

type concreteHandlerB struct {
    baseHandler
}

func (chb *concreteHandlerB) handle(req int) string {
    if req >= 10 && req < 20 {
        return fmt.Sprintf("%d handled by concreteHandlerB\n", req)
    }
    return chb.baseHandler.handle(req)
}

type concreteHandlerC struct {
    baseHandler
}

func (chc *concreteHandlerC) handle(req int) string {
    if req >= 20 {
        return fmt.Sprintf("%d handled by concreteHandlerC\n", req)
    }
    return chc.baseHandler.handle(req)
}

func main() {
    chc := &concreteHandlerC{}
    chb := &concreteHandlerB{}
    cha := &concreteHandlerA{}

    cha.setNextHandler(chb)
    chb.setNextHandler(chc)

    for i := 5; i < 25; i += 5 {
        fmt.Printf("%s", cha.handle(i))
    }
}

使用反射的职责链模式示例

type handler interface {
    handle(req int) string
}

type concreteHandler struct {
    nextPtr *handler
}

func (ch *concreteHandler) setNextHandler(next handler) {
    v := reflect.ValueOf(&ch.nextPtr).Elem()
    v.Set(reflect.ValueOf(&next))
}

func (ch *concreteHandler) handle(req int) string {
    if ch.nextPtr != nil {
        next := *ch.nextPtr
        return next.handle(req)
    }
    return ""
}

func newConcreteHandler() *concreteHandler {
    return &concreteHandler{}
}

func main() {
    chc := newConcreteHandler()
    chb := newConcreteHandler()
    cha := newConcreteHandler()

    cha.setNextHandler(concreteHandler{&chb})
    chb.setNextHandler(concreteHandler{&chc})

    for i := 5; i < 25; i += 5 {
        fmt.Printf("%s", cha.handle(i))
    }
}

总结

职责链模式是一种比较常用的设计模式，它将多个接收者对象连成一条链，让请求在链中依次传递，直到有一个对象能够处理该请求为止。在 Go 语言中，职责链模式的实现采用了代理模式和反射两种方式。代理模式的方式比较清晰易懂，而反射的方式则比较灵活。需要根据具体的情况，选择相应的方式来实现职责链模式。

c语言编程笔录