1. 从“巨无霸”对象说起：为什么我们需要访问者模式？
三年前我接手过一个电商后台系统，核心的 Product 类足足有 1200 行代码。这个类不仅要管理商品基础信息，还包含了价格计算、库存预警、促销规则、日志记录等十几种功能。每次新增业务需求，开发团队都像在走钢丝——既要小心翼翼避免影响现有功能，又要在已经臃肿的类里继续塞代码。
这正是面向对象开发中最常见的反模式之一：上帝对象（God Object）。当我们将数据结构和业务逻辑强耦合在一起时，就会导致：
- 核心类变得脆弱：任何修改都可能引发连锁反应
- 测试成本指数级增长：每次改动都需要回归测试整个类
- 团队协作困难：多人修改同一类时频繁产生冲突
1.1 问题的本质：稳定与变化的对抗
在软件设计中存在一个基本矛盾：
- 数据结构通常是稳定的（如用户的基本属性、商品的核心字段）
- 业务逻辑却是频繁变化的（如新的计算规则、报表格式、业务流程）
当我们把变化的部分（业务逻辑）写入稳定的部分（数据结构）时，就违反了开闭原则（对扩展开放，对修改关闭）。访问者模式的本质，正是通过双重分发机制来解决这一矛盾。
关键洞察：就像现实生活中，房子（数据结构）不会频繁改动，但我们可以随时更换家具（业务逻辑）。访问者模式让我们的代码也遵循同样的智慧。
2. 访问者模式深度解析
2.1 经典实现：双分派机制
传统访问者模式包含两个核心组件：
- 被访问者（Element）：定义
accept方法接收访问者 - 访问者（Visitor）：为每个被访问者类型提供
visit方法
typescript复制// 被访问者接口
interface Employee {
accept(visitor: EmployeeVisitor): void;
}
// 具体被访问者
class Engineer implements Employee {
constructor(public name: string, public salary: number) {}
accept(visitor: EmployeeVisitor) {
visitor.visitEngineer(this);
}
}
// 访问者接口
interface EmployeeVisitor {
visitEngineer(engineer: Engineer): void;
visitManager(manager: Manager): void;
}
// 具体访问者
class BonusCalculator implements EmployeeVisitor {
visitEngineer(engineer: Engineer) {
console.log(`${engineer.name} 的奖金: ${engineer.salary * 0.2}`);
}
visitManager(manager: Manager) {
console.log(`${manager.name} 的奖金: ${manager.salary * 0.5}`);
}
}
这种实现虽然严谨，但在动态类型语言中显得过于繁琐。下面我们看更符合JavaScript习惯的实现方式。
2.2 JavaScript优化版：策略表模式
针对JS的特性，我们可以简化实现：
javascript复制// 策略表访问者
const visitors = {
bonus: {
Engineer: emp => emp.salary * 0.2,
Manager: emp => emp.salary * 0.5
},
report: {
Engineer: emp => `${emp.name}的技术报告`,
Manager: emp => `${emp.name}的管理报表`
}
};
// 执行函数
function execute(employees, operation) {
return employees.map(emp => {
const processor = visitors[operation][emp.type];
return processor ? processor(emp) : null;
});
}
// 使用示例
const employees = [
{ type: 'Engineer', name: '张三', salary: 15000 },
{ type: 'Manager', name: '李四', salary: 30000 }
];
console.log(execute(employees, 'bonus')); // [3000, 15000]
console.log(execute(employees, 'report')); // ["张三的技术报告", "李四的管理报表"]
这种实现保留了访问者模式的核心优势，同时更符合JavaScript的灵活特性。
3. 实战应用场景
3.1 电商促销系统
假设我们需要为电商平台实现多种促销规则：
javascript复制// 商品数据（稳定部分）
const products = [
{ sku: 'A001', type: 'Book', price: 59.9, stock: 100 },
{ sku: 'B202', type: 'Electronics', price: 1999, stock: 20 }
];
// 促销访问者（易变部分）
const promotions = {
// 全场8折
discount: {
apply(product) {
return { ...product, price: product.price * 0.8 };
}
},
// 满减活动
fullReduction: {
apply(product) {
const reduction = product.price > 100 ? 20 : 0;
return { ...product, price: product.price - reduction };
}
}
};
// 执行促销
function applyPromotion(products, promotionName) {
const promotion = promotions[promotionName];
return promotion
? products.map(p => promotion.apply(p))
: products;
}
3.2 AST处理器
访问者模式在编译器中应用广泛，比如处理抽象语法树(AST)：
javascript复制// AST节点类型
class Node {
constructor(type, value, children = []) {
this.type = type;
this.value = value;
this.children = children;
}
}
// 访问者实现
const astVisitors = {
// 计算器
calculator: {
Number(node) { return parseFloat(node.value); },
Add(node, visit) {
return node.children.reduce((sum, child) => sum + visit(child), 0);
},
Multiply(node, visit) {
return node.children.reduce((prod, child) => prod * visit(child), 1);
}
},
// 代码生成器
codeGenerator: {
Number(node) { return node.value; },
Add(node, visit) {
return `(${node.children.map(visit).join(' + ')})`;
}
}
};
function traverse(node, visitor) {
const handler = visitor[node.type];
if (!handler) throw new Error(`Unknown node type: ${node.type}`);
return handler(node, child => traverse(child, visitor));
}
// 使用示例
const ast = new Node('Add', '+', [
new Node('Number', '2'),
new Node('Multiply', '*', [
new Node('Number', '3'),
new Node('Number', '4')
])
]);
console.log(traverse(ast, astVisitors.calculator)); // 14
console.log(traverse(ast, astVisitors.codeGenerator)); // "(2 + (3 * 4))"
4. 性能优化与高级技巧
4.1 缓存优化
频繁创建访问者实例可能影响性能，可以采用缓存策略：
javascript复制class CachedVisitor {
constructor() {
this.cache = new Map();
}
visit(node) {
const cacheKey = this.getCacheKey(node);
if (this.cache.has(cacheKey)) {
return this.cache.get(cacheKey);
}
const result = this.doVisit(node);
this.cache.set(cacheKey, result);
return result;
}
getCacheKey(node) {
return `${node.type}:${JSON.stringify(node.value)}`;
}
doVisit(node) {
// 由子类实现具体逻辑
throw new Error('Abstract method');
}
}
4.2 异步访问者
处理异步操作时的访问者模式实现：
javascript复制class AsyncVisitor {
async visit(node) {
const handler = this[`visit${node.type}`];
if (!handler) {
throw new Error(`No handler for type: ${node.type}`);
}
return await handler.call(this, node);
}
}
class DatabaseVisitor extends AsyncVisitor {
async visitUser(node) {
const data = await db.query('SELECT * FROM users WHERE id = ?', [node.id]);
return processUserData(data);
}
async visitProduct(node) {
const data = await db.query('SELECT * FROM products WHERE sku = ?', [node.sku]);
return processProductData(data);
}
}
5. 与其他模式的关系
5.1 与策略模式对比
| 特性 | 访问者模式 | 策略模式 |
|---|---|---|
| 目的 | 分离数据结构与算法 | 封装可互换的算法 |
| 适用场景 | 复杂对象结构 | 单一算法的多种实现 |
| 扩展方式 | 添加新Visitor | 添加新Strategy |
| 访问方式 | 通过accept方法双重分发 | 直接调用策略方法 |
5.2 与装饰器模式结合
javascript复制// 装饰器增强基础功能
function loggableVisitor(visitor) {
return {
...visitor,
visit(node) {
console.log(`Visiting ${node.type}`);
const result = visitor.visit(node);
console.log(`Result: ${result}`);
return result;
}
};
}
// 使用装饰后的访问者
const decorated = loggableVisitor(new CalculatorVisitor());
decorated.visit(ast);
6. 实战经验与坑点指南
6.1 何时使用访问者模式
✔️ 适合场景：
- 对象结构稳定但操作频繁变化
- 需要对同一对象结构进行多种不相关操作
- 操作需要访问对象结构的内部细节
- 希望避免污染对象接口
❌ 不适合场景：
- 对象结构本身频繁变化
- 只需要对对象进行简单操作
- 性能敏感的底层代码
6.2 常见陷阱
-
循环依赖问题：
javascript复制// 错误示例：互相引用 class A { accept(v) { v.visitA(this); } } class Visitor { visitA(a) { a.accept(this); } // 无限递归 } -
类型检查陷阱：
javascript复制// 不够健壮的实现 function visit(node) { if (node.type === 'A') { // ... } else { // 可能遗漏类型 } } -
状态管理问题：
javascript复制// 错误的状态管理 class Visitor { constructor() { this.result = null; // 共享状态容易出错 } }
6.3 最佳实践
- 保持访问者无状态：每个visit方法应该是纯函数
- 使用组合代替继承：通过组合多个简单访问者实现复杂功能
- 提供默认实现：为访问者接口提供合理的默认行为
- 类型安全：在TypeScript中充分利用接口和泛型
7. TypeScript强化实现
利用TypeScript的类型系统可以构建更安全的访问者模式：
typescript复制interface Element {
accept<T>(visitor: Visitor<T>): T;
}
interface Visitor<T> {
visitConcreteElementA(element: ConcreteElementA): T;
visitConcreteElementB(element: ConcreteElementB): T;
}
class ConcreteElementA implements Element {
accept<T>(visitor: Visitor<T>) {
return visitor.visitConcreteElementA(this);
}
}
class ConcreteVisitor implements Visitor<string> {
visitConcreteElementA(element: ConcreteElementA): string {
return `Visited A`;
}
visitConcreteElementB(element: ConcreteElementB): string {
return `Visited B`;
}
}
8. 现代JavaScript的演进
随着语言发展，我们可以用更现代的方式实现类似功能：
8.1 使用Proxy实现动态访问
javascript复制function createVisitorHandler(visitors) {
return {
get(target, prop) {
if (prop in visitors) {
return data => {
const type = data.type;
return type in visitors[prop]
? visitors[prop][type](data)
: defaultHandler(data);
};
}
return target[prop];
}
};
}
const visitor = new Proxy({}, createVisitorHandler({
bonus: {
Engineer: e => e.salary * 0.2,
Manager: m => m.salary * 0.5
}
}));
console.log(visitor.bonus({ type: 'Engineer', salary: 10000 })); // 2000
8.2 使用Symbol实现多态
javascript复制const VISITOR = Symbol('visitor');
class Employee {
constructor(type, name) {
this.type = type;
this.name = name;
}
[VISITOR](visitor) {
const method = visitor[this.type];
if (method) return method(this);
throw new Error(`No visitor method for ${this.type}`);
}
}
const bonusVisitor = {
Engineer: emp => emp.salary * 0.2,
Manager: emp => emp.salary * 0.5
};
const emp = new Employee('Engineer', 'Alice');
emp.salary = 10000;
console.log(emp[VISITOR](bonusVisitor)); // 2000
9. 测试策略
针对访问者模式的测试应该关注：
- 访问者独立性：每个访问者应该可以单独测试
- 数据不变性：验证原始数据不会被修改
- 类型覆盖：确保所有类型都有对应处理
示例测试用例：
javascript复制describe('BonusVisitor', () => {
const employees = [
{ type: 'Engineer', name: 'Dev', salary: 10000 },
{ type: 'Manager', name: 'Boss', salary: 20000 }
];
it('should calculate engineer bonus', () => {
const result = execute(employees[0], bonusVisitor);
expect(result).toEqual(2000);
});
it('should handle unknown types', () => {
const unknown = { type: 'Intern', salary: 3000 };
expect(() => execute(unknown, bonusVisitor))
.toThrow('No handler for type: Intern');
});
});
10. 架构层面的思考
访问者模式不仅仅是一种编码技巧，它反映了一种重要的架构哲学：
- 关注点分离：数据结构与业务逻辑的解耦
- 单向依赖：具体元素只依赖抽象访问者
- 开闭原则：通过扩展而非修改来增加功能
在实际项目中，我通常会这样分层：
code复制src/
├── models/ # 稳定的数据结构
├── visitors/ # 多变的业务逻辑
├── services/ # 协调层
└── index.js # 组合入口
这种架构让我们的系统能够从容应对业务需求的变化，同时保持核心模型的稳定性。