Java实现双分派

最近在看SparkSQL的实现，推荐一本书《SparkSQL 内核剖析》，讲的很好。
关于SparkSQL如何把一条String类型的SQL识别解析，在Spark 2.0版本，使用的是ANTLR4来进行语法和词法分析，构造出语法分析树，然后通过SparkSQL的astBuilder这个对象去访问这棵树，在访问的过程中讲语法分析树逐步转换为unresolved logical plan。在这个访问语法树的过程中，SparkSQL采用的是访问者模式。

在追踪源码的过程中，总是在各种visit(this)和accept(Visitor)方法中跳来跳去，由于之前并未了解过访问者设计模式，遂场面一度十分混乱。这也正是写这篇文章的缘由。（是不是感觉逻辑清晰，没错，再夸我我会骄傲的）

一、Java动态绑定与双分派

从一个看过访问者模式的学习者的角度，为了更好的理解访问者设计模式，最好先要了解双分派是什么。

参考一篇让我茅塞顿开的文章：https://www.cnblogs.com/liaokailin/p/3804437.html

1.1动态绑定

动态绑定是指程序执行期间（而不是在编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法 。

如下代码：

package com.dp.zhb;

public class DynamicBound {
    public static void main(String[] args) {
        Person person = new Man() ;
        person.say() ;
    }
}

class Person{
    public void say(){} ;
}

class Man extends Person{
    public void say(){
        System.out.println("Hey Man");
    }
}

运行结果：

调用的是Person对象中的say方法 但是实际执行的是Man中的方法，这就是动态绑定。

1.2静态绑定

静态绑定就是指在编译期就已经确定执行哪一个方法。方法的重载（方法名相同而参数不同）就是静态绑定的，重载时，执行哪一个方法在编译期就已经确定下来。

package com.dp.zhb;

public class StaticBound {
    public static void main(String[] args) {
        OutputName out = new OutputName() ;
        Person p = new Person() ;
        Person man = new Man() ;
        Person woman = new Woman() ;
        out.print(p) ;
        out.print(man) ;
        out.print(woman) ;
    }
}


class Person{
}

class Man extends Person{

}
class Woman extends Person{

}

class OutputName{
    void print(Person p){
        System.out.println("person");
    }
    void print(Man m){
        System.out.println("man");
    }
    void print(Woman w){
        System.out.println("woman");
    }
}

上面这个程序输出结果：

不管在运行的时候传入的实际类型是什么，它永远都只会执行 void print(Person p)这个方法，即 : 重载是静态绑定的。

如果希望使用重载的时候，程序能够根据传入参数的实际类型动态地调用相应的方法，只能通过instanceof操作符进行类型的判断，然后再进行调用。虽然可以解决问题，但是如果子类数目很多，那么就要写很过个if else来判断类型，显然不是这种解决方案不是很合适。上述代码如下：

package com.dp.zhb;

public class StaticBound {
    public static void main(String[] args) {
        OutputName out = new OutputName() ;
        Person p = new Person() ;
        Person man = new Man() ;
        Person woman = new Woman() ;
        out.print(p) ;
        out.print(man) ;
        out.print(woman) ;
    }
}


class Person{
}

class Man extends Person{

}
class Woman extends Person{

}

class OutputName{
    void print(Person p){
        if(p instanceof Man) print((Man)p);
        else if (p instanceof Woman) print((Woman)p);
        else  System.out.println("person");
    }
    void print(Man m){
        System.out.println("man");
    }
    void print(Woman w){
        System.out.println("woman");
    }
}

结果：

1.3 双分派

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

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

来看一个双分派的例子：

package com.dp.zhb;

class Father {
    public void accept(Execute exe){
        exe.method(this);
    }
}
class Son1 extends Father{
    @Override
    public void accept(Execute exe){
        exe.method(this);
    }
}
class Son2 extends Father{
    @Override
    public void accept(Execute exe){
        exe.method(this);
    }
}

class Execute {
    public void method(Father father){
        System.out.println("This is Father's method");
    }

    public void method(Son1 son){
        System.out.println("This is Son1's method");
    }

    public void method(Son2 son){
        System.out.println("This is Son2's method");
    }
}

public class Test {
    public static void main(String[] args){
        Father father = new Father();
        Father s1 = new Son1();
        Father s2 = new Son2();
        Execute exe = new Execute();
        father.accept(exe);
        s1.accept(exe);
        s2.accept(exe);
    }
}

运行结果：

通俗的解释一下，就是重载是静态绑定，重写是动态绑定，双分派把重写放在重载之前，以实现在运行时动态判断执行那个子类的方法。上面的例子中，首先依据重写（Java的多态）找到对应的accept方法，然后accept方法中调用method方法， 并把当前类的this传入method，传入this这步就属于是静态绑定，在编译器就确定好的。比如在Father类中：

class Father {
    public void accept(Execute exe){
        exe.method(this);
    }
}

method(this)就对应了Execute类中的

public void method(Father father){
        System.out.println("This is Father's method");
    }