行为型 职责链模式

为什么需要职责链模式

职责链模式将请求和处理解耦,让多个对象都有机会处理同一个请求。设计上面可以short circuit,也就是如果有一个处理能接受请求就可以返回了,也可以设计成用户注册的所有处理器都能处理请求。

实现

一般来说各个处理器都实现同一个接口,有一个Chain类负责添加处理器,并且触发处理器。接受类(处理类)实现同一个接口。

简化来说,因为golang也接受函数也是变量,func类型也是可以接受,不必采用接口而是直接接受func type也是可以的。我两种实现都提供了例子。

go.mod

module responsibility

go 1.13

responsibility.go

package responsibility

import "fmt"

type IHandler interface {
	handle(int) bool
}

type Chain struct {
	handlers     []IHandler
	handlerFuncs []func(int) bool
}

func (chain *Chain) AddHandler(handler IHandler) {
	chain.handlers = append(chain.handlers, handler)
}
func (chain *Chain) AddHanderFunc(f func(int) bool) {
	chain.handlerFuncs = append(chain.handlerFuncs, f)
}
func (chain *Chain) HandleByFunc(count int) {
	for _, f := range chain.handlerFuncs {
		if f(count) {
			break
		}
	}
}
func (chain *Chain) Handle(count int) {
	for _, handler := range chain.handlers {
		if handler.handle(count) {
			break
		}
	}
}

type AliceHandler struct{}

func (hanlder *AliceHandler) handle(count int) bool {
	if count < 10 {
		fmt.Println("Intercepted by Alice")
		return true
	}
	return false
}

type BobHandler struct {
}

func (handler *BobHandler) handle(count int) bool {
	if count >= 10 {
		fmt.Println("Intercepted by Bob")
		return true
	}
	return false
}

responsibility_test.go

package responsibility_test

import (
	"fmt"
	"responsibility"
)

func ExampleChain_AddHandler() {
	chain := &responsibility.Chain{}
	chain.AddHandler(&responsibility.AliceHandler{})
	chain.AddHandler(&responsibility.BobHandler{})
	chain.Handle(1)
	// output:
	// Intercepted by Alice
}

func ExampleChain_AddHanderFunc() {
	chain := &responsibility.Chain{}
	chain.AddHanderFunc(func(count int) bool {
		fmt.Println("Custom func")
		return true
	})
	chain.HandleByFunc(1)
	// output:
	// Custom func
}

执行: go test responsibility -v

Previous
Next