回调java 简书_Java回调机制详解

曾经自己偶尔听说过回调机制，隐隐约约能够懂一些意思，但是当让自己写一个简单的示例程序时，自己就傻眼了。随着工作经验的增加，自己经常听到这儿使用了回调，那儿使用了回调，自己是时候好好研究一下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毫秒。

参考资料：