设计模式-访问者模式

访问者模式

访问者模式（Visitor Pattern）是一种将数据结构与数据操作分离的设计模式，是指封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作，属于行为型模式。

访问者模式被称为最复杂的设计模式，但是使用率不高。不过，一旦你需要使用它时，那就真的需要了，也就是这种场景其他方案很难达成目标。

基本思想

针对系统中拥有固定类型的对象结构，在其内提供一个accept()方法用来接收访问者对象的访问。不同的访问者对同一元素的访问内容不同，使得相同的元素可以产生不同的数据结果。
accept()方法可以接收不同的访问者对象，然后在内部将自己(元素)转发到接收到的访问者对象的visit()方法内，访问者内部对应类型的visit()方法就会得到回调执行，对元素进行操作。
也就是通过两次动态分发(①对访问者的分发accept()方法②对元素的分发visit()方法)，才最终将一个具体的元素传递到一个具体的访问者。
如此一来，就解耦了数据结构与操作，且数据操作不会改变元素状态。

适用场景

• 数据结构稳定，作用于数据结构的操作经常发生变化的场景；
• 需要数据结构与数据操作分离的场景；
• 需要对不同数据类型进行操作，而不使用分支判断具体类型的场景

代码

抽象元素：

package com.caozz.demo2.visitor.general;

// 抽象元素
public interface IElement {
    void accept(IVisitor visitor);
}

具体元素A：

package com.caozz.demo2.visitor.general;

// 具体元素
public class ConcreteElementA implements IElement {

    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }

    public String operationA() {
        return this.getClass().getSimpleName();
    }

}

具体元素B：

package com.caozz.demo2.visitor.general;

import java.util.Random;

// 具体元素
public class ConcreteElementB implements IElement {

    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }

    public int operationB() {
        return new Random().nextInt(100);
    }
}

抽象访问者：

package com.caozz.demo2.visitor.general;

// 抽象访问者
public interface IVisitor {

    void visit(ConcreteElementA element);

    void visit(ConcreteElementB element);
}

具体访问者A：

package com.caozz.demo2.visitor.general;

// 具体访问者
public class ConcreteVisitorA implements IVisitor {

    public void visit(ConcreteElementA element) {
        String result = element.operationA();
        System.out.println("result from " + element.getClass().getSimpleName() + ": " + result);
    }

    public void visit(ConcreteElementB element) {
        int result = element.operationB();
        System.out.println("result from " + element.getClass().getSimpleName() + ": " + result);
    }
}

具体访问者B：

package com.caozz.demo2.visitor.general;

// 具体访问者
public class ConcreteVisitorB implements IVisitor {

    public void visit(ConcreteElementA element) {
        String result = element.operationA();
        System.out.println("result from " + element.getClass().getSimpleName() + ": " + result);
    }


    public void visit(ConcreteElementB element) {
        int result = element.operationB();
        System.out.println("result from " + element.getClass().getSimpleName() + ": " + result);
    }
}

结构对象：

package com.caozz.demo2.visitor.general;

import java.util.ArrayList;
import java.util.List;

// 结构对象
public class ObjectStructure {
    private List<IElement> list = new ArrayList<IElement>();

    {
        this.list.add(new ConcreteElementA());
        this.list.add(new ConcreteElementB());
    }

    public void accept(IVisitor visitor) {
        for (IElement element : this.list) {
            element.accept(visitor);
        }
    }
}

测试：

package com.caozz.demo2.visitor.general;

/**
 * Created by Caozz
 */
public class Test {

    public static void main(String[] args) {
        ObjectStructure collection = new ObjectStructure();
        System.out.println("ConcreteVisitorA handle elements:");
        IVisitor visitorA = new ConcreteVisitorA();
        collection.accept(visitorA);
        System.out.println("------------------------------------");
        System.out.println("ConcreteVisitorB handle elements:");
        IVisitor visitorB = new ConcreteVisitorB();
        collection.accept(visitorB);
    }

}

测试结果：

ConcreteVisitorA handle elements:
result from ConcreteElementA: ConcreteElementA
result from ConcreteElementB: 17
' ------------------------------------'
ConcreteVisitorB handle elements:
result from ConcreteElementA: ConcreteElementA
result from ConcreteElementB: 28