曾经自己偶尔听说过回调机制，隐隐约约能够懂一些意思，但是当让自己写一个简单的示例程序时，自己就傻眼了。随着工作经验的增加，自己经常听到这儿使用了回调，那儿使用了回调，自己是时候好好研究一下Java回调机制了。网上关于Java回调的文章一抓一大把，但是看完总是云里雾里，不知所云，特别是看到抓取别人的代码走两步时，总是现眼。于是自己决定写一篇关于Java机制的文章，以方便大家和自己更深入的学习Java回调机制。
首先，什么是回调函数，引用百度百科的解释：回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应[2].
不好意思，上述解释我看了好几遍，也没理解其中深刻奥秘，相信一些读者你也一样。光说不练假把式，咱们还是以实战理解脉络。
1.实战
本文以底层服务BottomService和上层服务UpperService为示例，利用上层服务调用底层服务，整体执行过程如下：
第一步: 执行UpperService.callBottomService();
第二步: 执行BottomService.bottom();
第三步:执行UpperService.upperTaskAfterCallBottomService()
1.1 同步调用代码
同步调用时序图：
1.1.1 底层服务类:BottomService.java
package synchronization.demo;
/**
* Created by lance on 2017/1/19.
*/
public class BottomService {
public String bottom(String param) {
try { // 模拟底层处理耗时，上层服务需要等待
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return param +" BottomService.bottom() execute -->";
}
}
1.1.2 上层服务接口: UpperService.java
package synchronization.demo;
/**
* Created by lance on 2017/1/19.
*/
public interface UpperService {
public void upperTaskAfterCallBottomService(String upperParam);
public String callBottomService(final String param);
}
1.1.3 上层服务接口实现类:UpperServiceImpl.java
package synchronization.demo;
/**
* Created by lance on 2017/1/19.
*/
public class UpperServiceImpl implements UpperService {
private BottomService bottomService;
@Override
public void upperTaskAfterCallBottomService(String upperParam) {
System.out.println(upperParam + " upperTaskAfterCallBottomService() execute.");
}
public UpperServiceImpl(BottomService bottomService) {
this.bottomService = bottomService;
}
@Override
public String callBottomService(final String param) {
return bottomService.bottom(param + " callBottomService.bottom() execute --> ");
}
}
1.1.4 Test测试类:Test.java
package synchronization.demo;
import java.util.Date;
/**
* Created by lance on 2017/1/19.
*/
public class Test {
public static void main(String[] args) {
BottomService bottomService = new BottomService();
UpperService upperService = new UpperServiceImpl(bottomService);
System.out.println("=============== callBottomService start ==================:" + new Date());
String result = upperService.callBottomService("callBottomService start --> ");
//upperTaskAfterCallBottomService执行必须等待callBottomService()调用BottomService.bottom()方法返回后才能够执行
upperService.upperTaskAfterCallBottomService(result);
System.out.println("=============== callBottomService end ====================:" + new Date());
}
}
1.1.5 输出结果:
=============== callBottomService start ==================:Thu Jan 19 14:59:58 CST 2017
callBottomService start --> callBottomService.bottom() execute --> BottomService.bottom() execute --> upperTaskAfterCallBottomService() execute.
=============== callBottomService end ====================:Thu Jan 19 15:00:01 CST 2017
注意输出结果：
是同步方式，Test调用callBottomService()等待执行结束，然后再执行下一步，即执行结束。callBottomService开始执行时间为Thu Jan 19 14:59:58 CST 2017，执行结束时间为Thu Jan 19 15:00:01 CST 2017，耗时3秒钟，与模拟的耗时时间一致，即3000毫秒。
1.2 Java回调实战
同步调用很明显的缺点是UpperService必须等待BottomService的返回结果之后，才能够继续向下执行upperTaskAfterCallBottomService()，造成了UpperService必须等待。然而回调则不需要等待，回调只需要将UpperService自身实例的引用或指针传给BottomService，BottomService执行完bottom()后，通过UpperService实例的引用或指针调用upperTaskAfterCallBottomService()，达到了与同步调用同样的效果且UpperService的调用者Test不需要等待。
回调的执行时序图如下：
具体实现代码如下：
1.2.1 底层服务类：BottomService.java
package callback.demo;
/**
* Created by lance on 2017/1/19.
*/
public class BottomService {
public void bottom(UpperService upperService, String param) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
upperService.upperTaskAfterCallBottomService( param +" bottom callback upperTaskAfterCallBottomService() execute -->");
}
}
1.2.2 上层服务接口: UpperService.java
package callback.demo;
/**
* Created by lance on 2017/1/19.
*/
public interface UpperService {
public void upperTaskAfterCallBottomService(String upperParam);
public void callBottomService(final String param);
}
1.2.3 上层服务接口实现类: UpperServiceImpl.java
package callback.demo;
/**
* Created by lance on 2017/1/19.
*/
public class UpperServiceImpl implements UpperService {
private BottomService bottomService;
@Override
public void upperTaskAfterCallBottomService(String upperParam) {
System.out.println( upperParam + " upperTaskAfterCallBottomService() execute.");
}
public UpperServiceImpl(BottomService bottomService) {
this.bottomService = bottomService;
}
@Override
public void callBottomService(final String param) {
new Thread(new Runnable() {
public void run() {
bottomService.bottom(UpperServiceImpl.this, param + " callBottomService.bottom() execute --> ");
}
}).start();
}
}
1.2.4 Test测试类:Test.java
package callback.demo;
import java.util.Date;
/**
* Created by lance on 2017/1/19.
*/
public class Test {
public static void main(String[] args) {
BottomService bottomService = new BottomService();
UpperService upperService = new UpperServiceImpl(bottomService);
System.out.println("=============== callBottomService start ==================:" + new Date());;
upperService.callBottomService("callBottomService start --> ");
System.out.println("=============== callBottomService end ====================:" + new Date());
}
}
1.2.5 输出结果:
=============== callBottomService start ==================:Thu Jan 19 16:00:45 CST 2017
=============== callBottomService end ====================:Thu Jan 19 16:00:45 CST 2017
callBottomService start --> callBottomService.bottom() execute --> bottom callback upperTaskAfterCallBottomService() execute --> upperTaskAfterCallBottomService() execute.
注意输出结果：
Test不需要等待callBottomService()执行结束后才进行下一步执行，Test继续往下执行结束，不需要等待callBottomService()执行完毕。 故callBottomService的从开始到执行结束的时间都是Thu Jan 19 16:00:45 CST 2017，执行耗时时间为0秒，而执行效果达到和同步执行一致。
反观1.1同步方式的执行耗时情况，callBottomService开始执行时间为Thu Jan 19 14:59:58 CST 2017，执行结束时间为Thu Jan 19 15:00:01 CST 2017，耗时3秒钟，与模拟的耗时时间一致，即3000毫秒。
参考资料：
1.一个经典例子让你彻彻底底理解java回调机制（http://blog.csdn.net/xiaanming/article/details/8703708/）。
