Java访问者模式

概述

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新的操作。

访问者模式的结构

访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由地演化。数据结构的每一个节点都可以接受一个访问者的调用，此节点向访问者对象传入节点对象，而访问者对象则反过来执行节点对象的操作。这样的过程叫做“双重分派”。节点调用访问者，将它自己传入，访问者则将某算法针对此节点执行。访问者模式的示意性类图如下所示：

访问者模式涉及到的角色如下：
　　●　　抽象访问者(Visitor)角色：声明了一个或者多个方法操作，形成所有的具体访问者角色必须实现的接口。
　　●　　具体访问者(ConcreteVisitor)角色：实现抽象访问者所声明的接口，也就是抽象访问者所声明的各个访问操作。
　　●　　抽象节点(Node)角色：声明一个接受操作，接受一个访问者对象作为一个参数。
　　●　　具体节点(ConcreteNode)角色：实现了抽象节点所规定的接受操作。
　　●　　结构对象(ObjectStructure)角色：有如下的责任，可以遍历结构中的所有元素；如果需要，提供一个高层次的接口让访问者对象可以访问每一个元素；如果需要，可以设计成一个复合对象或者一个聚集，如List或Set。

源代码

/**
 * 抽象节点(Node)角色：声明一个接受操作，接受一个访问者对象作为一个参数。
 */
public interface Node {

    /**
     * 接受操作，接受一个访问者对象作为一个参数
     * @param visitor
     */
    public void accept(Visitor visitor);

}

/**
 * 具体节点(ConcreteNode)角色：实现了抽象节点所规定的接受操作。
 */
public class NodeA implements Node {
    /**
     * 接受操作，接收一个访问者对象，同时调用访问者对象的visit方法，把自己作为参数传过去
     */
    @Override
    public void accept(Visitor visitor) {
        //这里为方法重载，执行时判断this的真实类型，判断调用visitor对象的哪个方法
        visitor.visit(this);
    }

    /**
     * NodeA特有的方法
     */
    public String operationA(){
        return "nodeA";
    }
}

/**
 * 具体节点(ConcreteNode)角色：实现了抽象节点所规定的接受操作。
 */
public class NodeB implements Node {
    /**
     * 接受操作
     */
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    /**
     * NodeB特有的方法
     */
    public String operationB(){
        return "nodeB";
    }
}

/**
 * 抽象访问者(Visitor)角色：声明了一个或者多个方法操作，形成所有的具体访问者角色必须实现的接口
 */
public interface Visitor {

    /**
     * 对应于NodeA的访问操作
     */
    public void visit(NodeA node);

    /**
     * 对应于NodeB的访问操作
     */
    public void visit(NodeB node);

}

/**
 * 具体访问者类
 */
public class VisitorA implements Visitor {

    /**
     * 对应于NodeA的访问操作
     */
    @Override
    public void visit(NodeA nodeA) {
        System.out.println(nodeA.operationA());
    }

    /**
     * 对应于NodeB的访问操作
     */
    @Override
    public void visit(NodeB nodeB) {
        System.out.println(nodeB.operationB());
    }
}

/**
 * 具体访问者类
 */
public class VisitorB implements Visitor {

    /**
     * 对应于NodeA的访问操作
     */
    @Override
    public void visit(NodeA nodeA) {
        System.out.println(nodeA.operationA());
    }

    /**
     * 对应于NodeB的访问操作
     */
    @Override
    public void visit(NodeB nodeB) {
        System.out.println(nodeB.operationB());
    }
}

/**
 * 结构对象角色类，这个结构对象角色持有一个聚集，并向外界提供add()方法作为对聚集的管理操作。
 * 通过调用这个方法，可以动态地增加一个新的节点。
 */
public class ObjectStructure {

    private List<Node> nodes = new ArrayList<Node>();

    /**
     * 执行方法操作
     * @param visitor
     */
    public void action(Visitor visitor){
        for(Node node: nodes){
            //根据node真实类型和visitor真实类型判断调用的方法
            node.accept(visitor);
        }
    }

    /**
     * 添加节点
     * @param node
     */
    public void add(Node node) {
        nodes.add(node);
    }

}

/**
 * 客户端
 */
public class Client {

    public static void main(String[] args) {
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.add(new NodeA());
        objectStructure.add(new NodeB());

        objectStructure.action(new VisitorA());
        System.out.println("----------------");
        objectStructure.action(new VisitorB());
    }

}

创建对象时序图

首先，这个示意性的客户端创建了一个结构对象，然后将一个新的NodeA对象和一个新的NodeB对象传入。
其次，客户端创建了一个VisitorA对象，并将此对象传给结构对象。
然后，客户端调用结构对象聚集管理方法，将NodeA和NodeB节点加入到结构对象中去。
最后，客户端调用结构对象的行动方法action()，启动访问过程。

访问过程时序图

结构对象会遍历它自己所保存的聚集中的所有节点，在本系统中就是节点NodeA和NodeB。首先NodeA会被访问到，这个访问是由以下的操作组成的：
（1）NodeA对象的接受方法accept()被调用，并将VisitorA对象本身传入；
（2）NodeA对象反过来调用VisitorA对象的访问方法，并将NodeA对象本身传入；
（3）VisitorA对象调用NodeA对象的特有方法operationA()。
从而就完成了双重分派过程，接着，NodeB会被访问，这个访问的过程和NodeA被访问的过程是一样的，这里不再叙述。

访问者模式的优点

●　　好的扩展性
　　能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。

●　　好的复用性
　　可以通过访问者来定义整个对象结构通用的功能，从而提高复用程度。

●　　分离无关行为
　　可以通过访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，这样每一个访问者的功能都比较单一。

访问者模式的缺点

●　　对象结构变化很困难
　　不适用于对象结构中的类经常变化的情况，因为对象结构发生了改变，访问者的接口和访问者的实现都要发生相应的改变，代价太高。

●　　破坏封装
　　访问者模式通常需要对象结构开放内部数据给访问者和ObjectStructrue，这破坏了对象的封装性。

总结

访问者模式适用于数据结构稳定的系统，它增加新的操作很容易，因为增加新的操作意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。