回调函数

引言：在学习Springboot启动原理的时候，总是听到一个'回调'这样一个词，在前端中经常听到，但是在后端听到，还是有一种模棱两可的感觉，于是乎...

eg1: 

场景：老师问学生问题，学生思考完毕回答老师?
流程：
（1）老师调用学生接口的方法resolveQuestion，向学生提问；
（2）学生解决完毕问题之后调用老师的回调方法tellAnswer；
这样一套流程，构成了一种双向调用的关系。

分析：回调的做法是，调用方在调用时，将自己(this)传递给被调用方，这样，当被调用方完成一定的逻辑后，可以通过传递过来的this，回调调用方的方法。

package myCallback;

/**
 * 场景：老师问学生问题，学生思考完毕回答老师。
 * 程序设计思路：
 * （1）老师调用学生接口的方法resolveQuestion，向学生提问；
 * （2）学生解决完毕问题之后调用老师的回调方法tellAnswer；
 * 这样一套流程，构成了一种双向调用的关系。
 * <p>
 * 解释：
 * 回调的做法是，调用方在调用时，将自己(this)传递给被调用方，这样，当被调用方完成一定的逻辑后，可以通过传递过来的this，回调调用方的方法。
 *
 * <p>
 * 参考：https://www.cnblogs.com/aademeng/articles/11070081.html
 *
 * @author zls
 * @date 2020/2/5
 */
public class CallbackDemo2 {
    public static void main(String[] args) {
        Student student = new Ricky();
        Teacher teacher = new Teacher(student);
        teacher.askQuestion();
    }
}

/**
 * 回调接口：同步回调
 */
interface Callback {
    // 回答问题
    public void tellAnswer(String answer);
}

// 老师
class Teacher implements Callback {
    private Student student;

    public Teacher(Student student) {
        this.student = student;
    }

    // 提出问题
    public void askQuestion() {
        System.out.println("老师提出问题：谁最漂亮？");
        //调用方在调用时，将自己传递给被调用方
        student.resolveQuestion(this);
    }

    // 听到同学回答的答案
    @Override
    public void tellAnswer(String answer) {
        System.out.println("同学" + ((Ricky) student).getName() + "的回答的是：" + answer + "最漂亮！");
    }

}

/**
 * 学生接口
 */
interface Student {
    // 解决问题
    public void resolveQuestion(Callback callback);
}

// 学生Ricky
class Ricky implements Student {
    private String name = "佳宁";

    @Override
    public void resolveQuestion(Callback callback) {
        // 模拟解决问题
        try {
            Thread.sleep(2000);
            System.out.println("回答到：鞠婧祎最漂亮");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

        // 回调: 被调用方回调调用方的方法
        callback.tellAnswer("鞠婧祎");
    }

    public String getName() {
        return this.name;
    }
}

eg2:

package myCallback;

import javax.lang.model.SourceVersion;

/**
 * 回调函数实际上就是在调用某个函数（通常是API函数）时，将自己的一个函数（这个函数为回调函数）的地址作为参数传递给那个函数。
 * 而那个函数在需要的时候，利用传递的地址调用回调函数，这时你可以利用这个机会在回调函数中处理消息或完成一定的操作。
 * 简而言之：所谓回调函数，就是你定义的，但是你没有调用，它却执行了。
 * <p>
 * 程序设计思路：
 * 定义三个类，分别是主函数类，callback函数的接口类，业务处理类，在业务处理类中，处理完业务之后，执行一个callback函数。
 * <p>
 * 参考：https://blog.csdn.net/buctoj/article/details/95516802
 *
 * @author zls
 * @date 2020/2/5
 */
public class CallBackDemo {
    public static void main(String[] args) {
        // 这是主函数类。new了一个业务处理类来处理逻辑，并在处理完毕之后，执行callback函数。
        // 形式一：
//        new TestCallBack().compute(10, new ComputeCallBack() {
//            @Override
//            public void onComputeEnd() {
//                System.out.println("end back!!!");
//            }
//        });
        
        // 形式二：
        ComputeCallBack computeCallBack = new ComputeCallBack() {
            @Override
            public void onComputeEnd() {
                System.out.println("end back!!!");
            }
        };
        new TestCallBack().compute(10, computeCallBack);

        // 形式三：可能上面那种方法不是那么直观，这里我特意的把回调接口的需要被回调的方法给单独拆开了
        // 在这里我们并没有调用onComputeEnd，但是该方法最终是执行了的
        TestCallBack testCallBack = new TestCallBack();
        testCallBack.compute(10, new CallBackImp());
    }
}

/**
 * 这是业务处理类。
 */
class TestCallBack {
    // 业务方法 仅仅输出一些数字，然后执行回调函数。
    public void compute(int n, ComputeCallBack callback) {
        for (int i = 0; i < n; i++) {
            System.out.println(i);
        }
        // 回调
        callback.onComputeEnd();
    }
}

/**
 * 这是回调函数的接口
 */
interface ComputeCallBack {
    public void onComputeEnd();
}

/**
 * 被回调的方法
 */
class CallBackImp implements ComputeCallBack{
    @Override
    public void onComputeEnd() {
        System.out.println("被回调的方法...");
    }
}

参考：

https://www.cnblogs.com/aademeng/articles/11070081.html

 JAVA之回调函数(callback)