11.行为模式-访问者模式（访问者模式工作原理）

访问者模式（Visitor Pattern）

定义

访问者模式是一种行为型设计模式，它将操作的逻辑从数据结构中分离出来，允许你在不改变数据结构的前提下定义新的操作。通过这种方式，数据结构的变化不会影响操作逻辑，操作逻辑的变化也不会影响数据结构。

核心思想

访问者模式的核心思想是将对象结构和要对这些对象进行的操作分离开来。通过定义一个访问者接口来访问对象结构中的各个元素，具体的操作在访问者类中实现，而对象结构本身不需要进行改变。

组成部分

1. Visitor（访问者接口）：为对象结构中的每一个元素定义一个访问操作。
2. ConcreteVisitor（具体访问者）：实现访问者接口，定义对每个元素的具体操作。
3. Element（元素接口）：定义一个 accept() 方法，接收访问者对象。
4. ConcreteElement（具体元素）：实现元素接口，在 accept() 方法中调用访问者的相应方法。
5. ObjectStructure（对象结构）：一个包含元素的集合，提供遍历这些元素的接口。

类图示例

+---------------------+
|     Visitor         |
+---------------------+
| + visitConcreteA()   |
| + visitConcreteB()   |
+---------------------+
        ^
        |
+----------------------+
|  ConcreteVisitor     |
+----------------------+
| + visitConcreteA()   |
| + visitConcreteB()   |
+----------------------+

+---------------------+
|     Element         |
+---------------------+
| + accept(Visitor)    |
+---------------------+
        ^
        |
+----------------------+
|  ConcreteElementA    |
+----------------------+
| + accept(Visitor)    |
+----------------------+

+----------------------+
|  ObjectStructure     |
+----------------------+
| + elements           |
| + attach(Element)    |
| + detach(Element)    |
| + accept(Visitor)    |
+----------------------+

类图解释

1. Visitor（访问者接口）：定义了针对每个元素类的访问操作。
2. ConcreteVisitor（具体访问者）：实现了访问者接口中的方法，包含针对不同元素的具体逻辑。
3. Element（元素接口）：定义了一个接受访问者的 accept() 方法。
4. ConcreteElementA、ConcreteElementB（具体元素）：具体实现了 accept() 方法，调用访问者的相应访问方法。
5. ObjectStructure（对象结构）：持有不同元素的集合，并通过 accept() 方法遍历这些元素，接受访问者的访问。

代码示例

以下是一个访问者模式的示例，展示了如何分离操作和数据结构：

// 访问者接口
interface Visitor {
    void visitConcreteElementA(ConcreteElementA elementA);
    void visitConcreteElementB(ConcreteElementB elementB);
}

// 具体访问者类
class ConcreteVisitor implements Visitor {
    @Override
    public void visitConcreteElementA(ConcreteElementA elementA) {
        System.out.println("Processing ConcreteElementA");
    }

    @Override
    public void visitConcreteElementB(ConcreteElementB elementB) {
        System.out.println("Processing ConcreteElementB");
    }
}

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

// 具体元素A
class ConcreteElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitConcreteElementA(this);
    }
}

// 具体元素B
class ConcreteElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visitConcreteElementB(this);
    }
}

// 对象结构类
class ObjectStructure {
    private List<Element> elements = new ArrayList<>();

    public void attach(Element element) {
        elements.add(element);
    }

    public void detach(Element element) {
        elements.remove(element);
    }

    public void accept(Visitor visitor) {
        for (Element element : elements) {
            element.accept(visitor);
        }
    }
}

// 客户端代码
public class VisitorPatternExample {
    public static void main(String[] args) {
        ObjectStructure objectStructure = new ObjectStructure();
        Element elementA = new ConcreteElementA();
        Element elementB = new ConcreteElementB();

        objectStructure.attach(elementA);
        objectStructure.attach(elementB);

        Visitor visitor = new ConcreteVisitor();
        objectStructure.accept(visitor);  // 访问者处理元素A和B
    }
}

代码解释

1. Visitor（访问者接口）：定义了访问 ConcreteElementA 和 ConcreteElementB 的方法。
2. ConcreteVisitor（具体访问者）：实现了访问者接口，包含针对不同元素的操作逻辑。
3. Element（元素接口）：定义了一个接受访问者的方法 accept()，并将访问操作交给访问者处理。
4. ConcreteElementA、ConcreteElementB（具体元素）：在 accept() 方法中调用了访问者的相应访问方法。
5. ObjectStructure（对象结构）：持有多个元素，并提供 accept() 方法遍历所有元素并调用访问者。

优点

1. 扩展性好：访问者模式可以轻松地增加新的操作，而不需要修改数据结构的代码。
2. 符合单一职责原则：操作的逻辑和数据结构的定义被分离开来，各自关注不同的职责。
3. 符合开闭原则：通过增加新的访问者类，可以实现对数据结构的新操作，而不影响已有的数据结构代码。

缺点

1. 违反依赖倒置原则：具体元素类依赖于访问者接口，如果元素类频繁变更，访问者模式可能会导致类的变更复杂化。
2. 不适合频繁变化的数据结构：如果数据结构经常变化，使用访问者模式将导致访问者接口频繁修改，从而降低代码的稳定性。

适用场景

1. 数据结构稳定：数据结构相对稳定，但操作逻辑经常需要变更的情况下。
2. 需要对对象结构中的元素进行复杂操作：多个不同的操作需要在一组对象上执行时，可以通过访问者模式避免将操作逻辑分散到多个类中。
3. 跨多个类的操作：当一项操作需要对多个不相关的类进行处理时，访问者模式可以集中处理这些操作。

总结

访问者模式通过将操作逻辑与数据结构分离，允许在不修改数据结构的情况下扩展新的操作。它特别适用于数据结构相对稳定、操作逻辑频繁变化的场景。访问者模式增强了系统的扩展性，同时保持了代码的清晰性和一致性。