访问者模式

Visitor

2010-05-21 约 1918 字预计阅读 4 分钟

定义

访问者模式即表示一个作用于某对象结构中的各元素的操作，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

动机：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作，一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。为不同类型的元素提供多种访问操作方式，且可以在不修改原有系统的情况下增加新的操作方式。

同时我们还需要明确一点那就是访问者模式是适用于那些数据结构比较稳定的，因为他是将数据的操作与数据结构进行分离了，如果某个系统的数据结构相对稳定，但是操作算法易于变化的话，就比较适用适用访问者模式，因为访问者模式使得算法操作的增加变得比较简单了。

参与者：

Vistor: 抽象访问者。为该对象结构中的ConcreteElement的每一个类声明的一个操作。
ConcreteVisitor: 具体访问者。实现Visitor申明的每一个操作，每一个操作实现算法的一部分。
Element: 抽象元素。定义一个Accept操作，它以一个访问者为参数。
ConcreteElement: 具体元素。实现Accept操作。
ObjectStructure: 对象结构。能够枚举它的元素，可以提供一个高层的接口来允许访问者访问它的元素。

问者模式主要分为两个层次结构，

一个是访问者层次结构，提供了抽象访问者和具体访问者，主要用于什么一些操作。
一个是元素层次结构，提供了抽象元素和具体元素，主要用于声明Accept操作。

访问者模式用到了一种双分派的技术，所谓双分派技术就是在选择一个方法的时候，不仅仅要根据消息接收者（receiver）的运行时区别（Run time type），还要根据参数的运行时区别。在访问者模式中，客户端将具体状态当做参数传递给具体访问者，这里完成第一次分派，然后具体访问者作为参数的“具体状态”中的方法，同时也将自己this作为参数传递进去，这里就完成了第二次分派。双分派意味着得到的执行操作决定于请求的种类和接受者的类型。

实现

以医院付费、取药为实例。在这个实例中划价员和药房工作者作为访问者，药品作为访问元素、处方单作为对象结构

抽象访问者

1
2
3
4
5
6
7


public abstract class Visitor {
    protected String name;
    public void setName(String name) {
        this.name = name;
    }    
    public abstract void visitor(Medicine a);
}

具体访问者：划价员Charger、药房工作者WorkerOfPharmacy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class Charger extends Visitor{
    public void visitor(Medicine a) {
        System.out.println("划价员：" + name +"给药" + a.getName() +"划价:" + a.getPrice());
    }  
}
public class WorkerOfPharmacy extends Visitor{
    public void visitor(Medicine a) {
        System.out.println("药房工作者：" + name + "拿药 ：" + a.getName());
    }  
}

抽象元素

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


public abstract class Medicine {
    protected String name;
    protected double price;
    public Medicine (String name,double price){
        this.name = name;
        this.price = price;
    }    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }    
    public void setPrice(double price) {
        this.price = price;
    }    
    public abstract void accept(Visitor visitor);
}

具体元素

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public class MedicineA extends Medicine{
    public MedicineA(String name, double price) {
        super(name, price);
    }
    public void accept(Visitor visitor) {
        visitor.visitor(this);
    }
}
public class MedicineB extends Medicine{
    public MedicineB(String name, double price) {
        super(name, price);
    }
    public void accept(Visitor visitor) {
        visitor.visitor(this);
    }
}

对象结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


public class Presciption {
    List<Medicine> list = new ArrayList<Medicine>();    
    public void accept(Visitor visitor){
        Iterator<Medicine> iterator = list.iterator();        
        while (iterator.hasNext()) {
            iterator.next().accept(visitor);
        }
    }    
    public void addMedicine(Medicine medicine){
        list.add(medicine);
    }    
    public void removeMedicien(Medicine medicine){
        list.remove(medicine);
    }
}

客户端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public class Client {
    public static void main(String[] args) {
        Medicine a = new MedicineA("板蓝根", 11.0);
        Medicine b = new MedicineB("感康", 14.3);

        Presciption presciption = new Presciption();
        presciption.addMedicine(a);
        presciption.addMedicine(b);
        
        Visitor charger = new Charger();
        charger.setName("张三");
        
        Visitor workerOfPharmacy = new WorkerOfPharmacy();
        workerOfPharmacy.setName("李四");
        
        presciption.accept(charger);
        presciption.accept(workerOfPharmacy);
    }
}

运行结果：划价员：张三给药板蓝根划价：11.0 划价员：张三给药感康划价：14.3 药房工作者：李四拿药：板蓝根药房工作者：李四拿药：感康

优点

使得新增新的访问操作变得更加简单。
能够使得用户在不修改现有类的层次结构下，定义该类层次结构的操作。
将有关元素对象的访问行为集中到一个访问者对象中，而不是分散搞一个个的元素类中。

缺点

增加新的元素类很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，违背了“开闭原则”的要求。
破坏封装。当采用访问者模式的时候，就会打破组合类的封装。
比较难理解。貌似是最难的设计模式了。

使用场景

对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。
需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。

总结

访问者模式封装了对象结构元素之上的操作，使得新增元素的操作变得非常简单。所以它比较适用于那么对象结构很少变化的类。
访问者模式中对象结构存储了不同类型的元素对象，以供不同访问者访问。

目录

访问者模式

Visitor

定义

实现

使用场景

总结