设计模式精讲 Day 23：访问者模式（Visitor Pattern）

【设计模式精讲 Day 23】访问者模式（Visitor Pattern）

开篇

欢迎来到"设计模式精讲"系列的最后一天！今天我们探讨访问者模式（Visitor Pattern），这是行为型设计模式中最复杂但也是最强大的模式之一。访问者模式将数据结构与数据操作分离，在不改变数据结构的前提下定义作用于这些元素的新操作。这种模式特别适用于对象结构稳定但经常需要新增操作的场景，如编译器设计、文档处理等。通过今天的讲解，你将掌握访问者模式的核心思想、实现方法以及在实际项目中的灵活应用。

模式定义

访问者模式是一种行为设计模式，它允许你在不改变各元素类的前提下定义作用于这些元素的新操作。该模式的核心思想是将数据结构和数据操作分离，使得操作可以独立变化。

官方定义：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。（《设计模式：可复用面向对象软件的基础》）

访问者模式体现了开闭原则（OCP）——对扩展开放，对修改关闭。当需要为对象结构添加新的操作时，只需添加新的访问者实现，而不需要修改现有的类结构。

模式结构

访问者模式包含以下主要角色（用文字描述类图结构）：

1. Visitor（访问者）：声明访问者可以访问哪些具体元素（visit方法）
2. ConcreteVisitor（具体访问者）：实现每个由Visitor声明的操作
3. Element（元素）：定义一个accept方法，接受访问者对象
4. ConcreteElement（具体元素）：实现accept方法
5. ObjectStructure（对象结构）：能枚举它的元素，可以提供一个高层接口允许访问者访问它的元素

类关系描述：

• Visitor依赖于Element（通过visit方法）
• Element依赖于Visitor（通过accept方法）
• ConcreteElement实现Element接口
• ConcreteVisitor实现Visitor接口
• ObjectStructure聚合Element

适用场景

访问者模式最适合以下业务场景：

1. 对象结构稳定但经常需要新增操作：如编译器中的语法树分析、文档格式转换
2. 需要对对象结构中的元素执行多种不相关操作：如统计报表生成、数据校验等
3. 避免"污染"元素类的接口：将相关操作集中在一个访问者中
4. 跨多个类层次结构的操作：访问者可以跨越不同的类层次执行操作

实现方式

基础实现

下面是一个完整的访问者模式实现示例，模拟文档处理系统：

// 元素接口
interface DocumentElement {
    void accept(Visitor visitor);
}

// 具体元素：Heading
class Heading implements DocumentElement {
    private String text;
    
    public Heading(String text) {
        this.text = text;
    }
    
    public String getText() {
        return text;
    }
    
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 具体元素：Paragraph
class Paragraph implements DocumentElement {
    private String content;
    
    public Paragraph(String content) {
        this.content = content;
    }
    
    public String getContent() {
        return content;
    }
    
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 访问者接口
interface Visitor {
    void visit(Heading heading);
    void visit(Paragraph paragraph);
}

// 具体访问者：HTML导出
class HtmlExportVisitor implements Visitor {
    private StringBuilder html = new StringBuilder();
    
    public String getHtml() {
        return html.toString();
    }
    
    @Override
    public void visit(Heading heading) {
        html.append("<h1>").append(heading.getText()).append("</h1>\n");
    }
    
    @Override
    public void visit(Paragraph paragraph) {
        html.append("<p>").append(paragraph.getContent()).append("</p>\n");
    }
}

// 具体访问者：字数统计
class WordCountVisitor implements Visitor {
    private int count = 0;
    
    public int getCount() {
        return count;
    }
    
    @Override
    public void visit(Heading heading) {
        count += heading.getText().split("\\s+").length;
    }
    
    @Override
    public void visit(Paragraph paragraph) {
        count += paragraph.getContent().split("\\s+").length;
    }
}

// 对象结构
class Document {
    private List<DocumentElement> elements = new ArrayList<>();
    
    public void addElement(DocumentElement element) {
        elements.add(element);
    }
    
    public void accept(Visitor visitor) {
        for (DocumentElement element : elements) {
            element.accept(visitor);
        }
    }
}

// 客户端代码
public class VisitorDemo {
    public static void main(String[] args) {
        Document document = new Document();
        document.addElement(new Heading("Welcome to Visitor Pattern"));
        document.addElement(new Paragraph("This is the first paragraph."));
        document.addElement(new Paragraph("This is the second paragraph."));
        
        // HTML导出
        HtmlExportVisitor htmlVisitor = new HtmlExportVisitor();
        document.accept(htmlVisitor);
        System.out.println("HTML Output:\n" + htmlVisitor.getHtml());
        
        // 字数统计
        WordCountVisitor countVisitor = new WordCountVisitor();
        document.accept(countVisitor);
        System.out.println("Word count: " + countVisitor.getCount());
    }
}

单元测试

为验证访问者模式的实现，我们可以编写以下单元测试：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class VisitorPatternTest {
    @Test
    void testHtmlExportVisitor() {
        Document document = new Document();
        document.addElement(new Heading("Test Heading"));
        document.addElement(new Paragraph("Test paragraph content."));
        
        HtmlExportVisitor visitor = new HtmlExportVisitor();
        document.accept(visitor);
        
        String expected = "<h1>Test Heading</h1>\n<p>Test paragraph content.</p>\n";
        assertEquals(expected, visitor.getHtml());
    }
    
    @Test
    void testWordCountVisitor() {
        Document document = new Document();
        document.addElement(new Heading("This is a heading"));
        document.addElement(new Paragraph("This is a paragraph with five words."));
        
        WordCountVisitor visitor = new WordCountVisitor();
        document.accept(visitor);
        
        assertEquals(10, visitor.getCount());
    }
}

工作原理

访问者模式的双分派（Double Dispatch）机制是其核心工作原理：

1. 第一次分派：客户端调用元素对象的accept方法，将访问者对象作为参数传入
2. 第二次分派：元素对象回调访问者的visit方法，将自己(this)作为参数传入
3. 动态绑定：基于访问者的具体类型和元素的具体类型，决定执行哪个visit方法

这种双分派机制使得：

• 元素类不必知道具体操作细节
• 新操作只需实现新的访问者类
• 操作逻辑集中在一个访问者类中

访问者模式与迭代器模式经常结合使用，对象结构负责遍历元素，访问者负责处理元素。

优缺点分析

优点

1. 开闭原则：新增操作只需添加新的访问者类，无需修改现有类
2. 单一职责原则：相关操作集中在访问者中，元素类保持简洁
3. 灵活性：可以在不改变类结构的情况下定义新操作
4. 复用性：一个访问者可以在不同场景中复用
5. 信息累积：访问者可以在遍历过程中收集状态信息

缺点

1. 破坏封装：访问者可能需要访问元素的内部状态
2. 元素变更困难：添加新元素类型需要修改所有访问者
3. 复杂度高：双分派机制增加了理解难度
4. 对象结构限制：要求对象结构稳定，元素类型很少变化

案例分析：电商系统优惠券计算

问题描述

某电商系统有多种商品类型（普通商品、折扣商品、礼品卡），需要实现：

1. 价格计算（原价、折扣价）
2. 优惠券适用性检查
3. 购物车总价计算

传统实现会导致商品类不断被修改，违反开闭原则。

解决方案

使用访问者模式将优惠计算逻辑从商品类中分离：

// 商品接口
interface Product {
    void accept(CouponVisitor visitor);
}

// 具体商品
class RegularProduct implements Product {
    private double price;
    
    public RegularProduct(double price) {
        this.price = price;
    }
    
    public double getPrice() {
        return price;
    }
    
    @Override
    public void accept(CouponVisitor visitor) {
        visitor.visit(this);
    }
}

class DiscountProduct implements Product {
    private double price;
    private double discount;
    
    public DiscountProduct(double price, double discount) {
        this.price = price;
        this.discount = discount;
    }
    
    public double getPrice() {
        return price;
    }
    
    public double getDiscount() {
        return discount;
    }
    
    @Override
    public void accept(CouponVisitor visitor) {
        visitor.visit(this);
    }
}

// 优惠券访问者接口
interface CouponVisitor {
    void visit(RegularProduct product);
    void visit(DiscountProduct product);
    double getTotal();
}

// 具体访问者：满减优惠
class FullReductionCoupon implements CouponVisitor {
    private double threshold;
    private double reduction;
    private double total = 0;
    
    public FullReductionCoupon(double threshold, double reduction) {
        this.threshold = threshold;
        this.reduction = reduction;
    }
    
    @Override
    public void visit(RegularProduct product) {
        double price = product.getPrice();
        total += (total + price >= threshold) ? price - reduction : price;
    }
    
    @Override
    public void visit(DiscountProduct product) {
        double price = product.getPrice() * (1 - product.getDiscount());
        total += (total + price >= threshold) ? price - reduction : price;
    }
    
    @Override
    public double getTotal() {
        return total;
    }
}

// 购物车
class ShoppingCart {
    private List<Product> products = new ArrayList<>();
    
    public void addProduct(Product product) {
        products.add(product);
    }
    
    public double calculateTotal(CouponVisitor coupon) {
        for (Product product : products) {
            product.accept(coupon);
        }
        return coupon.getTotal();
    }
}

// 客户端使用
public class ECommerceDemo {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.addProduct(new RegularProduct(100));
        cart.addProduct(new DiscountProduct(200, 0.1));
        cart.addProduct(new RegularProduct(50));
        
        FullReductionCoupon coupon = new FullReductionCoupon(300, 50);
        double total = cart.calculateTotal(coupon);
        
        System.out.println("Total after coupon: " + total); // 输出: 290.0
    }
}

效果验证

通过访问者模式：

1. 商品类保持稳定，不再需要修改
2. 新增优惠券类型只需实现新的访问者
3. 计算逻辑集中，易于维护
4. 符合开闭原则，系统扩展性良好

与其他模式的关系

与组合模式的关系

访问者模式经常用于遍历组合模式构建的对象结构：

• 组合模式提供复杂的树状结构
• 访问者模式为结构中的元素添加操作

// 组合模式中的元素
interface Component {
    void accept(Visitor visitor);
}

class Leaf implements Component {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

class Composite implements Component {
    private List<Component> children = new ArrayList<>();
    
    public void add(Component component) {
        children.add(component);
    }
    
    public void accept(Visitor visitor) {
        for (Component child : children) {
            child.accept(visitor);
        }
        visitor.visit(this);
    }
}

与迭代器模式的关系

访问者模式可以替代迭代器模式：

• 迭代器模式：遍历元素并让客户端处理
• 访问者模式：遍历元素并将处理逻辑封装在访问者中

访问者模式更适用于需要复杂操作的场景。

与策略模式的关系

两者都封装算法，但不同点：

• 策略模式：在单一上下文中替换算法
• 访问者模式：在不同上下文中应用算法

Java标准库中的应用

1. Java FileVisitor：java.nio.file.FileVisitor接口用于文件遍历操作
2. Annotation Processing：javax.lang.model.element.ElementVisitor用于处理注解
3. ASM库：用于字节码操作的ASM框架使用访问者模式

// 使用FileVisitor遍历文件
Path start = Paths.get("/path/to/directory");
Files.walkFileTree(start, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        System.out.println("Visiting: " + file);
        return FileVisitResult.CONTINUE;
    }
});

总结与系列回顾

今天我们深入探讨了访问者模式，包括：

1. 访问者模式的定义和结构
2. 双分派机制的工作原理
3. 实际电商系统中的优惠券计算案例
4. 与其他设计模式的比较

关键设计思想：

• 数据结构与操作分离
• 通过双分派实现开放封闭
• 集中相关操作，分散无关操作

实际应用提示：

• 适合对象结构稳定的系统
• 避免过度使用，保持代码可读性
• 考虑与组合模式、迭代器模式的结合使用

至此，我们完成了为期23天的"设计模式精讲"系列，涵盖了三大类23种经典设计模式。希望这个系列能帮助你：

1. 深入理解面向对象设计原则
2. 掌握设计模式的精髓和应用场景
3. 在实际项目中灵活运用设计模式解决问题
4. 提升代码的可维护性、可扩展性和复用性

设计模式是软件设计的经验总结，但不是银弹。在实际应用中，需要根据具体场景灵活运用，甚至组合多个模式解决问题。记住：模式是为了服务于设计，而不是设计服务于模式。

参考资料

1. Design Patterns: Elements of Reusable Object-Oriented Software
2. Java Design Patterns: A Hands-On Experience with Real-World Examples
3. Visitor Pattern in Java
4. Refactoring Guru: Visitor Pattern
5. Java FileVisitor API

感谢你坚持完成整个系列的学习！设计模式的学习是一个持续的过程，建议在实际项目中不断实践和反思。如果你有任何问题或想法，欢迎在评论区交流讨论。

文章标签: 设计模式,访问者模式,Java,面向对象,行为型模式

文章简述: 本文是"设计模式精讲"系列的第23篇，全面解析了访问者模式的核心思想、实现方法和实际应用。文章从模式定义和结构入手，详细讲解了双分派机制的工作原理，并通过一个电商系统优惠券计算的真实案例，展示了如何利用访问者模式分离数据结构与操作。文章还分析了访问者模式的优缺点、适用场景，以及与其他设计模式的关系，包括在Java标准库中的典型应用。通过清晰的代码示例和单元测试，读者可以深入理解访问者模式的实现细节和实际价值，掌握如何在不改变类结构的情况下灵活扩展系统功能。