设计模式--访问者模式

2017-12-14 本文已影响87人 w1992wishes

一堆信函，这里面不一定都是投降信，也有可能是离间信，讨伐信等等（只是假如），曹操的做法是一视同仁，全都烧了。如果将袁绍和曹操互换一下，我猜，袁绍肯定会每封信都打开看，投降的全都斩掉，离间的全部封赏。再换一个孙权，刘备，结果又会怎样？

这里可以引出访问者模式。

在软件开发中，有些对象结构（一堆信函）可能存储了不同类型的对象（投降信，离间信），而且对对象结构中的元素的操作方式并不唯一，可能需要提供多种不同的处理方式（曹操把所有的信都烧掉；袁绍把投降信的主人全部杀掉，离间信的主人则封赏），还有可能增加新的处理方式（刘备，孙权处理这些信）。

在设计模式中，访问者模式可以满足上述要求，其模式动机就是以不同的方式操作复杂对象结构。

二、什么是访问者模式

访问者模式是一种较为复杂的行为型设计模式，它包含访问者和被访问元素两个主要组成部分，这些被访问的元素通常具有不同的类型，且不同的访问者可以对它们进行不同的访问操作（就是引言中说的不同的领导（曹操，袁绍，刘备等）对一堆信函进行不同的处理方式）。访问者模式使得用户可以在不修改现有系统的情况下扩展系统的功能，为这些不同类型的元素增加新的操作。

在使用访问者模式时，被访问元素通常不是单独存在的，它们存储在一个集合中，这个集合被称为“对象结构”，访问者通过遍历对象结构实现对其中存储的元素的逐个操作。

访问者模式定义如下：

访问者模式(Visitor Pattern):提供一个作用于某对象结构中的各元素的操作表示，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。

可以对定义这么理解：有这么一个操作，它是作用于一些元素之上的，而这些元素属于某一个对象结构。同时这个操作是在不改变各元素类的前提下，在这个前提下定义新操作是访问者模式精髓中的精髓。

三、模式的结构

访问者模式UML类图如下：

访问者模式类图

在访问者模式结构图中包含如下几个角色：

Vistor（抽象访问者）：抽象访问者为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素的类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作。
ConcreteVisitor（具体访问者）：具体访问者实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型的元素。
Element（抽象元素）：抽象元素一般是抽象类或者接口，它定义一个accept()方法，该方法通常以一个抽象访问者作为参数。
ConcreteElement（具体元素）：具体元素实现了accept()方法，在accept()方法中调用访问者的访问方法以便完成对一个元素的操作。
ObjectStructure（对象结构）：对象结构是一个元素的集合，它用于存放元素对象，并且提供了遍历其内部元素的方法。它可以结合组合模式来实现，也可以是一个简单的集合对象，如一个List对象或一个Set对象。

访问者模式中对象结构存储了不同类型的元素对象，以供不同访问者访问。访问者模式包括两个层次结构，一个是访问者层次结构，提供了抽象访问者和具体访问者，一个是元素层次结构，提供了抽象元素和具体元素。相同的访问者可以以不同的方式访问不同的元素，相同的元素可以接受不同访问者以不同访问方式访问。在访问者模式中，增加新的访问者无须修改原有系统，系统具有较好的可扩展性。

在访问者模式中，抽象访问者定义了访问元素对象的方法，通常为每一种类型的元素对象都提供一个访问方法，而具体访问者可以实现这些访问方法。这些访问方法的命名一般有两种方式：一种是直接在方法名中标明待访问元素对象的具体类型，如visitElementA(ElementA elementA)，还有一种是统一取名为visit()，通过参数类型的不同来定义一系列重载的visit()方法。

四、典型代码

抽象访问者典型代码如下（利用重载）：

public interface Visitor {
    void visit(ConcreteElementA elementA);
    void visit(ConcreteElementB elementB);
}

具体访问者典型代码：

public class ConcreteVisitorA implements Visitor {
    public void visit(ConcreteElementA elementA) {
        //todo
    }

    public void visit(ConcreteElementB elementB) {
        //todo
    }
}

public class ConcreteVisitorB implements Visitor {
    public void visit(ConcreteElementA elementA) {
        //todo
    }

    public void visit(ConcreteElementB elementB) {
        //todo
    }
}

抽象元素类典型代码：

public interface Element {
    void accept(Visitor visitor);
}

accept方法传入了一个抽象访问者Visitor类型的参数，即针对抽象访问者进行编程，而不是具体访问者，在程序运行时再确定具体访问者的类型，并调用具体访问者对象的visit()方法实现对元素对象的操作。

具体元素类典型代码如下：

public class ConcreteElementA implements Element{
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public class ConcreteElementB implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

在访问者模式中，对象结构是一个集合，它用于存储元素对象并接受访问者的访问，其典型代码如下:

public class ObjectStructure {
    private List<Element> elements = new ArrayList<Element>();

    public void addElement(Element e){
        elements.add(e);
    }

    public void removeElement(Element e){
        elements.remove(e);
    }

    public void accept(Visitor visitor){
        for (Iterator<Element> itr = elements.iterator(); itr.hasNext();){
            itr.next().accept(visitor);
        }
    }
}

在对象结构中可以使用迭代器对存储在集合中的元素对象进行遍历，并逐个调用每一个对象的accept()方法，实现对元素对象的访问操作。

五、访问者模式中的伪动态双分派

先了解静态分派以及动态分派：

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

List list = null;
list = new ArrayList();

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

根据对象的类型而对方法进行的选择，就是分派(Dispatch)，分派(Dispatch)又分为两种，即静态分派和动态分派。静态分派(Static Dispatch)发生在编译时期，分派根据静态类型信息发生。

5.1、静态分派

静态分派就是按照变量的静态类型进行分派，从而确定方法的执行版本，静态分派在编译时期就可以确定方法的版本。静态分派最典型的应用就是方法重载。

public class StaticDispatch {

    public void test(String string){
        System.out.println("this is string");
    }

    public void test(Integer integer){
        System.out.println("this is integer");
    }

    public static void staticDispatch(String[] args) {
        String string = "aaaaa";
        Integer integer = 1;
        StaticDispatch staticDispatch = new StaticDispatch();
        staticDispatch.test(integer);
        staticDispatch.test(string);
    }
}

在静态分派判断的时候，根据多个判断依据（即参数类型和个数）判断出了方法的版本，那么这个就是多分派的概念，因为有一个以上的考量标准，也可以称为宗量。所以JAVA是静态多分派的语言。

5.2、动态分派

对于动态分派，与静态相反，它不是在编译期确定的方法版本，而是在运行时才能确定。而动态分派最典型的应用就是多态的特性。

interface Animal{
    void test();
}
class Dog implements Animal{
    public void test(){
        System.out.println("dog");
    }
}
class Cat implements Animal{
    public void test(){
        System.out.println("cat");
    }
}
public class DynamicDispatch {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        dog.test();
        cat.test();
    }
}

这里的test方法版本，就无法根据dog和cat的静态类型去判断了，他们的静态类型都是Animal接口，根本无从判断。

显然，产生的输出结果，就是因为test方法的版本是在运行时判断的，这就是动态分派。

动态分派判断的方法是在运行时获取到dog和cat的实际引用类型，再确定方法的版本，而由于此时判断的依据只是实际引用类型，只有一个判断依据，所以这就是单分派的概念，这时我们的考量标准只有一个宗量，即变量的实际引用类型。相应的，这说明JAVA是动态单分派的语言。

5.3、伪动态双分派

访问者模式中使用的是伪动态双分派，所谓的动态双分派就是在运行时依据两个实际类型去判断一个方法的运行行为，而访问者模式实现的手段是进行了两次动态单分派来达到这个效果。

public void accept(Visitor visitor){
        for (Iterator<Element> itr = elements.iterator(); itr.hasNext();){
            itr.next().accept(visitor);
        }
    }

这里就是依据element和visitor两个实际类型决定了visit方法的版本，从而决定了accept方法的动作。

accept方法具体执行过程如下:

调用具体元素类的accept(Visitor visitor)方法，并将Visitor子类对象作为其参数，根据visitor的实际类型决定是调用ConcreteElementA还是ConcreteElementB的accept方法。
这时accept方法的版本已经确定，假如是ConcreteElementA，它的accept方法是调用下面这行代码。

public class ConcreteElementA implements Element{
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

此时的this是ConcreteElementA类型，所以对应于Visitor接口的visit(ConcreteElementA elementA)方法，此时需要再根据visitor的实际类型确定visit方法的版本，如此一来，就完成了动态双分派的过程。

以上的过程就是通过两次动态双分派，第一次对accept方法进行动态分派，第二次对visit方法进行动态分派，从而达到了根据两个实际类型确定一个方法的行为的效果。

六、代码示例

还是以引言中的曹操烧信为例：

6.1、不使用访问者模式

public class LetterList {
    List<Letter> letters = new ArrayList<Letter>();

    public void addLetter(Letter letter){
        letters.add(letter);
    }

    public void handle(String name){
        if ("caocao".equals(name)){
            for (Letter letter : letters){
                System.out.println("把信全部烧掉");
            }
        }else if ("yuanshao".equals(name)){
            for (Letter letter : letters){
                if (letter.getClass().getSimpleName().equals("SurrenderLetter")){
                    System.out.println("把写投降信的全部杀掉");
                }else if (letter.getClass().getSimpleName().equals("DivideLetter")){
                    System.out.println("写离间信的全部封赏");
                }
            }
        }
    }
}

handle方法对人物名字和信的类型进行判断，不同人对不同类型的不同信件做了不同处理，功能基本实现，但该解决方案存在如下几个问题：

LetterList类非常庞大，它将每个人处理每种信件的方式代码集中在一个类中，在具体实现时，代码将相当冗长，LetterList类承担了过多的职责，既不方便代码的复用，也不利于系统的扩展，违背了“单一职责原则”。
在代码中包含大量的“if…else…”条件判断语句，既需要对不同人进行判断，又需要对不同类型的信件进行判断，出现嵌套的条件判断语句，导致测试和维护难度增大。
如果要增加一个新的人物（“刘备”）来处理这些信件，不得不修改LetterList类的源代码，在handle()方法中增加一个新的条件判断语句和一些业务处理代码来实现新增人物的访问操作。这违背了“开闭原则”，系统的灵活性和可扩展性有待提高。
如果要增加一种新类型的信件，同样需要修改LetterList类的源代码，这也违背了“开闭原则”。

6.2、使用访问者模式

抽象信件：

public interface Letter {
    void accept(Person person);
}

具体信件：

public class SurrenderLetter implements Letter{
    private String writer;

    public SurrenderLetter(String writer) {
        this.writer = writer;
    }

    public String getWriter() {
        return writer;
    }

    public void setWriter(String writer) {
        this.writer = writer;
    }

    public void accept(Person person) {
        person.handle(this);
    }
}

public class DivideLetter implements Letter {
    private String writer;

    public DivideLetter(String writer) {
        this.writer = writer;
    }

    public void setWriter(String writer) {
        this.writer = writer;
    }

    public String getWriter() {
        return writer;
    }

    public void accept(Person person) {
        person.handle(this);
    }
}

抽象元素类：

public interface Person {
    void handle(SurrenderLetter letter);
    void handle(DivideLetter letter);
}

具体元素类：

public class CaoCao implements Person {
    public void handle(SurrenderLetter letter) {
        System.out.println("不看了，烧掉");
    }

    public void handle(DivideLetter letter) {
        System.out.println("不看了，烧掉");
    }
}

public class YuanShao implements Person {
    public void handle(SurrenderLetter letter) {
        System.out.println("把" + letter.getWriter() + "杀掉");
    }

    public void handle(DivideLetter letter) {
        System.out.println("给" + letter.getWriter() + "封赏");
    }
}

复杂结构：

public class LetterList {
    private List<Letter> letters = new ArrayList<Letter>();

    public void add(Letter letter){
        letters.add(letter);
    }

    public void accept(Person person){
        for (Letter letter : letters){
            letter.accept(person);
        }
    }
}

这样一改，发现代码就优雅多了，新增处理人，不需要改动源码，只需新增具体访问者就好，从增加新的访问者的角度来看，访问者模式符合“开闭原则”。当然如果新增具体元素，则必须对原有系统进行修改，在原有的抽象访问者类和具体访问者类中增加相应的访问方法。从增加新的元素的角度来看，访问者模式违背了“开闭原则”。

七、访问者模式与组合模式联用

访问者模式中，包含一个用于存储元素对象集合的对象结构，具体元素之间可以存在整体与部分关系，有些元素作为容器对象，有些元素作为成员对象，可以使用组合模式来组织元素。

模式联用

由于叶子元素的遍历操作已经在容器元素中完成，因此要防止单独将已增加到容器元素中的叶子元素再次加入对象结构中，对象结构中只保存容器元素和孤立的叶子元素。

八、优点和缺点

8.1、优点

使得对象结构和作用于结构上的操作解耦，使得操作集合可以独立变化。
添加新的操作或者说访问者会非常容易，无须修改源代码，符合“开闭原则”。
将有关元素对象的操作集中到一个访问者对象中，而不是分散在一个个的元素类中。类的职责更加清晰，有利于对象结构中元素对象的复用，相同的对象结构可以供多个不同的访问者访问。
使得类层次结构不改变的情况下，可以针对各个层次做出不同的操作，而不影响类层次结构的完整性。
可以跨越类层次结构，访问不同层次的元素类，做出相应的操作。

8.2、缺点

增加新的元素会非常困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”的要求。
实现起来比较复杂，会增加系统的复杂性。
破坏封装，如果将访问行为放在各个元素中，则可以不暴露元素的内部结构和状态，但使用访问者模式的时候，为了让访问者能获取到所关心的信息，元素类不得不暴露出一些内部的状态和结构，就像信件类必须提供访问写信人的方法一样。

九、适用环境

对象结构稳定，作用于对象结构的操作经常变化的时候。
当一个对象结构中，一些元素类需要负责与其不相关的操作的时候，为了将这些操作分离出去，以减少这些元素类的职责时，可以使用访问者模式。
有时在对对象结构上的元素进行操作的时候，需要区分具体的类型，这时使用访问者模式可以针对不同的类型，在访问者类中定义不同的操作，从而去除掉类型判断。