Go语言设计模式：行为型模式-洪萨配资

Go语言设计模式：行为型模式

一、行为型模式概述

行为型模式关注对象之间的通信和职责分配，描述对象如何协作以及如何分配职责。

Go语言中的行为型模式特点

接口驱动：通过接口定义行为契约
并发安全：考虑并发场景下的协作
组合实现：通过组合而非继承实现行为复用

二、策略模式

策略模式定义一系列算法，把它们封装起来，并使它们可以互相替换。

package strategy type Strategy interface { Execute(a, b int) int } type AddStrategy struct{} func (a *AddStrategy) Execute(x, y int) int { return x + y } type SubtractStrategy struct{} func (s *SubtractStrategy) Execute(x, y int) int { return x - y } type MultiplyStrategy struct{} func (m *MultiplyStrategy) Execute(x, y int) int { return x * y } type Context struct { strategy Strategy } func (c *Context) SetStrategy(strategy Strategy) { c.strategy = strategy } func (c *Context) ExecuteStrategy(a, b int) int { return c.strategy.Execute(a, b) }

三、观察者模式

观察者模式定义对象间的一对多依赖，当一个对象状态改变时，所有依赖它的对象都会收到通知。

package observer type Observer interface { Update(message string) } type Subject interface { Attach(observer Observer) Detach(observer Observer) Notify(message string) } type ConcreteSubject struct { observers []Observer } func (s *ConcreteSubject) Attach(observer Observer) { s.observers = append(s.observers, observer) } func (s *ConcreteSubject) Detach(observer Observer) { for i, obs := range s.observers { if obs == observer { s.observers = append(s.observers[:i], s.observers[i+1:]...) break } } } func (s *ConcreteSubject) Notify(message string) { for _, observer := range s.observers { observer.Update(message) } } type ConcreteObserver struct { name string } func (o *ConcreteObserver) Update(message string) { println(o.name + " received: " + message) }

四、命令模式

命令模式将请求封装成对象，使你可以用不同的请求对客户进行参数化。

package command type Command interface { Execute() Undo() } type Receiver struct{} func (r *Receiver) Action() { println("Receiver action") } func (r *Receiver) ReverseAction() { println("Receiver reverse action") } type ConcreteCommand struct { receiver *Receiver } func (c *ConcreteCommand) Execute() { c.receiver.Action() } func (c *ConcreteCommand) Undo() { c.receiver.ReverseAction() } type Invoker struct { history []Command } func (i *Invoker) SetCommand(command Command) { command.Execute() i.history = append(i.history, command) } func (i *Invoker) Undo() { if len(i.history) > 0 { command := i.history[len(i.history)-1] command.Undo() i.history = i.history[:len(i.history)-1] } }

五、迭代器模式

迭代器模式提供一种方法顺序访问聚合对象中的各个元素，而又不暴露该对象的内部表示。

package iterator type Iterator interface { HasNext() bool Next() interface{} } type Iterable interface { CreateIterator() Iterator } type ConcreteIterator struct { collection []interface{} index int } func (i *ConcreteIterator) HasNext() bool { return i.index < len(i.collection) } func (i *ConcreteIterator) Next() interface{} { if i.HasNext() { item := i.collection[i.index] i.index++ return item } return nil } type ConcreteCollection struct { items []interface{} } func (c *ConcreteCollection) CreateIterator() Iterator { return &ConcreteIterator{collection: c.items} } func (c *ConcreteCollection) Add(item interface{}) { c.items = append(c.items, item) }

六、模板方法模式

模板方法模式定义一个算法的骨架，将一些步骤延迟到子类中实现。

package template type AbstractClass interface { PrimitiveOperation1() PrimitiveOperation2() TemplateMethod() } type ConcreteClass struct{} func (c *ConcreteClass) PrimitiveOperation1() { println("Primitive operation 1") } func (c *ConcreteClass) PrimitiveOperation2() { println("Primitive operation 2") } func (c *ConcreteClass) TemplateMethod() { c.PrimitiveOperation1() c.PrimitiveOperation2() println("Template method completed") }

七、状态模式

状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

package state type State interface { Handle(context *Context) } type ConcreteStateA struct{} func (s *ConcreteStateA) Handle(context *Context) { println("Handling in state A") context.SetState(&ConcreteStateB{}) } type ConcreteStateB struct{} func (s *ConcreteStateB) Handle(context *Context) { println("Handling in state B") context.SetState(&ConcreteStateA{}) } type Context struct { state State } func (c *Context) SetState(state State) { c.state = state } func (c *Context) Request() { c.state.Handle(c) }

八、责任链模式

责任链模式使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

package chain type Handler interface { SetNext(handler Handler) Handler Handle(request string) string } type AbstractHandler struct { next Handler } func (h *AbstractHandler) SetNext(handler Handler) Handler { h.next = handler return handler } func (h *AbstractHandler) Handle(request string) string { if h.next != nil { return h.next.Handle(request) } return "No handler found" } type ConcreteHandlerA struct { AbstractHandler } func (h *ConcreteHandlerA) Handle(request string) string { if request == "A" { return "Handled by Handler A" } return h.AbstractHandler.Handle(request) } type ConcreteHandlerB struct { AbstractHandler } func (h *ConcreteHandlerB) Handle(request string) string { if request == "B" { return "Handled by Handler B" } return h.AbstractHandler.Handle(request) }

九、中介者模式

中介者模式定义一个对象，封装一系列对象之间的交互。

package mediator type Mediator interface { Send(message string, colleague Colleague) } type Colleague interface { Send(message string) Receive(message string) } type ConcreteMediator struct { colleagues []Colleague } func (m *ConcreteMediator) AddColleague(colleague Colleague) { m.colleagues = append(m.colleagues, colleague) } func (m *ConcreteMediator) Send(message string, sender Colleague) { for _, colleague := range m.colleagues { if colleague != sender { colleague.Receive(message) } } } type ConcreteColleague struct { name string mediator Mediator } func (c *ConcreteColleague) Send(message string) { println(c.name + " sends: " + message) c.mediator.Send(message, c) } func (c *ConcreteColleague) Receive(message string) { println(c.name + " receives: " + message) }

十、行为型模式实战

场景：日志处理责任链

package chain type LogHandler interface { SetNext(handler LogHandler) LogHandler Handle(logLevel string, message string) } type BaseHandler struct { next LogHandler } func (h *BaseHandler) SetNext(handler LogHandler) LogHandler { h.next = handler return handler } type DebugHandler struct { BaseHandler } func (h *DebugHandler) Handle(logLevel, message string) { if logLevel == "DEBUG" { println("[DEBUG] " + message) } else if h.next != nil { h.next.Handle(logLevel, message) } } type InfoHandler struct { BaseHandler } func (h *InfoHandler) Handle(logLevel, message string) { if logLevel == "INFO" { println("[INFO] " + message) } else if h.next != nil { h.next.Handle(logLevel, message) } } type ErrorHandler struct { BaseHandler } func (h *ErrorHandler) Handle(logLevel, message string) { if logLevel == "ERROR" { println("[ERROR] " + message) } else if h.next != nil { h.next.Handle(logLevel, message) } }