访问者模式

访问者模式定义

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

访问者模式通用类图.png

思考

为什么需要访问者模式呢，这就要放到OOP之中了，在面向对象编程的思想中，我们使用类来组织属性，以及对属性的操作，那么我们理所当然的将访问操作放到了类的内部，这样看起来没问题，但是当我们想要使用另一种遍历方式要怎么办呢，我们必须将这个类进行修改，这在设计模式中是大忌，在设计模式中就要保证，对扩展开放，对修改关闭的开闭原则。

因此，我们思考，可不可以将访问操作独立出来变成一个新的类，当我们需要增加访问操作的时候，直接增加新的类，原来的代码不需要任何的改变，如果可以这样做，那么我们的程序就是好的程序，因为可以扩展，符合开闭原则。而访问者模式就是实现这个的，使得使用不同的访问方式都可以对某些元素进行访问。

角色定义

  • Visitor——抽象访问者
    抽象类或者接口，声明访问者可以访问哪些数据，具体到程序中就是visit()方法的参数定义对象是可以被访问。
  • ConcreteVisitor——具体访问者
    它影响访问者访问到一个类后该怎么干，要做什么事情。
  • Element——抽象元素
    接口或抽象类，声明接受哪一类访问者访问，程序上是通过accept()方法中的参数来定义。
  • ConcreteElement——具体元素
    实现accept()方法，通常是visitor.visit(this)，基本上就形成了一种模式了。
  • ObjectStrutrue——结构对象
    元素产生者，一般容纳在多个不同类、不同接口的容器，如List，Set，Map等，在项目中，一般很少抽象处这个角色。

通用源码

抽象元素

public abstract class Element {
    /**
    * 定义业务逻辑
    */
    abstract void doSomething();

    /**
    * 允许谁来访问
    * @param ivisitor
    */
    abstract void accept(IVisitor ivisitor);
}

抽象元素有两种方法：一是本身的业务逻辑，也就是元素作为一个业务处理单元必须完成的职责；另外一个是允许哪一个访问者来访问。

具体元素

public class ConcreteElement1 extends Element{
    @Override
    void doSomething() {
        System.out.println("111111111111111");
    }

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

public class ConcreteElement2 extends Element{
    @Override
    void doSomething() {
        System.out.println("2222222222");
    }

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

抽象访问者

public interface IVisitor {
    void visit(ConcreteElement1 element);

    void visit(ConcreteElement2 element);
}

具体访问者

public class Visitor implements IVisitor{
    @Override
    public void visit(ConcreteElement1 element) {
        //访问的一些逻辑
        element.doSomething();
    }

    @Override
    public void visit(ConcreteElement2 element) {
        //访问的一些逻辑
        element.doSomething();
    }
}

结构对象是产生出不同的元素对象，使用工厂方法模拟
结构对象

public class ObjectStructure {
    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 e = ObjectStructure.createElement();
            //接受访问者访问
            e.accept(new Visitor());
        }
    }
}

通过增加访问者，只要是具体元素就非常容易访问，对元素的遍历就更加容易了，甭管它是什么对象，只要它在一个容器中，都可以通过访问者来访问，任务集中化，这就是访问者模式。

访问者模式的应用

访问者模式的优点

  • 符合单一职责原则
    具体元素角色也是Employee抽象类的两个子类负责数据的加载，而Visitor类则负责报表的展现，两个不同的职责非常明确地分开来，各自演绎变化。
  • 优秀的扩展性
    由于职责分开，继续增加对数据的操作是非常快捷的，例如，现在要增加一份给老板看的报表，这份报表格式又有所不同，直接在Visitor中增加一个方法，传递数据后进行整理打印。
  • 灵活性非常高

访问者模式的缺点

  • 具体元素对访问者公布细节
    访问者要访问一个类就必然要求这个类公布一些方法和数据，也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的。
  • 具体元素变更比较困难
    具体元素角色的增加、删除、修改都是比较困难的，就上面那个例子，你想想，你要是想增加一个成员变量，如年龄age，Visitor就需要修改，如果Visitor是一个还好办，多个呢？业务逻辑再复杂点呢？
  • 违背了依赖倒置原则
    访问者依赖的是具体元素，而不是抽象元素，这破坏了依赖倒置原则，特别是在面向对象的编程中,抛弃了对接口的依赖，而直接依赖实现类,扩展比较难。

访问者模式的使用场景

一个对象结构包含很多类对象,它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作，也就说是用迭代器模式已经不能胜任的情景。
需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免让这些操作"污染”这些对象的类。
总结一下，在这种地方你一定要考虑使用访问者模式：业务规则要求遍历多个不同的对象。这本身也是访问者模式出发点，迭代器模式只能访问同类或同接口的数据(当然了，如果你使用instanceof，那么能访问所有的数据，这没有争论)，而访问者模式是对迭代器模式的扩充，可以遍历不同的对象，然后执行不同的操作，也就是针对访问的对象不同,执行不同的操作。访问者模式还有一个用途，就是充当拦截器(Interceptor)角色。

访问者模式的扩展

访问者模式是经常用到的模式，虽然你不注意，有可能你起的名字也不是什么Visitor，但是它确实是非常容易使用到的。

统计功能

统计一下公司人员的工资总额。类图如下：


抽象访问者

public interface IVisitor {
     //首先定义我可以访问普通员工
     public void visit(CommonEmployee commonEmployee);
     //其次定义，我还可以访问部门经理
     public void visit(Manager manager);
     //统计所有员工工资总和
     public int getTotalSalary();
}

具体访问者

public class Visitor implements IVisitor{

    /**
     * 部门经理的工资系数是5
     */
    private final static int MANAGE_COEFFICIENT = 5;

    /**
     * 普通员工的工资系数是2
     */
    private final static int COMMON_EMPLOYEE_COEFFICIENT = 2;

    /**
     * 普通员工的工资总和
     */
    private int commonTotalSalary= 0;

    /**
     * 部门经理的工资总和
     */
    private int manageTotalSalary = 0;


    @Override
    public void visit(CommonEmployee employee) {
        System.out.println(this.getCommonEmployee(employee));
        calCommonSalary(employee.getSalary());
    }

    @Override
    public void visit(Manager manager) {
        System.out.println(this.getManagerInfo(manager));
        calManageSalary(manager.getSalary());
    }

    @Override
    public int getTotalSalary() {
        return this.manageTotalSalary + this.commonTotalSalary;
    }


    /**
     * 计算经理的工资总和
     * @param salary
     */
    private void calManageSalary(int salary){
        this.manageTotalSalary += salary * MANAGE_COEFFICIENT;
    }

    private void calCommonSalary(int salary){
        this.commonTotalSalary += salary * COMMON_EMPLOYEE_COEFFICIENT;
    }

    /**
     * 组装出基本信息
     * @param employee
     * @return
     */
    private String getBasicInfo(Employee employee) {
        String info = "姓名：" + employee.getName() + "\t";
        info += "性别：" + (employee.getSex() == Employee.FEMALE ? "女" : "男") + "\t";
        info += "薪水：" + employee.getSalary() + "\t";
        return info;
    }

    /**
     * 组装出部门经理的信息
     * @param manager
     * @return
     */
    private String getManagerInfo(Manager manager) {
        String basicInfo = this.getBasicInfo(manager);
        String otherInfo = "业绩：" + manager.getPerformance() + "\t";
        return basicInfo + otherInfo;
    }

    /**
    * 组装出普通员工信息
    * @param employee
    * @return
    */
    private String getCommonEmployee(CommonEmployee employee) {
        String basicInfo = this.getBasicInfo(employee);
        String otherInfo = "工作：" + employee.getJob() + "\t";
        return basicInfo + otherInfo;
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        IVisitor visitor = new Visitor();
        for (Employee employee : mockEmployee()) {
            employee.accept(visitor);
        }
        System.out.println("本公司的月工资总额是："+visitor.getTotalSalary());
    }

    /**
     * 模拟出公司的人员情况
     * @return
     */
    public static List<Employee> mockEmployee(){
        List<Employee> employees = new ArrayList<>();

        CommonEmployee zhangsan = new CommonEmployee();
        zhangsan.setJob("编写程序");
        zhangsan.setName("张三");
        zhangsan.setSalary(1800);
        zhangsan.setSex(designpattern.visitor.Employee.MALE);
        employees.add(zhangsan);

        CommonEmployee lisi = new CommonEmployee();
        lisi.setJob("页面美工");
        lisi.setName("李四");
        lisi.setSalary(1900);
        lisi.setSex(designpattern.visitor.Employee.FEMALE);
        employees.add(lisi);

        Manager wangwu = new Manager();
        wangwu.setName("王五");
        wangwu.setPerformance("基本上是负值，但是会拍马屁");
        wangwu.setSalary(1879);
        wangwu.setSex(Employee.MALE);
        employees.add(wangwu);

        return employees;
    }
}

多个访问者

在实际的项目中，一个对象，多个访问者的情况非常多。其实我们上面例子就应该是两个访问者，为什么呢?报表分两种:第一种是展示表，通过数据库查询，把结果展示出来，这个就类似于我们的那个列表；第二种是汇总表，这个是需要通过模型或者公式计算出来的,一般都是批处理结果,这个类似于我们计算工资总额，这两种报表格式是对同一堆数据的两种处理方式。从程序上看，一个类就有个不同的访问者了。修改该后的类如下。


类图看着挺复杂，其实也没什么复杂的,只是多了两个接口和两个实现类，分别负责展示表和汇总表的业务处理，IVisitor接口没有改变。
汇总类接口

public interface ITotalVisitor extends IVisitor{
    void getTotalSalary();
}

具体汇总类

public class TotalVisitor implements ITotalVisitor{
    /**
     * 部门经理的工资系数是5
     */
    private final static int MANAGE_COEFFICIENT = 5;

    /**
     * 普通员工的工资系数是2
     */
    private final static int COMMON_EMPLOYEE_COEFFICIENT = 2;

    /**
     * 普通员工的工资总和
     */
    private int commonTotalSalary= 0;

    /**
     * 部门经理的工资总和
     */
    private int manageTotalSalary = 0;

    @Override
    public void getTotalSalary() {
        System.out.println("本月公司总工资是：" + this.manageTotalSalary + this.commonTotalSalary);
    }


    @Override
    public void visit(CommonEmployee employee) {
        calCommonSalary(employee.getSalary());
    }

    @Override
    public void visit(Manager manager) {
        calManageSalary(manager.getSalary());
    }

    /**
     * 计算经理的工资总和
     * @param salary
     */
    private void calManageSalary(int salary){
        this.manageTotalSalary += salary * MANAGE_COEFFICIENT;
    }

    private void calCommonSalary(int salary){
        this.commonTotalSalary += salary * COMMON_EMPLOYEE_COEFFICIENT;
    }
}

抽象展示类

public interface IShowVisitor extends IVisitor {
    /**
     * 展示报表
     */
    void report();
}

具体展示类

public class ShowVisitor implements IShowVisitor {
    private String info = "";
    @Override
    public void report() {
        System.out.println(info);
    }

    @Override
    public void visit(CommonEmployee employee) {
        this.info += "\n" + this.getCommonEmployee(employee);
    }

    @Override
    public void visit(Manager manager) {
        this.info += "\n" + this.getManagerInfo(manager);
    }

    /**
     * 组装出基本信息
     * @param employee
     * @return
     */
    private String getBasicInfo(Employee employee) {
        String info = "姓名：" + employee.getName() + "\t";
        info += "性别：" + (employee.getSex() == Employee.FEMALE ? "女" : "男") + "\t";
        info += "薪水：" + employee.getSalary() + "\t";
        return info;
    }

    /**
     * 组装出部门经理的信息
     * @param manager
     * @return
     */
    private String getManagerInfo(Manager manager) {
        String basicInfo = this.getBasicInfo(manager);
        String otherInfo = "业绩：" + manager.getPerformance() + "\t";
        return basicInfo + otherInfo;
    }

    /**
     * 组装出普通员工信息
     * @param employee
     * @return
     */
    private String getCommonEmployee(CommonEmployee employee) {
        String basicInfo = this.getBasicInfo(employee);
        String otherInfo = "工作：" + employee.getJob() + "\t";
        return basicInfo + otherInfo;
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        IShowVisitor showVisitor = new ShowVisitor();
        ITotalVisitor totalVisitor = new TotalVisitor();

        for (Employee employee : mockEmployee()) {
            employee.accept(showVisitor);
            employee.accept(totalVisitor);
        }

        showVisitor.report();
        totalVisitor.getTotalSalary();
    }

    /**
     * 模拟出公司的人员情况
     * @return
     */
    public static List<Employee> mockEmployee(){
        List<Employee> employees = new ArrayList<>();

        CommonEmployee zhangsan = new CommonEmployee();
        zhangsan.setJob("编写程序");
        zhangsan.setName("张三");
        zhangsan.setSalary(1800);
        zhangsan.setSex(designpattern.visitor.Employee.MALE);
        employees.add(zhangsan);

        CommonEmployee lisi = new CommonEmployee();
        lisi.setJob("页面美工");
        lisi.setName("李四");
        lisi.setSalary(1900);
        lisi.setSex(designpattern.visitor.Employee.FEMALE);
        employees.add(lisi);

        Manager wangwu = new Manager();
        wangwu.setName("王五");
        wangwu.setPerformance("基本上是负值，但是会拍马屁");
        wangwu.setSalary(1879);
        wangwu.setSex(Employee.MALE);
        employees.add(wangwu);

        return employees;
    }
}

双分派

分派（ dispatch）是指运行环境按照对象的实际类型为其绑定对应方法体的过程。

说到访问者模式就不得不提一下双分派(double dispatch)问题，什么是双分派呢?我们先来解释一下什么是单分派(single dispatch)和多分派(multiple dispatch)，单分派语言处理一个操作是根据请求者的名称和接收到的参数决定的，在Java中有静态绑定和动态绑定之说，它的实现是依据重载(overload)和覆写(override)实现的。

double dispatch（双分派）在选择一个方法的时候，不仅仅要根据消息接收者（receiver） 的运行时型别（Run time type），还要根据参数的运行时型别（Run time type）。这里的消息接收者其实就是方法的调用者。具体来讲就是，对于消息表达式a.m(b)，双分派能够按照a和b的实际类型为其绑定对应方法体。

我们来说一个简单的例子。例如，演员演电影角色，一个演员可以扮演多个角色,我们先定义一个影视中的两个角色:功夫主角和白痴配角，代码如下。
角色接口及实现类

public interface Role {
     //演员要扮演的角色
}
public class KungFuRole implements Role {
     //武功天下第一的角色
}
public class IdiotRole implements Role {
     //一个弱智角色
}

抽象角色

public abstract class AbsActor {
     //演员都能够演一个角色
     public void act(Role role){
             System.out.println("演员可以扮演任何角色");
     }
     //可以演功夫戏
     public void act(KungFuRole role){
             System.out.println("演员都可以演功夫角色");
     }
}

比较简单，这里使用了java的重载
青年演员和老年演员

public class YoungActor extends AbsActor {
     //年轻演员最喜欢演功夫戏
     public void act(KungFuRole role){
             System.out.println("最喜欢演功夫角色");
     }
}
public class OldActor extends AbsActor {
     //不演功夫角色
     public void act(KungFuRole role){
             System.out.println("年龄大了，不能演功夫角色");
     }
}

场景类

public class Client {
     public static void main(String[] args) {
             //定义一个演员
             AbsActor actor = new OldActor();
             //定义一个角色
             Role role = new KungFuRole();
             //开始演戏
             actor.act(role);
             actor.act(new KungFuRole());
             /*
             运行结果：
                演员可以扮演任何角色
                年龄大了,不能演功夫角色
             */
     }
}

重载在编译器期就决定了要调用哪个方法,它是根据role的表面类型而决定调用act(Role role)方法，这是静态绑定；而Actor的执行方法act则是由其实际类型决定的，这是动态绑定。
一个演员可以扮演很多角色，我们的系统要适应这种变化，也就是根据演员、角色两个对象类型,完成不同的操作任务，该如何实现呢?很简单,我们让访问者模式上场就可以解决该问题,只要把角色类稍稍修改即可，代码如下。

引入访问者模式

public interface Role {
     //演员要扮演的角色
     public void accept(AbsActor actor);
}
public class KungFuRole implements Role {
     //武功天下第一的角色
     public void accept(AbsActor actor){
             actor.act(this);
     }
}
public class IdiotRole implements Role {
     //一个弱智角色，由谁来扮演
     public void accept(AbsActor actor){
             actor.act(this);
     }
}

场景类

public class Client {
     public static void main(String[] args) {
             //定义一个演员
             AbsActor actor = new OldActor();
             //定义一个角色
             Role role = new KungFuRole();
             //开始演戏
             role.accept(actor);
             /*
             运行结果如下：
                年龄大了，不能演功夫角色
             */
     }
}

看到没？不管演员类和角色类怎么变化，我们都能够找到期望的方法运行，这就是双反派。双分派意味着得到执行的操作决定于请求的种类和两个接收者的类型，它是多分派的一个特例。从这里也可以看到Java是一个支持双分派的单分派语言。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,189评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,577评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,857评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,703评论 1赞 276
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,705评论 5赞 366
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,620评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,995评论 3赞 396
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,656评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,898评论 1赞 298
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,639评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,720评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,395评论 4赞 319
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,982评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,953评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,195评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 44,907评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,472评论 2赞 342

推荐阅读更多精彩内容

  • 设计模式--访问者模式
    目录 本文的结构如下： 引言 什么是访问者模式 模式的结构 典型代码 访问者模式中的伪动态双分派 代码示例 访问者...
    w1992wishes阅读 856评论 0赞 6
  • 行为型SEQ11 - 访问者模式 Visitor Pattern
    【学习难度：★★☆☆☆，使用频率：★★★☆☆】直接出处：访问者模式梳理和学习：https://github.com...
    BruceOuyang阅读 883评论 2赞 2
  • 25.访问者模式(行为型)
    访问者模式(行为型) 一、相关概述 访问者模式是一种较为复杂的行为型设计模式，它包含访问者和被访问元素两个主要组成...
    哈哈大圣阅读 343评论 0赞 0
  • 设计模式——访问者模式
    在阎宏博士的《JAVA与模式》一书中开头是这样描述访问者（Visitor）模式的：访问者模式是对象的行为模式。访问...
    Ant_way阅读 618评论 0赞 0
  • java设计模式－访问者模式
    定义 访问者模式是对象的行为模式。访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改...
    步积阅读 1,220评论 0赞 3