Java回调(callback)机制

一、简述

从软件模块之间的调用方式看，分为三类：同步调用、异步调用和回调。

1️⃣同步调用

同步调用是最基本并且最简单的一种调用方式，类 A 的 a() 调用类 B 的 b()，一直等待 b() 执行完毕，a() 继续往下走。该调用方式适用于 b() 执行时间不长的情况，因为 b() 执行时间过长或者直接阻塞的话，a() 的余下代码是无法执行下去的，这样会造成整个流程的阻塞。

2️⃣异步调用

异步调用是为了解决同步调用可能出现阻塞，导致整个流程卡住而产生的一种调用方式。类 A 的 a() 通过新起线程的方式调用类 B 的 b()，代码接着直接往下执行，这样无论 b() 执行时间多久，都不会阻塞住 a() 的执行。但是，由于 a() 不等待 b() 的执行完成，在 a() 需要 b() 执行结果的情况下(视具体业务而定，有些业务比如启异步线程发个微信通知、刷新缓存这种就没必要)，必须通过一定的方式对 b() 的执行结果进行监听。Java 中，可以使用 Future+Callable 的方式做到这一点。

3️⃣回调

核心：回调一方将本身即 this 传递给调用一方，这样调用一方就可以在执行完毕之后告诉回调一方想要知道的信息。

在面向对象的语言中，回调则是通过接口或抽象类来实现的。实现这种接口的类为回调类，回调类的对象为回调对象。如下 A 为回调方，B 为调用方。回调的思想是：

1. 回调方 A 实现接口 CallBack——背景 1
2. 回调方 A 中包含一个调用法 B 的引用 b——背景 2
3. 调用方 B 有一个参数为 callback 的方法 b(CallBack callback)——背景 3
4. A 的对象 a 在自己的 a() 里调用 B 的方法 b(CallBack callback)——A 类调用 B 类的某个方法
5. 然后 b 就可以在 b(CallBack callback) 中调用 A 的方法——B 类调用 A 类的某个方法

综上：

• 回调方类 A 的 a() 调用调用方类 B 的 b()。
• 调用方类 B 的 b() 执行完毕主动调用回调方类 A 的 callback()。

该调用方式如图，也就是一种双向的调用方式。回调函数是一个函数或过程，不过它是一个由调用方自己实现，供被调用方使用的特殊函数。

二、理解

1️⃣老师在黑板上写一个式子 “8+8=”，由小黑来填空。小黑自己完成计算，模拟代码如下：

public class Student {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    private int calcAdd(int a, int b) {
        return a + b;
    }
    public void fillBlank(int a, int b) {
        int result = calcAdd(a, b);
        System.out.println(name + "心算:" + a + "+" + b + "=" + result);
    }
}

小黑在填空(fillBlank)的时候，直接心算(clacAdd)了一下，得出结果是 2，并将结果写在空格里。测试如下:

public static void main(String[] args) {
    int a = 1;
    int b = 1;
    Student stu = new Student("小黑");
    stu.fillBlank(a, b);
}

该过程完全由 Student 类的实例对象单独完成，并未涉及回调机制。

2️⃣老师又在黑板上写了 “222+666=”，让小黑完成，然后回办公室去了。小黑懵逼的时候，小白同学递过来一个只能计算加法的计算机，小黑通过计算器计算得到结果并完成了填空。
计算器的代码为：

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

修改 Student 类，添加使用计算器的方法：

public class Student {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    private int useCalculator(int a, int b) {
        return new Calculator().add(a, b);
    }
    public void fillBlank(int a, int b) {
        int result = useCalculator(a, b);
        System.out.println(name + "使用计算器:" + a + "+" + b + "=" + result);
    }
}

测试如下：

public static void main(String[] args) {
    int a = 222;
    int b = 666;
    Student stu = new Student("小黑");
    stu.fillBlank(a, b);
}

该过程中仍未涉及到回调机制，但是小黑的部分工作已经实现了转移，由计算器来协助实现。

3️⃣老师又在黑板上写下了“1357+2468=”，让小黑上课之前完成填空，然后又回办公室了。小黑看着计算机，心里想着让小白代劳。小黑告诉小白题目，指出填写结果的具体位置，然后快乐的玩耍去了。
这里，将计算器和小白抽象成一个会算结果还会填空的超级计算器。该超级计算器需要传的参数是两个加数和要填空的位置，而这些内容需要小黑提前告知，也就是要把自己的一部分方法暴露出来，最简单的方法就是把自己的引用和两个加数一块告诉该超级计算器。
因此，超级计算器的 add 方法应该包含两个操作数和小黑自身的引用，代码如下：

public class SuperCalculator {
    public void add(int a, int b, Student stu) {
        int result = a + b;
        stu.fillBlank(a, b, result);
    }
}

小黑目前只需要一个方法“可以向超级计算器寻求帮助”就行了，代码如下：

public class Student {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    public void callHelp(int a, int b) {
        new SuperCalculator().add(a, b, this);
    }
    public void fillBlank(int a, int b, int result) {
        System.out.println(name + "求助计算:" + a + "+" + b + "=" + result);
    }
}

测试如下：

public static void main(String[] args) {
    int a = 1357;
    int b = 2468;
    Student stu = new Student("小黑");
    stu.callHelp(a, b);
}

执行流程：
小黑通过自身的 callHelp() 调用了 new SuperCalculator() 的 add()，在调用的时候将自身的引用 this 当作参数一并传入，超级计算器在得出结果之后，回调了小黑的 fillBlank()，将结果填在了黑板的空格上。如此就体现了回调。此时，小黑的 fillBlank() 就是常说的回调函数。

通过这种方式，可以明显的看出，对于完成老师的填空题这个问题上，小黑已经不需要等待到加法做完且结果填写在黑板上才能去跟小伙伴撒欢了，填空这个工作由超级计算器小白来做了。回调的优势已经开始体现了。

4️⃣门卫大爷听到了小黑跟小伙伴们吹嘘自己如何在小白的帮助下答题。于是，决定找到超计来做自己的小帮手。

上述代码，超计的 add() 需要的参数是两个整型变量和一个 Student 对象，但是门卫不是学生，这里需要修改。如此，想到继承和多态。如果让小黑和门卫从一个父类进行继承，那么只需要给超计传入一个父类的引用就可以啦。

不过，Java 的单继承，以及不希望暴露太多，这里使用从接口继承的方式配合内部类来做。

换句话说，小白希望以后继续向班里的同学提供计算服务，同时还能向门卫提供算账服务，甚至以后能够拓展其他人的业务，于是向所有的顾客约定了一个办法，用于统一的处理，也就是自己需要的操作数和做完计算之后应该怎么做。这个统一的方法，小白做成了一个接口回调接口，提供给了大家，代码如下：

public interface DoJob {
    void fillBlank(int a, int b, int result);
}

同时，小白修改了自己的计算器调用方，使其可以同时处理不同的实现了 DoJob 接口人的业务，代码如下：

public class SuperCalculator {
    public void add(int a, int b, DoJob customer) {
        int result = a + b;
        customer.fillBlank(a, b, result);
    }
}

小黑和门卫拿到这个接口之后，只要实现了这个接口回调方，就相当于按照统一的模式告诉小白得到结果之后的处理办法，按照之前说的使用内部类来做，代码如下：
小黑：

public class Student {
    private String name = null;
    public Student(String name) {
        this.name = name;
    }
    public class doHomeWork implements DoJob {
        @Override
        public void fillBlank(int a, int b, int result) {
            System.out.println(name + "求助计算:" + a + "+" + b + "=" + result);
        }
    }
    public void callHelp(int a, int b) {
        new SuperCalculator().add(a, b, new doHomeWork());
    }
}

门卫：

public class Guard {
    private String name;
    public Guard(String name) {
        this.name = name;
    }
    public class doHomeWork implements DoJob {
        @Override
        public void fillBlank(int a, int b, int result) {
            System.out.println(name + "求助算账:" + a + "+" + b + "=" + result + "元");
        }
    }
    public void callHelp(int a, int b) {
        new SuperCalculator().add(a, b, new doHomeWork());
    }
}

测试如下：

public static void main(String[] args) {
    int a = 66;
    int b = 88;
    int c = 1357;
    int d = 2468;
    Student stu = new Student("小黑");
    Guard guard = new Guard("门卫");
    stu.callHelp(a, b);
    guard.callHelp(c, d);
}