适配器模式之访问者模式

设计模式目录
http://blog.csdn.net/fenglailea/article/details/52733435
风.fox

访问者模式

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

通用类图

组成

• 抽象访问者 Vistor
  抽象接口或类，声明访问者可以访问那些元素，具体到程序中就是Visit方法的参数定义那些对象时可以被访问的
• 具体访问者 ConcreteVistor
  它影响访问者访问到一个类后该怎么干，要做什么事情
• 抽象元素 Element
  接口或者抽象类，声明接受哪一类访问者访问，程序上是通过accept方法中的参数来定义
• 具体元素 ConcreteElement
  实现accept方法，通常是visitor.vist(this)
• 结构对象 ObjectStruture
  元素产生者，一般容纳在多个不同类，不同接口的容器，如List,Set,Map等

通用源码

JAVA

//抽象元素
public abstract class Element{
    //定义业务逻辑
    public abstract void doSomething();
    //允许谁来访问
    public abstract void accept(IVisitor visitor);
}
//具体元素
public class ConcreteElement1 extends Element{
    // 业务逻辑
    public  void doSomething(){
        ...
    }
    //允许谁来访问
    public void accept(IVisitor visitor){
        visitor.visit(this);
    }
}
public class ConcreteElement2 extends Element{
    // 业务逻辑
    public  void doSomething(){
        ...
    }
    //允许谁来访问
    public void accept(IVisitor visitor){
        visitor.visit(this);
    }
}
//抽象访问者
public interface IVisitor{
    //可以访问哪些对象
    public void visit(ConcreteElement1 el1);
    public void visit(ConcreteElement2 el2);
}
//具体访问者
public class Visitor implements IVisitor{
    //可以访问哪些对象
    public void visit(ConcreteElement1 el1){
        el1.doSomething();
    }
    public void visit(ConcreteElement2 el2){
        el2.doSomething();
    }
}
//结构对象
public class ObjectStruture{
    //对象生成器，这里通过一个工厂方法模式模拟
    public static Element createElement{
        Random rand=new Random();
        if(rand.nextInt(100)>50{
            return new ConcreteElement1();
        }else{
            return new ConcreteElement2();
        }
    }
}
//场景类
public class Client{
    public static void main(String[] args){
        for(int i=0;i<10;i++){
            //获得元素对象
            Element el=ObjectStruture.createElement();
            //接受访问者访问
            el.accept(new Visitor);
        }
    }
}

优点

符合单一职责原则
优秀的扩展性
灵活性非常高

缺点

具体元素对访问者公布细节
具体元素变更比较困难
违背了依赖导致原则

使用场景

一个对象结果包含很多类对象，他们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作，也就说是用迭代器模式已经不能胜任的情景
需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免让这些操作“污染”这些对象的类