访问者模式（Visitor Pattern）详解

文章目录

- 1. 访问者模式概述
- - 1.1 定义
  - 1.2 基本思想
- 2. 访问者模式的结构
- 3. 访问者模式的UML类图
- 4. 访问者模式的工作原理
- 5. Java实现示例
- - 5.1 基本实现示例
  - 5.2 访问者模式处理复杂对象层次结构
  - 5.3 访问者模式在文件系统中的应用
- 6. 访问者模式的优缺点
- - 6.1 优点
  - 6.2 缺点
- 7. 访问者模式的适用场景
- 8. 访问者模式在框架中的应用
- - 8.1 Java的反射API
  - 8.2 Java ASM库
  - 8.3 Spring框架中的BeanDefinitionVisitor
- 9. 访问者模式与其他设计模式的区别与联系
- - 9.1 访问者模式与策略模式
  - 9.2 访问者模式与组合模式
  - 9.3 访问者模式与命令模式
- 10. 实战案例：电商订单处理系统
- 11. 总结

1. 访问者模式概述

1.1 定义

访问者模式是一种行为型设计模式，它允许在不改变各元素类的前提下定义作用于这些元素的新操作。访问者模式通过将操作与对象结构分离，使得我们可以在不修改对象结构的情况下向现有对象结构添加新的操作。

1.2 基本思想

访问者模式的核心思想是：

将数据结构与数据操作分离
针对不同的元素类型，访问者可以执行不同的操作
在不修改已有类的情况下，通过添加新的访问者实现对元素的新操作

2. 访问者模式的结构

访问者模式包含以下角色：

抽象访问者(Visitor)：声明了一组访问方法，用于访问不同类型的具体元素
具体访问者(ConcreteVisitor)：实现抽象访问者接口中声明的方法，为不同类型的元素提供具体操作实现
抽象元素(Element)：声明一个接受访问者的方法（accept），以供访问者访问
具体元素(ConcreteElement)：实现抽象元素接口，实现accept方法接受访问者访问
对象结构(ObjectStructure)：包含元素集合，可以提供让访问者遍历其内部元素的方法

3. 访问者模式的UML类图

┌─────────────────┐          ┌─────────────────┐
│ ObjectStructure │          │ <<interface>>   │
├─────────────────┤          │     Element     │
│ +elements       │<>────────├─────────────────┤
│ +accept(Visitor)│          │ +accept(Visitor)│
└─────────────────┘          └────────┬────────┘│                            ││                            ││                ┌───────────┴───────────┐│                │                       ││      ┌─────────▼────────┐   ┌──────────▼─────────┐│      │  ConcreteElementA│   │  ConcreteElementB  ││      ├──────────────────┤   ├────────────────────┤│      │+accept(Visitor)  │   │+accept(Visitor)    ││      └──────────────────┘   └────────────────────┘│                │                      ││                │                      ││                ▼                      ▼│         "visitor.visitA(this)"   "visitor.visitB(this)"│││      ┌─────────────────────┐└─────>│    <<interface>>    ││       Visitor       │├─────────────────────┤│+visitA(ElementA)    ││+visitB(ElementB)    │└──────────┬──────────┘││┌─────────────┴────────────┐│                          │
┌────────────▼────────────┐  ┌──────────▼────────────┐
│   ConcreteVisitor1      │  │    ConcreteVisitor2   │
├─────────────────────────┤  ├─────────────────────────┤
│+visitA(ElementA)        │  │+visitA(ElementA)        │
│+visitB(ElementB)        │  │+visitB(ElementB)        │
└─────────────────────────┘  └─────────────────────────┘

4. 访问者模式的工作原理

当需要对一个对象结构中的元素进行操作时，访问者模式可以在不修改元素类的前提下实现新功能
每个具体元素都实现accept方法，该方法通过调用访问者对象的对应方法来实现功能
具体访问者针对每种具体元素类型实现相应的访问方法
在访问者模式中，双重分派是一个核心概念：
- 第一次分派：根据元素的实际类型选择调用哪个accept方法
- 第二次分派：在accept方法内部，根据访问者的实际类型选择调用哪个visit方法

5. Java实现示例

5.1 基本实现示例

下面是一个简单的访问者模式实现示例，假设我们有一个简单的计算机部件系统：

// 抽象访问者
interface ComputerPartVisitor {void visit(Computer computer);void visit(Mouse mouse);void visit(Keyboard keyboard);void visit(Monitor monitor);
}// 抽象元素
interface ComputerPart {void accept(ComputerPartVisitor visitor);
}// 具体元素类：鼠标
class Mouse implements ComputerPart {@Overridepublic void accept(ComputerPartVisitor visitor) {visitor.visit(this);}
}// 具体元素类：键盘
class Keyboard implements ComputerPart {@Overridepublic void accept(ComputerPartVisitor visitor) {visitor.visit(this);}
}// 具体元素类：显示器
class Monitor implements ComputerPart {@Overridepublic void accept(ComputerPartVisitor visitor) {visitor.visit(this);}
}// 具体元素类：计算机（复合元素）
class Computer implements ComputerPart {ComputerPart[] parts;public Computer() {parts = new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()};}@Overridepublic void accept(ComputerPartVisitor visitor) {for (ComputerPart part : parts) {part.accept(visitor);}visitor.visit(this);}
}// 具体访问者：显示访问者
class ComputerPartDisplayVisitor implements ComputerPartVisitor {@Overridepublic void visit(Computer computer) {System.out.println("展示计算机。");}@Overridepublic void visit(Mouse mouse) {System.out.println("展示鼠标。");}@Overridepublic void visit(Keyboard keyboard) {System.out.println("展示键盘。");}@Overridepublic void visit(Monitor monitor) {System.out.println("展示显示器。");}
}// 具体访问者：维护访问者
class ComputerPartMaintainVisitor implements ComputerPartVisitor {@Overridepublic void visit(Computer computer) {System.out.println("维护计算机。");}@Overridepublic void visit(Mouse mouse) {System.out.println("清洁鼠标。");}@Overridepublic void visit(Keyboard keyboard) {System.out.println("清洁并检查键盘按键。");}@Overridepublic void visit(Monitor monitor) {System.out.println("校准并清洁显示器屏幕。");}
}// 客户端
public class ComputerPartClient {public static void main(String[] args) {ComputerPart computer = new Computer();System.out.println("展示操作：");computer.accept(new ComputerPartDisplayVisitor());System.out.println("\n维护操作：");computer.accept(new ComputerPartMaintainVisitor());}
}

5.2 访问者模式处理复杂对象层次结构

下面是一个处理不同形状的访问者模式示例：

// 形状接口 - 抽象元素
interface Shape {void accept(ShapeVisitor visitor);
}// 圆形 - 具体元素
class Circle implements Shape {private double radius;public Circle(double radius) {this.radius = radius;}public double getRadius() {return radius;}@Overridepublic void accept(ShapeVisitor visitor) {visitor.visit(this);}
}// 矩形 - 具体元素
class Rectangle implements Shape {private double width;private double height;public Rectangle(double width, double height) {this.width = width;this.height = height;}public double getWidth() {return width;}public double getHeight() {return height;}@Overridepublic void accept(ShapeVisitor visitor) {visitor.visit(this);}
}// 三角形 - 具体元素
class Triangle implements Shape {private double sideA;private double sideB;private double sideC;public Triangle(double sideA, double sideB, double sideC) {this.sideA = sideA;this.sideB = sideB;this.sideC = sideC;}public double getSideA() {return sideA;}public double getSideB() {return sideB;}public double getSideC() {return sideC;}@Overridepublic void accept(ShapeVisitor visitor) {visitor.visit(this);}
}// 形状访问者接口 - 抽象访问者
interface ShapeVisitor {void visit(Circle circle);void visit(Rectangle rectangle);void visit(Triangle triangle);
}// 计算面积的访问者 - 具体访问者
class AreaCalculator implements ShapeVisitor {@Overridepublic void visit(Circle circle) {double area = Math.PI * circle.getRadius() * circle.getRadius();System.out.println("圆的面积：" + area);}@Overridepublic void visit(Rectangle rectangle) {double area = rectangle.getWidth() * rectangle.getHeight();System.out.println("矩形的面积：" + area);}@Overridepublic void visit(Triangle triangle) {// 使用海伦公式计算三角形面积double s = (triangle.getSideA() + triangle.getSideB() + triangle.getSideC()) / 2;double area = Math.sqrt(s * (s - triangle.getSideA()) * (s - triangle.getSideB()) * (s - triangle.getSideC()));System.out.println("三角形的面积：" + area);}
}// 计算周长的访问者 - 具体访问者
class PerimeterCalculator implements ShapeVisitor {@Overridepublic void visit(Circle circle) {double perimeter = 2 * Math.PI * circle.getRadius();System.out.println("圆的周长：" + perimeter);}@Overridepublic void visit(Rectangle rectangle) {double perimeter = 2 * (rectangle.getWidth() + rectangle.getHeight());System.out.println("矩形的周长：" + perimeter);}@Overridepublic void visit(Triangle triangle) {double perimeter = triangle.getSideA() + triangle.getSideB() + triangle.getSideC();System.out.println("三角形的周长：" + perimeter);}
}// 绘制形状的访问者 - 具体访问者
class ShapeDrawer implements ShapeVisitor {@Overridepublic void visit(Circle circle) {System.out.println("绘制圆形，半径：" + circle.getRadius());}@Overridepublic void visit(Rectangle rectangle) {System.out.println("绘制矩形，宽：" + rectangle.getWidth() + "，高：" + rectangle.getHeight());}@Overridepublic void visit(Triangle triangle) {System.out.println("绘制三角形，边长：" + triangle.getSideA() + ", " + triangle.getSideB() + ", " + triangle.getSideC());}
}// 形状集合 - 对象结构
class ShapeCollection {private List<Shape> shapes = new ArrayList<>();public void addShape(Shape shape) {shapes.add(shape);}public void accept(ShapeVisitor visitor) {for (Shape shape : shapes) {shape.accept(visitor);}}
}// 客户端代码
public class ShapeClient {public static void main(String[] args) {ShapeCollection shapes = new ShapeCollection();shapes.addShape(new Circle(5.0));shapes.addShape(new Rectangle(4.0, 6.0));shapes.addShape(new Triangle(3.0, 4.0, 5.0));System.out.println("计算所有形状的面积：");shapes.accept(new AreaCalculator());System.out.println("\n计算所有形状的周长：");shapes.accept(new PerimeterCalculator());System.out.println("\n绘制所有形状：");shapes.accept(new ShapeDrawer());}
}

5.3 访问者模式在文件系统中的应用

下面是一个使用访问者模式处理文件系统的示例：

import java.util.ArrayList;
import java.util.List;// 文件系统元素 - 抽象元素
interface FileSystemElement {void accept(FileVisitor visitor);String getName();
}// 文件 - 具体元素
class File implements FileSystemElement {private String name;private long size; // 文件大小（字节）public File(String name, long size) {this.name = name;this.size = size;}@Overridepublic String getName() {return name;}public long getSize() {return size;}@Overridepublic void accept(FileVisitor visitor) {visitor.visit(this);}
}// 目录 - 具体元素
class Directory implements FileSystemElement {private String name;private List<FileSystemElement> elements = new ArrayList<>();public Directory(String name) {this.name = name;}@Overridepublic String getName() {return name;}public void addElement(FileSystemElement element) {elements.add(element);}public List<FileSystemElement> getElements() {return elements;}@Overridepublic void accept(FileVisitor visitor) {visitor.visit(this);// 递归访问所有子元素for (FileSystemElement element : elements) {element.accept(visitor);}}
}// 文件访问者 - 抽象访问者
interface FileVisitor {void visit(File file);void visit(Directory directory);
}// 文件统计访问者 - 具体访问者
class FileStatisticsVisitor implements FileVisitor {private int fileCount = 0;private int directoryCount = 0;private long totalSize = 0;@Overridepublic void visit(File file) {fileCount++;totalSize += file.getSize();System.out.println("文件: " + file.getName() + ", 大小: " + file.getSize() + " 字节");}@Overridepublic void visit(Directory directory) {directoryCount++;System.out.println("目录: " + directory.getName());}public void printStatistics() {System.out.println("\n统计信息:");System.out.println("文件数量: " + fileCount);System.out.println("目录数量: " + directoryCount);System.out.println("总大小: " + totalSize + " 字节");}
}// 查找访问者 - 具体访问者
class SearchVisitor implements FileVisitor {private String searchKeyword;private List<FileSystemElement> foundElements = new ArrayList<>();public SearchVisitor(String searchKeyword) {this.searchKeyword = searchKeyword;}@Overridepublic void visit(File file) {if (file.getName().contains(searchKeyword)) {foundElements.add(file);}}@Overridepublic void visit(Directory directory) {if (directory.getName().contains(searchKeyword)) {foundElements.add(directory);}}public void printResults() {System.out.println("\n搜索结果，关键词: \"" + searchKeyword + "\"");if (foundElements.isEmpty()) {System.out.println("未找到匹配项");} else {for (FileSystemElement element : foundElements) {System.out.println("找到: " + element.getName());}}}
}// 客户端代码
public class FileSystemDemo {public static void main(String[] args) {// 创建文件系统结构Directory root = new Directory("root");Directory documents = new Directory("documents");Directory pictures = new Directory("pictures");File file1 = new File("report.doc", 2000);File file2 = new File("presentation.ppt", 5000);File pic1 = new File("vacation.jpg", 3000);File pic2 = new File("family.jpg", 2000);Directory downloads = new Directory("downloads");File file3 = new File("game.exe", 10000);// 构建文件系统树root.addElement(documents);root.addElement(pictures);root.addElement(downloads);documents.addElement(file1);documents.addElement(file2);pictures.addElement(pic1);pictures.addElement(pic2);downloads.addElement(file3);// 使用统计访问者FileStatisticsVisitor statisticsVisitor = new FileStatisticsVisitor();root.accept(statisticsVisitor);statisticsVisitor.printStatistics();// 使用搜索访问者SearchVisitor searchVisitor = new SearchVisitor("jpg");root.accept(searchVisitor);searchVisitor.printResults();}
}

6. 访问者模式的优缺点

6.1 优点

扩展性好：在不修改现有元素类的情况下，通过添加新的访问者类来增加新功能
符合单一职责原则：将数据结构和数据操作分离，使得职责更清晰
集中相关操作：针对不同元素类型的操作被集中在各个访问者类中，便于管理
适合复杂对象结构：对于复杂对象结构（如组合模式结构）特别适用
增强数据结构的灵活性：相同的数据结构可以被不同访问者用于完成不同操作

6.2 缺点

元素类变更困难：如果经常添加新的元素类，需要修改所有访问者类，违反了开闭原则
违反了依赖倒置原则：具体元素对具体访问者产生了依赖
访问者需要了解元素内部细节：可能会破坏封装性
增加复杂度：结构较复杂，理解和实现难度较高
循环依赖风险：如果处理不当，可能会导致元素和访问者之间形成循环依赖

7. 访问者模式的适用场景

对象结构比较稳定，但经常需要在此对象结构上定义新的操作
需要对一个对象结构中的对象进行很多不同且不相关的操作，而不想让这些操作"污染"类
数据结构和数据操作需要分离的场景
适合复杂对象结构（如组合模式构成的结构）的操作

常见应用场景：

文件系统遍历和操作
编译器设计（语法树访问）
XML文档解析
复杂图形结构绘制
数据结构的多种算法实现

8. 访问者模式在框架中的应用

8.1 Java的反射API

Java的反射API中的AnnotatedElement接口及其实现就体现了访问者模式的思想：

public interface AnnotatedElement {boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);<T extends Annotation> T getAnnotation(Class<T> annotationClass);Annotation[] getAnnotations();Annotation[] getDeclaredAnnotations();
}

8.2 Java ASM库

Java ASM库使用访问者模式来处理Java字节码：

// ASM的ClassVisitor示例
public class ClassPrinter extends ClassVisitor {public ClassPrinter() {super(ASM4);}@Overridepublic void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {System.out.println(name + " extends " + superName + " {");}@Overridepublic FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {System.out.println("    " + desc + " " + name);return null;}@Overridepublic MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {System.out.println("    " + name + desc);return null;}@Overridepublic void visitEnd() {System.out.println("}");}
}

8.3 Spring框架中的BeanDefinitionVisitor

Spring框架中的BeanDefinitionVisitor用于访问Bean定义：

public class BeanDefinitionVisitor {public void visitBeanDefinition(BeanDefinition beanDefinition) {visitParentName(beanDefinition.getParentName());visitBeanClassName(beanDefinition.getBeanClassName());visitFactoryBeanName(beanDefinition.getFactoryBeanName());visitFactoryMethodName(beanDefinition.getFactoryMethodName());visitScope(beanDefinition.getScope());if (beanDefinition.hasPropertyValues()) {visitPropertyValues(beanDefinition.getPropertyValues());}if (beanDefinition.hasConstructorArgumentValues()) {visitConstructorArgumentValues(beanDefinition.getConstructorArgumentValues());}}protected void visitParentName(String parentName) {// ...}protected void visitBeanClassName(String beanClassName) {// ...}// 其他访问方法...
}

9. 访问者模式与其他设计模式的区别与联系

9.1 访问者模式与策略模式

相似点：都将算法从主体类中抽离
区别：
- 策略模式针对单一对象提供不同算法
- 访问者模式针对不同类型对象提供不同算法，且通常处理复杂对象结构

9.2 访问者模式与组合模式

相似点：都适用于处理复杂对象结构
区别：
- 组合模式侧重于构建树形对象结构
- 访问者模式侧重于在已有对象结构上执行操作，两者经常一起使用

9.3 访问者模式与命令模式

相似点：都将操作封装成对象
区别：
- 命令模式封装单一请求为对象
- 访问者模式封装一组相关的操作，能够处理复杂对象结构

10. 实战案例：电商订单处理系统

import java.util.ArrayList;
import java.util.List;// 订单元素 - 抽象元素
interface OrderElement {void accept(OrderVisitor visitor);
}// 订单项 - 具体元素
class OrderItem implements OrderElement {private String productName;private int quantity;private double price;private boolean isImported;private boolean isFragile;public OrderItem(String productName, int quantity, double price, boolean isImported, boolean isFragile) {this.productName = productName;this.quantity = quantity;this.price = price;this.isImported = isImported;this.isFragile = isFragile;}public String getProductName() {return productName;}public int getQuantity() {return quantity;}public double getPrice() {return price;}public boolean isImported() {return isImported;}public boolean isFragile() {return isFragile;}@Overridepublic void accept(OrderVisitor visitor) {visitor.visit(this);}
}// 订单 - 具体元素（也是对象结构）
class Order implements OrderElement {private String orderNumber;private String customerName;private List<OrderItem> items = new ArrayList<>();public Order(String orderNumber, String customerName) {this.orderNumber = orderNumber;this.customerName = customerName;}public String getOrderNumber() {return orderNumber;}public String getCustomerName() {return customerName;}public void addItem(OrderItem item) {items.add(item);}public List<OrderItem> getItems() {return items;}@Overridepublic void accept(OrderVisitor visitor) {visitor.visit(this);for (OrderItem item : items) {item.accept(visitor);}}
}// 订单访问者 - 抽象访问者
interface OrderVisitor {void visit(Order order);void visit(OrderItem orderItem);
}// 税费计算访问者 - 具体访问者
class TaxCalculationVisitor implements OrderVisitor {private double totalTax = 0;private double importTaxRate = 0.05; // 5%的进口税private double generalTaxRate = 0.07; // 7%的普通消费税@Overridepublic void visit(Order order) {System.out.println("计算订单 " + order.getOrderNumber() + " 的税费");}@Overridepublic void visit(OrderItem orderItem) {double itemTotal = orderItem.getPrice() * orderItem.getQuantity();double taxAmount = itemTotal * generalTaxRate;if (orderItem.isImported()) {taxAmount += itemTotal * importTaxRate;}totalTax += taxAmount;System.out.println("商品: " + orderItem.getProductName() + ", 数量: " + orderItem.getQuantity() + ", 税额: " + taxAmount);}public double getTotalTax() {return totalTax;}
}// 配送成本计算访问者 - 具体访问者
class ShippingCostVisitor implements OrderVisitor {private double totalShippingCost = 0;private double standardShippingCost = 5.0; // 基础配送费private double fragileItemSurcharge = 3.0; // 易碎品附加费private double importedItemSurcharge = 2.0; // 进口商品附加费@Overridepublic void visit(Order order) {System.out.println("计算订单 " + order.getOrderNumber() + " 的配送费用");}@Overridepublic void visit(OrderItem orderItem) {double itemShippingCost = standardShippingCost;if (orderItem.isFragile()) {itemShippingCost += fragileItemSurcharge;}if (orderItem.isImported()) {itemShippingCost += importedItemSurcharge;}// 多件商品按照数量计算总配送费用itemShippingCost *= orderItem.getQuantity();totalShippingCost += itemShippingCost;System.out.println("商品: " + orderItem.getProductName() + ", 数量: " + orderItem.getQuantity() + ", 配送费: " + itemShippingCost);}public double getTotalShippingCost() {return totalShippingCost;}
}// 订单统计访问者 - 具体访问者
class OrderSummaryVisitor implements OrderVisitor {private int totalItems = 0;private double orderTotal = 0;@Overridepublic void visit(Order order) {System.out.println("\n订单摘要 - 订单号: " + order.getOrderNumber() + ", 客户: " + order.getCustomerName());}@Overridepublic void visit(OrderItem orderItem) {int quantity = orderItem.getQuantity();double itemTotal = orderItem.getPrice() * quantity;totalItems += quantity;orderTotal += itemTotal;System.out.println("商品: " + orderItem.getProductName() + ", 数量: " + quantity + ", 单价: " + orderItem.getPrice() + ", 小计: " + itemTotal);}public void printSummary() {System.out.println("\n总计商品数量: " + totalItems);System.out.println("订单总金额: " + orderTotal);}public int getTotalItems() {return totalItems;}public double getOrderTotal() {return orderTotal;}
}// 客户端代码
public class ECommerceOrderDemo {public static void main(String[] args) {// 创建一个订单Order order = new Order("ORD-12345", "张三");// 添加订单项order.addItem(new OrderItem("笔记本电脑", 1, 5999.99, true, true));order.addItem(new OrderItem("无线鼠标", 2, 99.99, false, true));order.addItem(new OrderItem("程序设计书籍", 3, 89.99, false, false));order.addItem(new OrderItem("进口咖啡", 5, 32.99, true, false));// 使用摘要访问者生成订单摘要OrderSummaryVisitor summaryVisitor = new OrderSummaryVisitor();order.accept(summaryVisitor);summaryVisitor.printSummary();// 使用税费计算访问者计算税费TaxCalculationVisitor taxVisitor = new TaxCalculationVisitor();order.accept(taxVisitor);System.out.println("\n总税费: " + taxVisitor.getTotalTax());// 使用配送成本访问者计算配送费用ShippingCostVisitor shippingVisitor = new ShippingCostVisitor();order.accept(shippingVisitor);System.out.println("\n总配送费: " + shippingVisitor.getTotalShippingCost());// 计算最终应付金额double finalTotal = summaryVisitor.getOrderTotal() + taxVisitor.getTotalTax() + shippingVisitor.getTotalShippingCost();System.out.println("\n最终应付金额: " + finalTotal);}
}