当前位置：首页 > news >正文

设计模式】Listener模式和Visitor模式的区别

news 来源：原创 2024/9/20 4:47:44

文章目录

前言
一、介绍
- - Listener模式
  - Visitor模式
二、代码实现
- - 2.1 Listener模式的Java实现
  - 2.2Listener模式的Go实现
  - 2.3Visitor模式的Java实现
  - 2.4Visitor模式的Go实现
三、总结

前言

在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详细解释这两种模式，并通过Java和Go语言的代码示例展示它们的实现，最后总结它们的区别和适用场景。

一、介绍

Listener模式

Listener模式（监听器模式） 是一种行为设计模式，主要用于事件驱动的编程。它允许一个对象（监听器）注册到另一个对象（事件源），以便在特定事件发生时接收通知。

主要特点：
1.解耦： 事件源和监听器之间是松耦合的，事件源只需要知道监听器实现了某个接口，而不需要知道具体的实现细节。
2.灵活性： 可以动态添加或移除监听器。
3.异步处理： 事件通知通常是异步的，这意味着事件源在触发事件后可以继续执行其他任务，而不需要等待监听器处理完事件。

典型应用：

GUI应用程序中的按钮点击事件。
网络编程中的数据接收事件。

Visitor模式

Visitor模式（访问者模式） 是一种行为设计模式，它允许你在不改变对象结构的前提下，定义作用于这些对象的新操作。它将操作的定义与对象结构分离，使得新的操作可以很容易地添加。

主要特点：
1.双重分派： Visitor模式使用双重分派机制，即首先调用对象的accept方法，然后在accept方法中调用访问者的visit方法。
2.扩展性： 可以很容易地添加新的操作，而不需要修改对象结构。
**3.复杂性：**增加了系统的复杂性，因为需要定义多个访问者类和accept方法。

典型应用：

编译器中的语法树遍历。
复杂对象结构的操作，如文件系统遍历。

二、代码实现

2.1 Listener模式的Java实现

// 定义监听器接口
public interface EventListener {void onEvent();
}// 事件源类
public class EventSource {private List<EventListener> listeners = new ArrayList<>();public void addListener(EventListener listener) {listeners.add(listener);}public void removeListener(EventListener listener) {listeners.remove(listener);}public void triggerEvent() {for (EventListener listener : listeners) {listener.onEvent();}}
}// 实现监听器
public class MyEventListener implements EventListener {@Overridepublic void onEvent() {System.out.println("Event triggered!");}
}// 使用示例
public class Main {public static void main(String[] args) {EventSource eventSource = new EventSource();MyEventListener listener = new MyEventListener();eventSource.addListener(listener);eventSource.triggerEvent();}
}

2.2Listener模式的Go实现

package mainimport ("fmt"
)// 定义监听器接口
type EventListener interface {OnEvent()
}// 事件源类
type EventSource struct {listeners []EventListener
}func (es *EventSource) AddListener(listener EventListener) {es.listeners = append(es.listeners, listener)
}func (es *EventSource) RemoveListener(listener EventListener) {for i, l := range es.listeners {if l == listener {es.listeners = append(es.listeners[:i], es.listeners[i+1:]...)break}}
}func (es *EventSource) TriggerEvent() {for _, listener := range es.listeners {listener.OnEvent()}
}// 实现监听器
type MyEventListener struct{}func (mel *MyEventListener) OnEvent() {fmt.Println("Event triggered!")
}func main() {eventSource := &EventSource{}listener := &MyEventListener{}eventSource.AddListener(listener)eventSource.TriggerEvent()
}

2.3Visitor模式的Java实现

// 定义访问者接口
public interface Visitor {void visit(ElementA element);void visit(ElementB element);
}// 定义元素接口
public interface Element {void accept(Visitor visitor);
}// 具体元素A
public class ElementA implements Element {@Overridepublic void accept(Visitor visitor) {visitor.visit(this);}
}// 具体元素B
public class ElementB implements Element {@Overridepublic void accept(Visitor visitor) {visitor.visit(this);}
}// 具体访问者
public class ConcreteVisitor implements Visitor {@Overridepublic void visit(ElementA element) {System.out.println("Visiting ElementA");}@Overridepublic void visit(ElementB element) {System.out.println("Visiting ElementB");}
}// 使用示例
public class Main {public static void main(String[] args) {List<Element> elements = Arrays.asList(new ElementA(), new ElementB());Visitor visitor = new ConcreteVisitor();for (Element element : elements) {element.accept(visitor);}}
}

2.4Visitor模式的Go实现

package mainimport ("fmt"
)// 定义访问者接口
type Visitor interface {VisitElementA(*ElementA)VisitElementB(*ElementB)
}// 定义元素接口
type Element interface {Accept(Visitor)
}// 具体元素A
type ElementA struct{}func (e *ElementA) Accept(visitor Visitor) {visitor.VisitElementA(e)
}// 具体元素B
type ElementB struct{}func (e *ElementB) Accept(visitor Visitor) {visitor.VisitElementB(e)
}// 具体访问者
type ConcreteVisitor struct{}func (cv *ConcreteVisitor) VisitElementA(e *ElementA) {fmt.Println("Visiting ElementA")
}func (cv *ConcreteVisitor) VisitElementB(e *ElementB) {fmt.Println("Visiting ElementB")
}func main() {elements := []Element{&ElementA{}, &ElementB{}}visitor := &ConcreteVisitor{}for _, element := range elements {element.Accept(visitor)}
}