一起学设计模式 - 访问者模式

摘要：概述访问者模式预留通路，回调实现。具体访问者给出对每一个元素类访问时所产生的具体行为。静态分派通过方法重载支持静态分派。上古上古第一代子孙上古第二代子孙显然，类的方法是由三个方法重载而成的。因为访问者模式使得算法操作增加变得容易。

</>复制代码 
访问者模式（Visitor Pattern）属于对象行为型模式的一种，表示一个作用于其对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。

访问者模式： 预留通路，回调实现。它的实现主要就是通过预先定义好调用的通路，在被访问的对象上定义accept方法，在访问者的对象上定义visit方法；然后在调用真正发生的时候，通过两次分发的技术，利用预先定义好的通路，回调到访问者具体的实现上。

</>复制代码 
主要解决

现已稳定的数据结构和易变的操作耦合问题，把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。

</>复制代码 
UML结构图

</>复制代码 
模式结构

抽象访问者(Visitor)： 定义了对每一个元素（Element）访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素个数（Element的实现类个数）是一样的，从这点不难看出，访问者模式要求元素类的个数不能改变（不能改变的意思是说，如果元素类的个数经常改变，则说明不适合使用访问者模式）。

具体访问者(ConcreteVisitor)： 给出对每一个元素类访问时所产生的具体行为。

抽象节点(Element)： 定义了一个接受访问者（accept）的方法，其意义是指，每一个元素都要可以被访问者访问。

具体节点(ConcreteElement)： 提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法。

结构对象角色(ObjectStructure)： 定义当中所提到的对象结构，对象结构是一个抽象表述，具体点可以理解为一个具有容器性质或者复合对象特性的类，它会含有一组元素（Element），并且可以迭代这些元素，供访问者访问。

场景：很多人都有养宠物的习惯，这里就以此为例

访问者角色：给宠物喂食的人

具体访问者角色：主人、其他人

抽象元素角色：动物抽象类

具体元素角色：宠物狗、宠物猫

结构对象角色：主人家

</>复制代码 
结构图如下：

1.创建抽象访问者接口

</>复制代码 
interface Person {
    void feed(Cat cat);
    void feed(Dog dog);
}

2.创建不同的具体访问者角色 -- 主人/其他人，同时实现 Person接口

</>复制代码 
class Owner implements Person {
    @Override
    public void feed(Cat cat) {
        System.out.println("主人喂食猫");
    }
    @Override
    public void feed(Dog dog) {
        System.out.println("主人喂食狗");
    }
}
class Someone implements Person {
    @Override
    public void feed(Cat cat) {
        System.out.println("其他人喂食猫");
    }
    @Override
    public void feed(Dog dog) {
        System.out.println("其他人喂食狗");
    }
}

3.创建 抽象节点 -- 宠物

</>复制代码 
interface Animal {
    void accept(Person person);
}

4.创建实现Animal接口的 具体节点（元素）

</>复制代码 
class Dog implements Animal {
    @Override
    public void accept(Person person) {
        person.feed(this);
        System.out.println("好好吃，汪汪汪！！！");
    }
}
/**
 * 具体节点（元素）角色 -- 宠物猫
 */
class Cat implements Animal {
    @Override
    public void accept(Person person) {
        person.feed(this);
        System.out.println("好好吃，喵喵喵！！！");
    }
}

5.创建实现Animal接口的 具体节点（元素）

</>复制代码 
class Home {
    private List nodeList = new ArrayList<>();
    void action(Person person) {
        for (Animal node : nodeList) {
            node.accept(person);
        }
    }
    /**
     * 添加操作
     *
     * @param animal 动物
     */
    void add(Animal animal) {
        nodeList.add(animal);
    }
}

6.创建客户端，用于测试

</>复制代码 
public class Client {
    public static void main(String[] args) {
        Home home = new Home();
        home.add(new Dog());
        home.add(new Cat());
        Owner owner = new Owner();
        home.action(owner);
        Someone someone = new Someone();
        home.action(someone);
    }
}

7.运行结果

</>复制代码 
主人喂食狗
好好吃，汪汪汪！！！
主人喂食猫
好好吃，喵喵喵！！！
其他人喂食狗
好好吃，汪汪汪！！！
其他人喂食猫
好好吃，喵喵喵！！！

变量被声明时的类型叫做变量的静态类型(Static Type)，有些人又把静态类型叫做明显类型(Apparent Type)；而变量所引用的对象的真实类型又叫做变量的实际类型(Actual Type)。

比如：

</>复制代码 
Map map = null;
map = new HashMap();

　声明了一个变量map，它的静态类型（也叫明显类型）是Map，而它的实际类型是HashMap。

　　根据对象的类型而对方法进行的选择，就是分派(Dispatch)，分派(Dispatch)又分为两种，即静态分派和动态分派。

　　静态分派(Static Dispatch) 发生在编译时期，分派根据静态类型信息发生。静态分派对于我们来说并不陌生，方法重载就是静态分派。

　　动态分派(Dynamic Dispatch) 发生在运行时期，动态分派动态地置换掉某个方法。

　　静态分派：Java通过方法重载支持静态分派。

　　动态分派：Java通过方法的重写支持动态分派。

通过方法的重写支持动态分派。

</>复制代码 
class Dog {
    public void execute() {
        System.out.println("上古 Dog");
    }
}
class DogBaby1 extends Dog {
    @Override
    public void execute() {
        System.out.println("上古Dog第一代子孙");
    }
}
class DogBaby2 extends Dog {
    @Override
    public void execute() {
        System.out.println("上古Dog第二代子孙");
    }
}
/**
 * @author Levin
 */
public class Client {
    public static void main(String[] args) {
        Dog baby1 = new DogBaby1();
        baby1.execute();
        Dog baby2 = new DogBaby2();
        baby2.execute();
    }
}

变量baby1的静态类型是Dog，而真实类型是DogBaby1。

execute()方法调用的是DogBaby1类的execute()方法，那么上面打印的就是 上古Dog第一代子孙；

变量baby2的静态类型是Dog，而真实类型是DogBaby2。

execute()方法调用的是DogBaby2类的execute()方法，那么上面打印的就是 上古Dog第二代子孙；

所以，问题的核心就是Java编译器在编译时期并不总是知道哪些代码会被执行，因为编译器仅仅知道对象的静态类型，而不知道对象的真实类型；而方法的调用则是根据对象的真实类型，而不是静态类型。

通过方法重载支持静态分派。

</>复制代码 
class Dog {
}
class DogBaby1 extends Dog {
}
class DogBaby2 extends Dog {
}
class Execute {
    public void execute(Dog dog) {
        System.out.println("上古 Dog");
    }
    public void execute(DogBaby1 baby1) {
        System.out.println("上古Dog第一代子孙");
    }
    public void execute(DogBaby2 baby2) {
        System.out.println("上古Dog第二代子孙");
    }
}
/**
 * @author Levin
 * @create 2017/12/19 0019
 */
public class Client {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Dog baby1 = new DogBaby1();
        Dog baby2 = new DogBaby2();
        Execute exe = new Execute();
        exe.execute(dog);
        exe.execute(baby1);
        exe.execute(baby2);
    }
}

显然，Execute类的excute()方法是由三个方法重载而成的。这三个方法分别接受狗(Dog)、狗baby1(DogBaby1)、狗baby2(DogBaby2)等类型的参数。

</>复制代码 
运行结果

</>复制代码 
上古 Dog
上古 Dog
上古 Dog

为什么呢？三次对execute()方法的调用传入的是不同的参数，分别是dog、baby1、baby2。它们虽然具有不同的真实类型，但是它们的静态类型都是一样的，均是Dog类型。

重载方法的分派是根据静态类型进行的，这个分派过程在编译时期就完成了。

Java是静态多分派、动态单分派的语言。

Java不支持动态的双分派。但是通过使用设计模式，也可以在Java语言里实现动态的双重分派。

首先，什么是双分派？还记得 设计模式解密（22）- 访问者模式 中举的例子吗？

访问者模式用到了一种双分派的技术，所谓双分派技术就是在选择一个方法的时候，不仅仅要根据消息接收者（receiver）的运行时区别（Run time type），还要根据参数的运行时区别。

在访问者模式中，客户端将具体状态当做参数传递给具体访问者，这里完成第一次分派，然后具体访问者作为参数的具体状态中的方法，同时也将自己this作为参数传递进去，这里就完成了第二次分派。双分派意味着得到的执行操作决定于请求的种类和接受者的类型。

双分派的核心就是这个this对象。

说到这里，我们已经明白双分派是怎么回事了，但是它有什么效果呢？就是可以实现方法的动态绑定，我们可以对上面的程序进行修改。

</>复制代码 
class Dog {
    public void accept(Execute exe) {
        exe.execute(this);
    }
}
class DogBaby1 extends Dog {
    @Override
    public void accept(Execute exe) {
        exe.execute(this);
    }
}
class DogBaby2 extends Dog {
    @Override
    public void accept(Execute exe) {
        exe.execute(this);
    }
}
class Execute {
    public void execute(Dog dog) {
        System.out.println("上古 Dog");
    }
    public void execute(DogBaby1 baby1) {
        System.out.println("上古Dog第一代子孙");
    }
    public void execute(DogBaby2 baby2) {
        System.out.println("上古Dog第二代子孙");
    }
}
/**
 * 双重分派
 *
 * @author Levin
 * @create 2017/12/19 0019
 */
public class Client {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Dog baby1 = new DogBaby1();
        Dog baby2 = new DogBaby2();
        Execute exe = new Execute();
        dog.accept(exe);
        baby1.accept(exe);
        baby2.accept(exe);
    }
}

</>复制代码 
运行结果

</>复制代码 
上古 Dog
上古Dog第一代子孙
上古Dog第二代子孙

从结果可以看出：双分派实现动态绑定的本质，就是在重载方法委派的前面加上了继承体系中覆盖的环节，由于覆盖是动态的，所以重载就是动态的了！！！

访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。

</>复制代码 
优点

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

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

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

</>复制代码 
缺点

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

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

</>复制代码 
使用场景

数据结构稳定，作用于数据结构的操作经常变化的时候。

当一个数据结构中，一些元素类需要负责与其不相关的操作的时候，为了将这些操作分离出去，以减少这些元素类的职责时，可以使用访问者模式。

有时在对数据结构上的元素进行操作的时候，需要区分具体的类型，这时使用访问者模式可以针对不同的类型，在访问者类中定义不同的操作，从而去除掉类型判断。

参考文献：http://www.cnblogs.com/JsonShare/p/7380772.html

全文代码：https://gitee.com/battcn/design-pattern/tree/master/Chapter19/battcn-visitor

个人QQ：1837307557

battcn开源群（适合新手）：391619659

微信公众号：battcn（欢迎调戏）