一文说透访问者模式

基本介绍

究竟什么是访问者模式呢？

访问者模式(Visitor Pattern)模式是行为型(Behavioral)设计模式，提供一个作用于某种对象结构上的各元素的操作方式，可以使我们在不改变元素结构的前提下，定义作用于元素的新操作。

如果系统的数据结构是比较稳定的，但其操作（算法）是易于变化的，那么使用访问者模式是个不错的选择；如果数据结构是易于变化的，则不适合使用访问者模式。

总结起来一句话，

访问者模式的目的是将数据结构和数据操作分离，提供优秀的扩展性。

通常情况下，访问者模式里有以下几个角色：

Vistor（抽象访问者）：为该对象结构中具体元素角色声明一个访问操作接口。
ConcreteVisitor（具体访问者）：每个具体访问者都实现了Vistor中定义的操作。
Element（抽象元素）：定义了一个accept操作，以Visitor作为参数。
ConcreteElement（具体元素）：实现了Element中的accept()方法，调用具体的Vistor的访问方法以便完成对一个元素的操作。
ObjectStructure（对象结构）：可以是组合模式，也可以是集合；能够枚举它包含的元素；提供一个接口，允许Vistor访问它的元素。

示例代码

废话说了不少了，再不上源码就是耍流氓了。先来张图把源码的结构展示下：

在这里插入图片描述

这是一个电商的场景，我们有个抽象物品类 ItemElement 接口，两个具体的实现分别是书 Book，和水果 Fruit。接口通过Accept开放一个给访问者的入口。

public interface ItemElement {
    int accept(ShoppingCartVisitor visitor);
}

@Data
@ToString
@AllArgsConstructor
class Book implements ItemElement {
    private int price;
    private String isbnNumber;

    @Override
    public int accept(ShoppingCartVisitor visitor) {
        return visitor.visit(this);
    }
}


@Data
@AllArgsConstructor
@ToString
class Fruit implements ItemElement
{
    private int pricePerKg;
    private int weight;
    private String name;


    @Override
    public int accept(ShoppingCartVisitor visitor)
    {
        return visitor.visit(this);
    }

}

接着定义一个 visitor 接口，里面有对具体的 element 的访问声明。而接口的实现类只要根据具体的Element实现类实现方法即可。

public interface ShoppingCartVisitor {
    int visit(Book book);
    int visit(Fruit fruit);
}

public class ShoppingCartVisitorImpl implements ShoppingCartVisitor {

    @Override
    public int visit(Book book) {
        int cost=0;
        if(book.getPrice() > 50) //折扣
        {
            cost = book.getPrice()-5;
        }
        else
            cost = book.getPrice();

        System.out.println("Book ISBN::"+book.getIsbnNumber() + " cost ="+cost);
        return cost;
    }

    @Override
    public int visit(Fruit fruit) {
        int cost = fruit.getPricePerKg()*fruit.getWeight();
        System.out.println(fruit.getName() + " cost = "+cost);
        return cost;
    }
}

然后是测试类，

public class ShoppingCartClient {
    public static void main(String[] args) {
        ItemElement[] items = new ItemElement[]{new Book(20, "1234"),
                new Book(100, "5678"), new Fruit(10, 2, "Banana"),
                new Fruit(5, 5, "Apple")};

        int total = calculatePrice(items);
        System.out.println("Total Cost = "+total);
    }

    private static int calculatePrice(ItemElement[] items)
    {
        ShoppingCartVisitor visitor = new ShoppingCartVisitorImpl();
        int sum=0;
        for(ItemElement item : items)
        {
            sum = sum + item.accept(visitor);
        }
        return sum;
    }
}

输出，

Book ISBN::1234 cost =20
Book ISBN::5678 cost =95
Banana cost = 20
Apple cost = 25
Total Cost = 160

代码很简单，根据这个示例代码我们可以总结下实现访问者模式的基本步骤：

声明一个visitor接口，里面定义一组方法，每个方法是针对具体的element操作的定义。
声明一个element接口，里面定义一个accept方法，作为访问者访问的入口。
element的访问操作都必须通过visitor接口来操作。
element不同的行为模型可以通过具体的visitor实现来操作。

使用访问者模式的一些源码分析

前段时间看ASM Java字节码增强技术，里面就用到了访问者模式。访问者模式主要用于修改或操作一些数据结构比较稳定的数据，我们知道字节码文件的结构是由JVM固定的，所以很适合利用访问者模式对字节码文件进行修改。

ASM中和访问者模式相关的有几个重要的类，

ClassReader

相当于访问者模式中的element，它将字节数组或者 class 文件读入到内存当中，并以树的数据结构表示，树中的一个节点代表着 class 文件中的某个区域。这个类定义了一个accept方法用来和visitor交互，

部分源码如下，

public class ClassReader {
    
    public void accept(ClassVisitor classVisitor, int flags) {
        this.accept(classVisitor, new Attribute[0], flags);
    }

    public void accept(ClassVisitor classVisitor, Attribute[] attrs, int flags) {
        int u = this.header;
        char[] c = new char[this.maxStringLength];
        Context context = new Context();
        context.attrs = attrs;
        context.flags = flags;
        context.buffer = c;
        int access = this.readUnsignedShort(u);
        String name = this.readClass(u + 2, c);
        String superClass = this.readClass(u + 4, c);
        String[] interfaces = new String[this.readUnsignedShort(u + 6)];
        u += 8;

        for(int i = 0; i < interfaces.length; ++i) {
            interfaces[i] = this.readClass(u, c);
            u += 2;
        }
        ...

ClassVisitor

相当于抽象访问者接口。ClassReader 对象创建之后，调用 ClassReader#accept() 方法，传入一个 ClassVisitor 对象。在 ClassReader 中遍历树结构的不同节点时会调用 ClassVisitor 对象中不同的 visit() 方法，从而实现对字节码的修改。

部分源码如下，

public abstract class ClassVisitor {
    
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        if (this.cv != null) {
            this.cv.visit(version, access, name, signature, superName, interfaces);
        }

    }

    public void visitSource(String source, String debug) {
        if (this.cv != null) {
            this.cv.visitSource(source, debug);
        }

    }

    public ModuleVisitor visitModule(String name, int access, String version) {
        if (this.api < 393216) {
            throw new RuntimeException();
        } else {
            return this.cv != null ? this.cv.visitModule(name, access, version) : null;
        }
    }
    ...

ClassWriter

ClassWriter 是 ClassVisitor 的实现类，它负责把每一个节点修改后的字节码输出为字节数组。

部分源码如下，

public class ClassWriter extends ClassVisitor {
    public final void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        this.version = version;
        this.access = access;
        this.name = this.newClass(name);
        this.thisName = name;
        if (signature != null) {
            this.signature = this.newUTF8(signature);
        }

        this.superName = superName == null ? 0 : this.newClass(superName);
        if (interfaces != null && interfaces.length > 0) {
            this.interfaceCount = interfaces.length;
            this.interfaces = new int[this.interfaceCount];

            for(int i = 0; i < this.interfaceCount; ++i) {
                this.interfaces[i] = this.newClass(interfaces[i]);
            }
        }

    }

    public final void visitSource(String file, String debug) {
        if (file != null) {
            this.sourceFile = this.newUTF8(file);
        }

        if (debug != null) {
            this.sourceDebug = (new ByteVector()).encodeUTF8(debug, 0, 2147483647);
        }

    }
    
    ...

ASM 大致的工作流程是：

ClassReader 读取字节码到内存中，生成用于表示该字节码的内部表示的树，ClassReader 对应于访问者模式中的元素
组装 ClassVisitor 责任链，这一系列 ClassVisitor 完成了对字节码一系列不同的字节码修改工作，对应于访问者模式中的访问者 Visitor
然后调用 ClassReader#accept() 方法，传入 ClassVisitor 对象，此 ClassVisitor 是责任链的头结点，经过责任链中每一个 ClassVisitor 的对已加载进内存的字节码的树结构上的每个节点的访问和修改
最后，在责任链的末端，调用 ClassWriter 这个 visitor 进行修改后的字节码的输出工作

参考:

关注公众号：思无邪了吗

个人博客：http://www.machengyu.net

csdn博客: https://blog.csdn.net/pony_ma...

思否: https://segmentfault.com/u/ma...

一文说透访问者模式

基本介绍

示例代码

使用访问者模式的一些源码分析

ClassReader

ClassVisitor

ClassWriter

犀牛饲养员

引用和评论

总结一些ES不常用的filter

数据结构之美-深入理解树形结构

创建型模式 Creation Pattern

什么是侵入式链表和非侵入式链表

什么是时间局部性和空间局部性

Builder 模式在 Go 语言中的应用

Golang 设计模式