• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

【趣味设计模式系列】之【访问者模式】

开发技术 开发技术 2周前 (09-06) 20次浏览

1. 简介

访问者模式(Visitor Pattern):表示一个作用在某对象结构中的元素的操作,它可以在不改变类的元素的前提下,定义作用于这些元素的新操作。这是《设计模式-可复用面向对象软件的基础》中的定义。换句通俗的话,就是类的结构元素不变,可以根据访问者重新定义元素的操作

2. 示例

2.1 水果套餐例子

假如有个水果套餐,是苹果、香蕉、橘子的组合,套餐内的水果种类一般不改变,需要对该购买套餐的消费者实行优惠,个人总价打9折,公司团购打8折,要求在不改变原有套餐内部元素与内部方法的情况下,根据外部访问者的变化,重新定义新的价格算法,如图所示
【趣味设计模式系列】之【访问者模式】

类图如下:
【趣味设计模式系列】之【访问者模式】

FruitPackage水果接口,接受访问者的方法accept,计算价格的方法getPrice

package com.wzj.visitor.example1;

/**
 * @Author: wzj
 * @Date: 2020/9/2 20:16
 * @Desc: 水果套餐
 */
interface FruitPackage {
    void accept(Visitor v);
    double getPrice();
}

套餐内的每个元素苹果、橘子、香蕉分别实现水果套餐接口FruitPackage,内部accept方法各种去访问对应的元素,并把当前元素的实例this传进去,Apple类

package com.wzj.visitor.example1;

/**
 * @Author: wzj
 * @Date: 2020/9/2 20:16
 * @Desc: 苹果
 */
public class Apple implements FruitPackage {

    @Override
    public void accept(Visitor visitor) {
        visitor.visitApple(this);
    }

    @Override
    public double getPrice() {
        return 30;
    }
}

Orange类

package com.wzj.visitor.example1;

import com.wzj.proxy.v8.Discount;

/**
 * @Author: wzj
 * @Date: 2020/8/4 20:45
 * @Desc: 橘子
 */
public class Orange implements FruitPackage {

    @Override
    public void accept(Visitor visitor) {
        visitor.visitOrange(this);
    }

    @Override
    public double getPrice() {
        return 50;
    }
}

Banana类

package com.wzj.visitor.example1;

/**
 * @Author: wzj
 * @Date: 2020/9/2 20:16
 * @Desc: 香蕉
 */
public class Banana implements FruitPackage {

    @Override
    public void accept(Visitor visitor) {
        visitor.visitBanana(this);
    }

    @Override
    public double getPrice() {
        return 40;
    }
}

定义访问者接口,内部依次定义访问每个元素的方法

package com.wzj.visitor.example1;

/**
 * @Author: wzj
 * @Date: 2020/9/2 20:14
 * @Desc: 访问者接口
 */
public interface Visitor {

    void visitApple(Apple apple);

    void visitOrange(Orange orange);

    void visitBanana(Banana banana);

}

个人访问者PersonelVisitor类

package com.wzj.visitor.example1;

/**
 * @Author: wzj
 * @Date: 2020/9/2 20:40
 * @Desc: 个人访问者--一律9折
 */
public class PersonelVisitor implements Visitor{

    double totalPrice = 0.0;


    @Override
    public void visitApple(Apple apple) {
        totalPrice += apple.getPrice() * 0.9;
    }

    @Override
    public void visitOrange(Orange orange) {
        totalPrice += orange.getPrice() * 0.9;
    }

    @Override
    public void visitBanana(Banana banana) {
        totalPrice += banana.getPrice() * 0.9;
    }
}

团购访问者GroupVisitor类

package com.wzj.visitor.example1;

/**
 * @Author: wzj
 * @Date: 2020/9/2 20:41
 * @Desc:  团购访问者--一律8折
 */
public class GroupVisitor implements Visitor{

    double totalPrice = 0.0;


    @Override
    public void visitApple(Apple apple) {
        totalPrice += apple.getPrice() * 0.8;
    }

    @Override
    public void visitOrange(Orange orange) {
        totalPrice += orange.getPrice() * 0.8;
    }

    @Override
    public void visitBanana(Banana banana) {
        totalPrice += banana.getPrice() * 0.8;
    }
}

具体水果套餐类ConcretePackage,把包含三个水果的元素组装起来

package com.wzj.visitor.example1;

/**
 * @Author: wzj
 * @Date: 2020/9/2 20:51
 * @Desc: 具体套餐,苹果、香蕉、橘子
 */
public class ConcretePackage implements FruitPackage{
    Apple apple;
    Orange orange;
    Banana banana;

    public ConcretePackage(Apple apple, Orange orange, Banana banana) {
        this.apple = apple;
        this.orange = orange;
        this.banana = banana;
    }

    public void accept(Visitor visitor) {
        this.apple.accept(visitor);
        this.orange.accept(visitor);
        this.banana.accept(visitor);
    }

    @Override
    public double getPrice() {
        return apple.getPrice() + orange.getPrice() + banana.getPrice();
    }
}

客户端类Client

package com.wzj.visitor.example1;

import org.aspectj.weaver.ast.Or;

/**
 * @Author: wzj
 * @Date: 2020/9/2 20:57
 * @Desc:
 */
public class Client {
    public static void main(String[] args) {
        Apple apple = new Apple();
        Orange orange = new Orange();
        Banana banana = new Banana();
        //个人套餐价格
        PersonelVisitor p = new PersonelVisitor();
        new ConcretePackage(apple, orange, banana).accept(p);
        System.out.println("个人套餐价格:" + p.totalPrice);
        //公司套餐价格
        GroupVisitor g = new GroupVisitor();
        new ConcretePackage(apple, orange, banana).accept(g);
        System.out.println("公司套餐价格:" + g.totalPrice);
    }
}

最后运行结果

个人套餐价格:108.0
公司套餐价格:96.0

2.2 台式机组装例子

假如有个台式机组装,为简化起见,是组装元素由固定的三部分组成,CPU、内存条、主板,现对个人来访者总价打9折,公司团购来访者总价打8折,要求在不改变原有套餐内部元素与内部方法的情况下,根据外部访问者的变化,重新定义新的价格算法,如图所示
【趣味设计模式系列】之【访问者模式】
类图设计
【趣味设计模式系列】之【访问者模式】

电脑部件类ComputerPart

package com.wzj.visitor.example2;

/**
 * @Author: wzj
 * @Date: 2020/9/2 21:15
 * @Desc: 电脑部件
 */
public interface ComputerPart {

    void accept(Visitor v);
    double getPrice();
}

CPU类、Memory类、Board类如下:

package com.wzj.visitor.example2;

/**
 * @Author: wzj
 * @Date: 2020/9/2 21:13
 * @Desc: CPU
 */
public class CPU implements ComputerPart{
    @Override
    public void accept(Visitor v) {
        v.visitCpu(this);
    }

    @Override
    public double getPrice() {
        return 1000;
    }
}

package com.wzj.visitor.example2;

/**
 * @Author: wzj
 * @Date: 2020/9/2 21:13
 * @Desc: 内存条
 */
public class Memory implements ComputerPart{
    @Override
    public void accept(Visitor v) {
        v.visitMemory(this);
    }

    @Override
    public double getPrice() {
        return 500;
    }
}

package com.wzj.visitor.example2;

/**
 * @Author: wzj
 * @Date: 2020/9/2 21:13
 * @Desc: CPU
 */
public class Board implements ComputerPart{
    @Override
    public void accept(Visitor v) {
        v.visitBoard(this);
    }

    @Override
    public double getPrice() {
        return 800;
    }
}

个人访问者PersonelVisitor类

package com.wzj.visitor.example2;

/**
 * @Author: wzj
 * @Date: 2020/9/2 21:21
 * @Desc: 个人购买9折
 */
public class PersonelVisitor implements Visitor {
    double totalPrice = 0.0;

    @Override
    public void visitCpu(CPU cpu) {
        totalPrice += cpu.getPrice() * 0.9;
    }

    @Override
    public void visitMemory(Memory memory) {
        totalPrice += memory.getPrice() * 0.9;
    }

    @Override
    public void visitBoard(Board board) {
        totalPrice += board.getPrice() * 0.9;
    }
}

团购访问者GroupVisitor类

package com.wzj.visitor.example2;

/**
 * @Author: wzj
 * @Date: 2020/9/2 21:21
 * @Desc:  公司团购8折
 */
public class GroupVisitor implements Visitor {
    double totalPrice = 0.0;

    @Override
    public void visitCpu(CPU cpu) {
        totalPrice += cpu.getPrice() * 0.8;
    }

    @Override
    public void visitMemory(Memory memory) {
        totalPrice += memory.getPrice() * 0.8;
    }

    @Override
    public void visitBoard(Board board) {
        totalPrice += board.getPrice() * 0.8;
    }
}

电脑类Computer类

package com.wzj.visitor.example2;

/**
 * @Author: wzj
 * @Date: 2020/9/2 21:24
 * @Desc:  电脑
 */
public class Computer {

    CPU cpu;
    Memory memory;
    Board board;

    public Computer(CPU cpu, Memory memory, Board board) {
        this.cpu = cpu;
        this.memory = memory;
        this.board = board;
    }

    public void acccept(Visitor v) {
        this.cpu.accept(v);
        this.memory.accept(v);
        this.board.accept(v);
    }
}

客户端Client类

package com.wzj.visitor.example2;

/**
 * @Author: wzj
 * @Date: 2020/9/2 21:24
 * @Desc:
 */
public class Client {
    public static void main(String[] args) {
        CPU cpu = new CPU();
        Memory memory = new Memory();
        Board board = new Board();
        PersonelVisitor p = new PersonelVisitor();
        new Computer(cpu, memory, board).acccept(p);
        System.out.println("个人套餐价格:" + p.totalPrice);
        GroupVisitor g = new GroupVisitor();
        new Computer(cpu, memory, board).acccept(g);
        System.out.println("公司套餐价格:" + g.totalPrice);
    }
}

结果:

个人套餐价格:2070.0
公司套餐价格:1840.0

3. 应用场景分析

访问者模式一般用在特定的场景中,在经典的四人帮写的【设计模式】一书中,举了编译器的例子,如果需要将源程序表示一个抽象语法树,编译器需要对抽象语法树实施某些操作,如类型检查、代码优化优化格式打印,大多数操作对于不同节点进行不同处理,但是对于编译器来说,节点类的集合对于给定的语言,内部结构很少变化,如下图
【趣味设计模式系列】之【访问者模式】

编译器对使用访问者对程序进行类型检查,它将创建一个TypeCheckingVisitor对象,并以这个对象为传入参数,在抽象语法树上调用accept方法,每一个节点在实现accept方法时会回调访问者:一个赋值节点AssignmentNode对象会回调visitAssignment(this)方法,一个变量引用节点VariableRefNode对象会调用visitVariableRef(this)方法。

笔者在【趣味设计模式系列】之【代理模式4–ASM框架解析】里面分析的ASM框架也是运用的访问者模式,几个核心类的关系如下图
【趣味设计模式系列】之【访问者模式】
成员变量节点FieldNode类、方法节点MethodNode类,拥有接收访问者的方法accept,通过传入的具体的访问者ClassAdapter类或ClassWriter类,方法内部各自调用具体访问者访问自己部件的方法,对应途中的访问属性visitField,访问方法visitMethod。

4. 总结

4.1 双分派技术

讲到访问者模式,大部分书籍或者资料都会讲到 Double Dispatch,中文翻译为双分派。为什么支持双分派的语言就不需要访问者模式。

既然有 Double Dispatch,对应的就有 Single Dispatch。所谓 Single Dispatch,指的是执行哪个对象的方法,根据对象的运行时类型来决定;执行对象的哪个方法,根据方法参数的编译时类型来决定。所谓 Double Dispatch,指的是执行哪个对象的方法,根据对象的运行时类型来决定;执行对象的哪个方法,根据方法参数的运行时类型来决定。

如何理解“Dispatch”这个单词呢?在面向对象编程语言中,我们可以把方法调用理解为一种消息传递,也就是“Dispatch”。一个对象调用另一个对象的方法,就相当于给它发送一条消息。这条消息起码要包含对象名、方法名、方法参数。如何理解“Single”“Double”这两个单词呢?“Single”“Double”指的是执行哪个对象的哪个方法,跟几个因素的运行时类型有关。我们进一步解释一下。Single Dispatch 之所以称为“Single”,是因为执行哪个对象的哪个方法,只跟“对象”的运行时类型有关。Double Dispatch 之所以称为“Double”,是因为执行哪个对象的哪个方法,跟“对象”和“方法参数”两者的运行时类型有关。

Java 支持多态特性,代码可以在运行时获得对象的实际类型(也就是前面提到的运行时类型),然后根据实际类型决定调用哪个方法。尽管 Java 支持函数重载,但 Java 设计的函数重载的语法规则是,并不是在运行时,根据传递进函数的参数的实际类型,来决定调用哪个重载函数,而是在编译时,根据传递进函数的参数的声明类型(也就是前面提到的编译时类型),来决定调用哪个重载函数。也就是说,具体执行哪个对象的哪个方法,只跟对象的运行时类型有关,跟参数的运行时类型无关。所以,Java 语言只支持 Single Dispatch。
举个例子来具体说明一下,代码如下所示:


public class ParentClass {
  public void f() {
    System.out.println("I am ParentClass's f().");
  }
}

public class ChildClass extends ParentClass {
  public void f() {
    System.out.println("I am ChildClass's f().");
  }
}

public class SingleDispatchClass {
  public void polymorphismFunction(ParentClass p) {
    p.f();
  }

  public void overloadFunction(ParentClass p) {
    System.out.println("I am overloadFunction(ParentClass p).");
  }

  public void overloadFunction(ChildClass c) {
    System.out.println("I am overloadFunction(ChildClass c).");
  }
}

public class DemoMain {
  public static void main(String[] args) {
    SingleDispatchClass demo = new SingleDispatchClass();
    ParentClass p = new ChildClass();
    demo.polymorphismFunction(p);//执行哪个对象的方法,由对象的实际类型决定
    demo.overloadFunction(p);//执行对象的哪个方法,由参数对象的声明类型决定
  }
}

//代码执行结果:
I am ChildClass's f().
I am overloadFunction(ParentClass p).

这也回答了为什么支持 Double Dispatch 的语言不需要访问者模式。

访问者模式允许在不改变类的情况下,有效的增加新的操作,这是一种很著名的技术,意味着执行的操作取决于请求的种类与接受者类型,accept方法是一个双分派操作, 取决于visitor类型与Node节点类型,使得访问者可以对每一种类型的请求执行不用的操作。

4.2 优点

  • 容易增加新的操作
    如果有复杂对象结构,需要增加新的操作,只需要增加新的访问者定义新操作即可。
  • 集中相关操作分离无关操作
    相关行为集中在访问者中,无关行为被分离到各自访问者的关子类中,所有与算法相关的数据结构都被隐藏在访问者中。

4.3 缺点

  • 具体元素对访问者公布,破坏封装;
  • 访问者依赖具体元素,而非依赖抽象,破坏了依赖倒置原则,导致具体元素的增加、删除、修改比较困难。

综上,访问者模式一般都用在类似于编译器等比较窄却很专业的场景中,如果自己非要使用,适合类的结构元素不变的情况下,需要重新定义元素操作。


附:githup源码下载地址:https://github.com/wuzhujun2006/design-patterns


喜欢 (0)