23种设计模式——访问者模式 (Visitor Pattern)

✅作者简介：大家好，我是 Meteors., 向往着更加简洁高效的代码写法与编程方式，持续分享Java技术内容。
🍎个人主页：Meteors.的博客
💞当前专栏：设计模式
✨特色专栏：知识分享
🥭本文内容：23种设计模式------访问者模式 (Visitor Pattern)
📚 ** ps ** ：阅读文章如果有问题或者疑惑，欢迎在评论区提问或指出。

[一. 背景](#一. 背景)

[二. 介绍](#二. 介绍)

[三. 主要角色](#三. 主要角色)

[四. 代码示例](#四. 代码示例)

[五. 应用场景](#五. 应用场景)

[六. 优缺点](#六. 优缺点)

[七. 优化策略](#七. 优化策略)

[八. 总结](#八. 总结)

一. 背景

访问者模式，这个名字像是访问某个东西，但我感觉不是很贴切，感觉实际上它指的是，通过增加访问的方式，对原有的元素操作功能进行扩展。下面内容将对访问者模式及它的使用进行详细的介绍。

二. 介绍

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

三. 主要角色

访问者模式包含以下几个关键角色：

**Visitor（抽象访问者）：**为对象结构中的每个具体元素类声明一个访问方法

**ConcreteVisitor（具体访问者）：**实现抽象访问者声明的各个访问方法，定义对不同元素的访问操作

**Element（抽象元素）：**定义一个accept方法，接受一个访问者对象

**ConcreteElement（具体元素）：**实现accept方法，在accept方法中调用访问者的访问方法

**ObjectStructure（对象结构）：**能枚举它的元素，可以提供一个高层的接口以允许访问者访问它的元素

四. 代码示例

下面是一个简单的示例，使用访问者模式使用渲染和拼音检查两种方式对图片和文本元素进行访问：

javascript 复制代码

// 抽象元素接口
interface DocumentElement {
    void accept(DocumentVisitor visitor);
}

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

// 具体元素：图片元素
class ImageElement implements DocumentElement {
    private String src;
    
    public ImageElement(String src) {
        this.src = src;
    }
    
    public String getSrc() {
        return src;
    }
    
    @Override
    public void accept(DocumentVisitor visitor) {
        visitor.visit(this);
    }
}

// 抽象访问者
interface DocumentVisitor {
    void visit(TextElement element);
    void visit(ImageElement element);
}

// 具体访问者：渲染访问者
class RenderVisitor implements DocumentVisitor {
    @Override
    public void visit(TextElement element) {
        System.out.println("渲染文本: " + element.getText());
    }
    
    @Override
    public void visit(ImageElement element) {
        System.out.println("渲染图片: " + element.getSrc());
    }
}

// 具体访问者：拼写检查访问者
class SpellCheckVisitor implements DocumentVisitor {
    @Override
    public void visit(TextElement element) {
        System.out.println("对文本进行拼写检查: " + element.getText());
        // 实际的拼写检查逻辑
    }
    
    @Override
    public void visit(ImageElement element) {
        System.out.println("跳过图片元素的拼写检查: " + element.getSrc());
    }
}

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

// 使用示例
public class VisitorPatternDemo {
    public static void main(String[] args) {
        Document document = new Document();
        
        document.addElement(new TextElement("Hello World"));
        document.addElement(new ImageElement("baby.jpg"));
        document.addElement(new TextElement("Visitor Pattern"));
        
        // 渲染文档
        DocumentVisitor renderVisitor = new RenderVisitor();
        document.accept(renderVisitor);
        
        System.out.println("---");
        
        // 拼写检查
        DocumentVisitor spellCheckVisitor = new SpellCheckVisitor();
        document.accept(spellCheckVisitor);
    }
}

五. 应用场景

在Android开发中，访问者模式可以应用于：

***UI组件处理：***对不同类型的UI组件执行不同的操作

***AST处理：***在编译器或代码分析工具中处理抽象语法树节点

***数据模型处理：***对不同类型的业务数据模型执行不同的操作

六. 优缺点

优点：

扩展性好：可以在不修改对象结构的前提下定义新的操作

复用性好：可以通过不同的访问者实现不同的操作

符合单一职责原则：将相关操作集中到访问者中，避免"污染"元素类

缺点：

违反封装原则：访问者需要了解元素的内部细节

增加系统复杂性：需要为每个元素类定义访问方法

难以添加新元素类：每增加一个元素类，都需要在访问者中添加对应的方法

七. 优化策略

使用反射优化访问者模式： 可以使用反射机制自动分派访问方法，避免为每个元素类手动编写访问方法：

java 复制代码

abstract class ReflectiveVisitor {
    public void visit(Object element) {
        try {
            Method method = this.getClass().getMethod("visit", element.getClass());
            method.invoke(this, element);
        } catch (Exception e) {
            // 处理没有对应访问方法的情况
            visitDefault(element);
        }
    }
    
    public void visitDefault(Object element) {
        System.out.println("默认访问处理: " + element.getClass().getSimpleName());
    }
}

使用泛型优化： 通过泛型可以提供类型安全的访问者实现：

java 复制代码

interface GenericVisitor<T> {
    T visit(TextElement element);
    T visit(ImageElement element);
}

class CountingVisitor implements GenericVisitor<Integer> {
    private int count = 0;
    
    @Override
    public Integer visit(TextElement element) {
        return ++count;
    }
    
    @Override
    public Integer visit(ImageElement element) {
        return ++count;
    }
    
    public int getCount() {
        return count;
    }
}

使用Lambda表达式简化： 在Java 8及以上版本中，可以使用函数式接口和Lambda表达式来简化访问者模式：

java 复制代码

@FunctionalInterface
interface ElementProcessor<T> {
    void process(T element);
}

class LambdaVisitor {
    public static void processElements(Document document, 
                                      ElementProcessor<TextElement> textProcessor,
                                      ElementProcessor<ImageElement> imageProcessor) {
        // 遍历并处理元素
    }
}

八. 总结

访问者模式是一种强大的设计模式，适用于需要对稳定的数据结构执行多种操作的场景。虽然它会增加系统的复杂性，但在适当的情况下使用，可以大大提高代码的可维护性和可扩展性。在使用时需要注意权衡其优缺点，并结合具体场景进行优化。