设计模式-访问者模式

概述：

---

封装某些作用于某种数据结构中各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。

模式中的角色：

---

• 抽象访问者(Visitor)：抽象类或者接口，为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色，这样访问者就可以通过该元素角色的特定接口直接访问它。
• 访问者(ConcreteVisitor)：实现 抽象访问者(Visitor) 的接口所声明的方法，它影响到访问者访问到一个类后该干什么，要做什么事情。
• 抽象元素类(Element)：定义一个接受访问操作(accept())，它以一个访问者(Visitor)作为参数。
• 元素类(ConcreteElement)：实现了抽象元素(Element)所定义的接受操作接口。实现所声明的accept方法，通常都是visitor.visit(this)，基本上已经形成一种定式了。
• 结构对象(ObjectStructure)：这是使用访问者模式必备的角色。它具备以下特性：能枚举它的元素；可以提供一个高层接口以允许访问者访问它的元素；如有需要，可以设计成一个复合对象或者一个聚集（如一个列表或无序集合）。一个元素的容器，一般包含一个容纳多个不同类、不同接口的容器，如List、Set、Map等，在项目中一般很少抽象出这个角色。

例子：

---

class A {
    public void method1(){
        System.out.println("我是A");
    }
    public void method2(B b){
        b.showA(this);
    }
}
class B {
    public void showA(A a){
        a.method1();
    }
}

---

看一下在类A中，方法method1和方法method2的区别在哪里?

• 方法method1很简单，就是打印出一句“我是A“；
• 方法method2稍微复杂一点，使用类B作为参数，并调用类B的showA方法。

再来看一下类B的showA方法，showA方法使用类A作为参数，然后调用类A的method1方法，可以看到，method2方法绕来绕去，无非就是调用了一下自己的method1方法而已，它的运行结果应该也是“我是A”，分析完之后，我们来运行一下这两个方法，并看一下运行结果：

public class Test {  
    public static void main(String[] args){  
        A a = new A();  
        a.method1();  
        a.method2(new B());  
    }  
}

运行结果为：

我是A
我是A

在例子中，对于类A来说，类B就是一个访问者。但是这个例子并不是访问者模式的全部，虽然直观，但是它的可扩展性比较差。

---

代码实现(Java)：

---

package com.mode.visitor;

/**
 * 抽象元素类
 * 被元素类实现，声明接受哪一类访问者访问
 */
public abstract class Element {
    /**
     * 固定调用方法
     * @param visitor
     */
    public abstract void accept(IVisitor visitor);

    public abstract void doSomething();
}

---

package com.mode.visitor;

import com.mode.visitor.vo.ConcreteElementA;
import com.mode.visitor.vo.ConcreteElementB;

/**
 * 抽象访问者
 * 声明访问者类可以访问的元素
 */
public interface IVisitor {
    public void visit(ConcreteElementA elA);

    public void visit(ConcreteElementB elB);
}

---

package com.mode.visitor;

import com.mode.visitor.vo.ConcreteElementA;
import com.mode.visitor.vo.ConcreteElementB;

/**
 * 访问者
 * 实现 抽象访问者 并且重写方法,通过访问者类调用
 */
public class Visitor implements IVisitor {

    public void visit(ConcreteElementA elA) {
        elA.doSomething();
    }

    public void visit(ConcreteElementB elB) {
        elB.doSomething();
    }
}

---

package com.mode.visitor.vo;

import com.mode.visitor.Element;
import com.mode.visitor.IVisitor;

/**
 * 元素类A
 */
public class ConcreteElementA extends Element {
    public void doSomething() {
        System.out.println("这是元素A");
    }

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

---

package com.mode.visitor.vo;

import com.mode.visitor.Element;
import com.mode.visitor.IVisitor;

/**
 * 元素类B
 */
public class ConcreteElementB extends Element {
    public void doSomething() {
        System.out.println("这是元素B");
    }

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

---

package com.mode.visitor;

import java.util.ArrayList;
import java.util.Random;

import com.mode.visitor.vo.ConcreteElementA;
import com.mode.visitor.vo.ConcreteElementB;

/**
 * 结构对象
 */
public class ObjectStruture {

    /**
     * 初始化数据
     */
    public static ArrayList<Element> getList() {
        ArrayList<Element> list = new ArrayList<Element>();
        Random ran = new Random();
        for (int i = 0; i < 10; i++) {
            int a = ran.nextInt(100);
            if (a > 50) {
                list.add(new ConcreteElementA());
            } else {
                list.add(new ConcreteElementB());
            }
        }
        return list;
    }
}

调用：

---

package com.mode.visitor.test;

import java.util.ArrayList;

import com.mode.visitor.Element;
import com.mode.visitor.ObjectStruture;
import com.mode.visitor.Visitor;

/**
 * 测试调用
 */
public class TestClass {
    public static void main(String[] args) {
        ArrayList<Element> list = ObjectStruture.getList();
        for (Element e : list) {
            e.accept(new Visitor());
        }
    }
}

访问者模式适用的情况：

---

1. 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
2. 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。Visitor使得你可以将相关的操作集中起来定义在一个类中。
3. 当该对象结构被很多应用共享时，用Visitor模式让每个应用仅包含需要用到的操作。
4. 定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。如果对象结构类经常 改变，那么可能还是在这些类中定义这些操作较好。

模式总结：

---

1. 优点

   • 符合单一职责原则：凡是适用访问者模式的场景中，元素类中需要封装在访问者中的操作必定是与元素类本身关系不大且是易变的操作，使用访问者模式一方面符合单一职责原则，另一方面，因为被封装的操作通常来说都是易变的，所以当发生变化时，就可以在不改变元素类本身的前提下，实现对变化部分的扩展。
   • 扩展性良好：元素类可以通过接受不同的访问者来实现对不同操作的扩展。

2. 缺点

   • 增加新的元素类比较困难。通过访问者模式的代码可以看到，在访问者类中，每一个元素类都有它对应的处理方法，也就是说，每增加一个元素类都需要修改访问者类（也包括访问者类的子类或者实现类），修改起来相当麻烦。也就是说，在元素类数目不确定的情况下，应该慎用访问者模式。所以，访问者模式比较适用于对已有功能的重构，比如说，一个项目的基本功能已经确定下来，元素类的数据已经基本确定下来不会变了，会变的只是这些元素内的相关操作，这时候，我们可以使用访问者模式对原有的代码进行重构一遍，这样一来，就可以在不修改各个元素类的情况下，对原有功能进行修改。

3. 适用场景

   • 这是一个巧妙而且复杂的模式，它的使用条件比较苛刻。当系统中存在着固定的数据结构，而有着不同的行为，那么访问者模式也许是个不错的选择。
   • 假如一个对象中存在着一些与本对象不相干（或者关系较弱）的操作，为了避免这些操作污染这个对象，则可以使用访问者模式来把这些操作封装到访问者中去。
   • 假如一组对象中，存在着相似的操作，为了避免出现大量重复的代码，也可以将这些重复的操作封装到访问者中去。

代码下载

---

访问者模式VisitorPattern - 11KB

---

参考：
- 访问者模式(百度百科)
- http://cqfly.iteye.com/blog/975791
- http://blog.csdn.net/zhengzhb/article/details/7489639

---