golang最简单的消息分发

simple根据不同的消息，用不同的函数处理

package main

import (
	"fmt"
	"sync"
)

// Message 表示要处理的消息
type Message struct {
	ID      int
	Content string
}

// Handler 表示消息处理程序的接口
type Handler interface {
	HandleMessage(Message)
}

// ConditionHandler 表示带有条件的消息处理程序
type ConditionHandler struct {
	Condition func(Message) bool
	Handler   Handler
}

// Dispatcher 表示消息调度器
type Dispatcher struct {
	mu       sync.Mutex
	handlers []ConditionHandler
}

// NewDispatcher 创建一个新的消息调度器
func NewDispatcher() *Dispatcher {
	return &Dispatcher{}
}

// AddHandler 添加一个带有条件的消息处理程序
func (d *Dispatcher) AddHandler(condition func(Message) bool, handler Handler) {
	d.mu.Lock()
	defer d.mu.Unlock()
	d.handlers = append(d.handlers, ConditionHandler{Condition: condition, Handler: handler})
}

// Dispatch 根据消息的条件选择合适的处理程序并处理消息
func (d *Dispatcher) Dispatch(message Message) {
	d.mu.Lock()
	defer d.mu.Unlock()

	for _, conditionHandler := range d.handlers {
		if conditionHandler.Condition(message) {
			conditionHandler.Handler.HandleMessage(message)
			return
		}
	}

	// 如果没有匹配的处理程序，默认处理方式
	fmt.Printf("No matching handler found for Message %d: %s\n", message.ID, message.Content)
}

// SimpleHandler 是一个简单的消息处理程序
type SimpleHandler struct {
	Name string
}

// HandleMessage 实现了 Handler 接口
func (h *SimpleHandler) HandleMessage(message Message) {
	fmt.Printf("[%s] Handling Message %d: %s\n", h.Name, message.ID, message.Content)
}

func main() {
	// 创建消息调度器
	dispatcher := NewDispatcher()

	// 添加带有条件的消息处理程序
	dispatcher.AddHandler(func(message Message) bool {
		// 条件：消息的 ID 是偶数
		return message.ID%2 == 0
	}, &SimpleHandler{Name: "EvenHandler"})

	dispatcher.AddHandler(func(message Message) bool {
		// 条件：消息的内容包含 "important"
		return message.Content == "important"
	}, &SimpleHandler{Name: "ImportantHandler"})

	// 模拟产生一些消息并进行分发
	messages := []Message{
		{ID: 1, Content: "Hello"},
		{ID: 2, Content: "World"},
		{ID: 3, Content: "This is important"},
	}

	for _, message := range messages {
		dispatcher.Dispatch(message)
	}
}

增加一点难度

把上面的Handler 抽离，定义一个 MessageContextHandlerGroup 数组，一个消息就可以处理多个不同的handler

// Message represents a message structure
type Message struct {
	Text string
}

// MessageContextHandler represents a function that can handle a message context
type MessageContextHandler func(ctx *MessageContext)

// MessageContextHandlerGroup represents a group of message context handlers
type MessageContextHandlerGroup []MessageContextHandler

// MessageContext represents a message processing context
type MessageContext struct {
	index           int
	messageHandlers MessageContextHandlerGroup
	*Message
}

// Next initiates the next message handler or starts the chain
func (c *MessageContext) Next() {
	c.index++
	for c.index <= len(c.messageHandlers) {
		handle := c.messageHandlers[c.index-1]
		handle(c)
		c.index++
	}
}

// matchFunc represents a function that checks if a message matches certain criteria
type matchFunc func(*Message) bool

// matchNode represents a node in the matching hierarchy
type matchNode struct {
	matchFunc matchFunc
	group     MessageContextHandlerGroup
}

// matchNodes is a collection of match nodes
type matchNodes []*matchNode

// MessageMatchDispatcher is a message dispatcher that performs matching based on criteria
type MessageMatchDispatcher struct {
	async      bool
	matchNodes matchNodes
}

// NewMessageMatchDispatcher creates a new instance of MessageMatchDispatcher
func NewMessageMatchDispatcher() *MessageMatchDispatcher {
	return &MessageMatchDispatcher{}
}

// OnMatch adds a matching condition and associated handler group to the dispatcher
func (dispatcher *MessageMatchDispatcher) OnMatch(matchFunc matchFunc, handlerGroup MessageContextHandlerGroup) {
	node := &matchNode{
		matchFunc: matchFunc,
		group:     handlerGroup,
	}
	dispatcher.matchNodes = append(dispatcher.matchNodes, node)
}

// Dispatch processes a message using the matching conditions and handler groups
func (dispatcher *MessageMatchDispatcher) Dispatch(msg *Message) {
	ctx := &MessageContext{
		Message: msg,
	}
	for _, node := range dispatcher.matchNodes {
		if node.matchFunc(msg) {
			ctx.messageHandlers = node.group
			ctx.Next()
			return
		}
	}
}
// Example usage
func main() {
	// Create a message match dispatcher
	dispatcher := NewMessageMatchDispatcher()

	// Define a matching condition and associated handler group
	textMatcher := func(msg *Message) bool {
		// Match messages with text
		return msg.Text == "Hello"
	}

	handlerGroup := MessageContextHandlerGroup{
		func(ctx *MessageContext) {
			// Handle messages with text
			fmt.Println("Received a text message:", ctx.Text)
		},
	}

	// Add the matching condition and handler group to the dispatcher
	dispatcher.OnMatch(textMatcher, handlerGroup)

	textMatcher2 := func(msg *Message) bool {
		// Match messages with text
		return msg.Text == "333"
	}

	handlerGroup2 := MessageContextHandlerGroup{
		func(ctx *MessageContext) {
			// Handle messages with text
			fmt.Println("Received a text message2:", ctx.Text)
		},
		func(ctx *MessageContext) {
			// Handle messages with text
			fmt.Println("eee2:", "eeee")
		},
	}
	dispatcher.OnMatch(textMatcher2, handlerGroup2)
	// Create a sample message
	myMessage := &Message{Text: "Hello"}
	myMessage1 := &Message{Text: "333"}
	myMessage2 := &Message{Text: "333"}
	// Use the dispatcher to dispatch the message
	dispatcher.Dispatch(myMessage)
	dispatcher.Dispatch(myMessage1)
	dispatcher.Dispatch(myMessage2)
}