java回调机制

回调的基本概念

在java中，我们可以将回调简单理解为：类A中的a方法调用类B中的b方法，而类B的b方法有反过来调用类A中的回调方法（callBack()）。

image

回调还可以分为同步回调和异步回调

同步回调

先看下面例子：

代码清单1：ICallBack.java

/**
 * 回调接口
 * @author 叶汉伟
 * @version v1.0
 */
public interface ICallBack {
    public void callBack();
}

代码清单2：A.java

/**
 * 类A，继承并实现接口ICallBack
 * @author 叶汉伟
 * @version v1.0
 */
public class A implements ICallBack{
    public void afunc(B b){
        System.out.println("A调用B的函数...");
        b.bfunc(this);
    }
    
    @Override
    public void callBack(){
        System.out.println("执行A的回调函数");
    }
}

代码清单3：B.java

/**
 * 类B，调用类A的回调方法
 * @author 叶汉伟
 *@version v1.0
 */
public class B {
    public void bfunc(ICallBack _callBack){
        System.out.println("B调用A的“回调函数”");
        _callBack.callBack();
    }
}

代码清单4：Test.java

public class Test {
    public static void main(String[] args){
        A _a=new A();
        B _b=new B();
    
        _a.afunc(_b);
    }
}

运行结果：

A调用B的函数... </br>
B调用A的“回调函数”...</br>
执行A的回调函数...

回调结束！

根据以上例子分析，同步回调是执行A的afunc()函数，到调用B的bfunc()函数执行回调，直到回调结束后程序再返回afunc()函数继续执行。

image

可见同步回调是一种顺序的，阻塞的程序调用，若回调函数的处理需要的时间久一点，就会造成程序无法继续向下执行，降低应用的整体性能。

异步回调

保持ICallBack.java和Test.java不变，重构A.java和B.java，将同步回调改成异步回调。代码如下：

代码清单5：A.java

/**
 * 类A，继承并实现接口ICallBack
 * @author 叶汉伟
 * @version v2.0
 */
public class A implements ICallBack{
    public void afunc(B b){
        System.out.println("A调用B的函数...");
        
         new Thread(new Runnable() {  
    @Override  
    public void run() {  
        b.bfunc(A.this);   
    }  
    }).start();  
         
        System.out.println("afunc()函数执行完毕！");
    }
    
    @Override
    public void callBack(){
        System.out.println("执行A的回调函数...");
    }
}

代码清单6：B.java

/**
 * 类B，调用类A的回调方法
 * @author 叶汉伟
 *@version v2.0
 */
public class B {
    public void bfunc(A a){
        System.out.println("B调用A的“回调函数”...");
         try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {}

        a.callBack();
        System.out.println("回调结束！");
    }
}

运行结果：

A调用B的函数...

afunc()函数执行完毕！

B调用A的“回调函数”...

执行A的回调函数...

回调结束！

可见，异步回调中，程序不会等回调执行完后再继续执行剩余程序，而是另起线程，一边继续执行剩余程序，一边执行回调程序，等回调执行完后返回结果。