曾經自己偶爾聽說過回調機制，隱隱約約能夠懂一些意思，但是當讓自己寫一個簡單的示例程序時，自己就傻眼了。隨著工作經驗的增加，自己經常聽到這兒使用了回調，那兒使用了回調，自己是時候好好研究一下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/）。
