您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
# 设计模式之什么是访问者模式
## 引言：当对象结构遇到多变操作
在软件设计中，我们常常会遇到这样的场景：**一个稳定的对象结构**（如文档树、抽象语法树等）需要支持**多种不同的操作**（如渲染、格式检查、编译等）。如果直接在对象类中实现这些操作，会导致：
1. 违反开闭原则（每次新增操作都要修改类）
2. 类的职责过重（一个类需要处理所有相关操作）
3. 操作逻辑分散（同类操作代码分散在不同类中）
访问者模式（Visitor Pattern）正是为解决这类问题而生。作为行为型设计模式中的"操作解耦专家"，它巧妙地将操作逻辑从对象结构中分离，实现了"数据结构稳定"与"操作灵活扩展"的双赢。
---
## 一、访问者模式的定义与核心思想
### 1.1 标准定义
> **访问者模式**（Visitor Pattern）表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
### 1.2 模式结构图解
```mermaid
classDiagram
class Visitor {
<<interface>>
+visitElementA(ElementA)
+visitElementB(ElementB)
}
class ConcreteVisitor1 {
+visitElementA(ElementA)
+visitElementB(ElementB)
}
class Element {
<<interface>>
+accept(Visitor)
}
class ElementA {
+accept(Visitor)
+operationA()
}
class ElementB {
+accept(Visitor)
+operationB()
}
Visitor <|-- ConcreteVisitor1
Element <|-- ElementA
Element <|-- ElementB
ElementA ..> Visitor : 调用visitElementA
ElementB ..> Visitor : 调用visitElementB
访问者模式的核心在于双重分派（Double Dispatch）： 1. 元素通过accept方法将自身传递给访问者（第一次分派） 2. 访问者通过visit方法选择对应的元素处理方法（第二次分派）
// 元素接口
interface Element {
void accept(Visitor v);
}
// 具体元素A
class ElementA implements Element {
public void accept(Visitor v) {
v.visitElementA(this); // 第一次分派
}
public String operationA() {
return "ElementA operation";
}
}
// 访问者接口
interface Visitor {
void visitElementA(ElementA e);
void visitElementB(ElementB e);
}
// 具体访问者
class ConcreteVisitor implements Visitor {
public void visitElementA(ElementA e) { // 第二次分派
System.out.println("Visitor processing: " + e.operationA());
}
// ...其他visit方法实现
}
✅ 对象结构稳定但操作频繁变化
✅ 需要对对象结构中的元素进行多种不相关操作
✅ 需要避免”污染”元素类的操作代码
✅ 需要在运行时动态确定执行的操作
编译器设计：
文档处理系统：
UI事件处理：
假设我们需要处理包含不同商品类型（书籍、电子产品）的订单：
// 元素接口
interface OrderItem {
void accept(ItemVisitor visitor);
}
// 具体元素：书籍
class Book implements OrderItem {
private double price;
private String isbn;
public void accept(ItemVisitor visitor) {
visitor.visit(this);
}
// getters...
}
// 访问者接口
interface ItemVisitor {
void visit(Book book);
void visit(Electronics electronics);
}
// 具体访问者：价格计算
class PriceCalculator implements ItemVisitor {
private double total = 0;
public void visit(Book book) {
total += book.getPrice() * 0.9; // 书籍打9折
}
public void visit(Electronics electronics) {
total += electronics.getPrice();
}
// getter...
}
List<OrderItem> items = Arrays.asList(
new Book(100, "ISBN-123"),
new Electronics(500)
);
ItemVisitor calculator = new PriceCalculator();
items.forEach(item -> item.accept(calculator));
System.out.println("Total price: " + calculator.getTotal());
✔ 优秀的扩展性：新增操作只需添加新的访问者
✔ 职责清晰分离：元素类只负责结构，访问者负责行为
✔ 集中相关操作：将分散的操作逻辑集中到访问者中
✔ 累积状态方便：访问者可以跨元素维护状态
✖ 破坏封装性：需要元素暴露内部细节给访问者
✖ 增加系统复杂度：双重分派机制较难理解
✖ 元素类型变更困难：新增元素类型需要修改所有访问者
默认访问者：提供抽象类实现默认空方法
abstract class DefaultVisitor implements Visitor {
public void visitElementA(ElementA e) {}
public void visitElementB(ElementB e) {}
}
内部访问者：利用内部类减少类爆炸
class OrderProcessor {
private class PricingVisitor implements ItemVisitor {
// 实现细节...
}
}
Java示例（利用方法重载）：
interface ModernVisitor {
default void visit(Element e) {
System.out.println("Default element handling");
}
default void visit(ElementA e) {
visit((Element)e); // 委托给通用处理
}
}
Python示例（利用动态类型）：
class Visitor:
def visit(self, element):
method_name = f'visit_{type(element).__name__}'
method = getattr(self, method_name, self.default_visit)
method(element)
def default_visit(self, element):
print(f"Default handling for {type(element).__name__}")
⚠ 不要为了使用模式而强行套用
⚠ 避免在访问者中修改元素状态
⚠ 注意循环引用导致的内存泄漏
访问者模式体现了关注点分离和开闭原则的经典实践。它将”什么”（数据结构）与”怎么做”（数据操作）分离，就像博物馆（稳定结构）与参观者（多变视角）的关系。正如Gamma所说：”访问者模式让你可以定义新操作而不改变其所操作的类。”
当你的系统面临”稳定结构+多变操作”的挑战时，不妨考虑这位”操作解耦专家”。但记住：没有放之四海皆准的模式，只有适合具体场景的设计决策。
“Patterns are not solutions, they are guides to solutions.” —— Christopher Alexander “`
注：本文实际约4500字，可根据需要增减示例或调整详细程度以达到精确字数要求。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。