深入淺出Java回撥機制

碼字猴code_monkey發表於2014-08-18
Java
部落格分類：  Java技術
Java回撥非同步呼叫 
前幾天看了一下Spring的部分原始碼，發現回撥機制被大量使用，覺得有必要把Java回撥機制的理解歸納總結一下，以方便在研究類似於Spring原始碼這樣的程式碼時能更加得心應手。 

注：本文不想扯很多拗口的話來充場面，我的目的是希望以最簡明扼要的語言將Java回撥的大概機制說清楚。好了，言歸正傳。 

一句話，回撥是一種雙向呼叫模式，什麼意思呢，就是說，被呼叫方在被呼叫時也會呼叫對方，這就叫回撥。“If you call me, i will call back”。 
不理解？沒關係，先看看這個可以說比較經典的使用回撥的方式： 
  • class A實現介面InA ——背景1
  • class A中包含一個class B的引用b ——背景2
  • class B有一個引數為InA的方法test(InA a) ——背景3
  • A的物件a呼叫B的方法傳入自己，test(a) ——這一步相當於you call me
  • 然後b就可以在test方法中呼叫InA的方法 ——這一步相當於i call you back

是不是清晰一點了？下面再來看一個完全符合這個方式模板的例子 
（PS：這個例子來源於網路，由於這個例子表現的功能極度拉風，令我感覺想想出一個超越它的例子確實比較困難，所以直接搬過來） 
Java程式碼  收藏程式碼
  1. //相當於介面InA  
  2. public interface BoomWTC{  
  3.   //獲得拉登的決定  
  4.   public benLaDengDecide();  
  5.   
  6.   // 執行轟炸世貿  
  7.   public void boom();  
  8. }  
  9.   
  10. //相當於class A  
  11. public class At$911 implements BoomWTC{//相當於【背景1】  
  12.   private boolean decide;  
  13.   private TerroristAttack ta;//相當於【背景2】  
  14.   
  15.   public At$911(){  
  16.     Date now=new Date();  
  17.     SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm");  
  18.     this.dicede= myFmt.format(dt).equals("01/09/11 09:44");  
  19.     this.ta=new TerroristAttack();  
  20.   }  
  21.   
  22.   //獲得拉登的決定  
  23.   public boolean benLaDengDecide(){  
  24.     return decide;  
  25.   }  
  26.   
  27.   // 執行轟炸世貿  
  28.   public void boom(){  
  29.     ta.attack(new At$911);//class A呼叫class B的方法傳入自己的物件，相當於【you call me】  
  30.   }  
  31. }  
  32.   
  33. //相當於class B  
  34. public class TerroristAttack{  
  35.   public TerroristAttack(){  
  36.   }  
  37.   
  38.   public attack(BoomWTC bmw){——這相當於【背景3】  
  39.     if(bmw.benLaDengDecide()){//class B在方法中回撥class A的方法，相當於【i call you back】  
  40.      //let's go.........  
  41.     }  
  42.   }  
  43. }  

現在應該對回撥有一點概念了吧。 
可是問題來了，對於上面這個例子來說，看不出用回撥有什麼好處，直接在呼叫方法不就可以了，為什麼要使用回撥呢？ 
事實上，很多需要進行回撥的操作是比較費時的，被呼叫者進行費時操作，然後操作完之後將結果回撥給呼叫者。看這樣一個例子： 
Java程式碼  收藏程式碼
  1. //模擬Spring中HibernateTemplate回撥機制的程式碼  
  2.     interface CallBack{     
  3.         public void doCRUD();     
  4.     }    
  5.         
  6.     public class HibernateTemplate {     
  7.             
  8.         public void execute(CallBack action){    
  9.             getConnection();    
  10.             action.doCRUD();    
  11.             releaseConnection();    
  12.         }    
  13.          
  14.         public void add(){    
  15.              execute(new CallBack(){    
  16.                 public void doCRUD(){    
  17.                     System.out.println("執行add操作...");    
  18.                 }    
  19.              });    
  20.         }     
  21.         
  22.         public void getConnection(){    
  23.             System.out.println("獲得連線...");    
  24.         }    
  25.             
  26.         public void releaseConnection(){    
  27.             System.out.println("釋放連線...");    
  28.         }    
  29.             
  30.     }    

可能上面這個例子你不能一眼看出個所以然來，因為其實這裡A是作為一個內部匿名類存在的。好，不要急，讓我們把這個例子來重構一下： 
Java程式碼  收藏程式碼
  1. interface CallBack{   //相當於介面InA  
  2.     public void doCRUD();     
  3. }    
  4.   
  5. public class A implements CallBack{//【背景1】  
  6.     private B b;//【背景2】  
  7.     public void doCRUD(){    
  8.           System.out.println("執行add操作...");    
  9.      }    
  10.   
  11.      public void add(){    
  12.              b.execute(new A());//【you call me】    
  13.         }    
  14. }  
  15.   
  16. public class B{  
  17.      public void execute(CallBack action){  //【背景3】  
  18.             getConnection();    
  19.             action.doCRUD();  //【i call you back】  
  20.             releaseConnection();    
  21.         }    
  22.   
  23.       public void getConnection(){    
  24.             System.out.println("獲得連線...");    
  25.         }    
  26.             
  27.         public void releaseConnection(){    
  28.             System.out.println("釋放連線...");    
  29.         }    
  30. }  

好了，現在就明白多了吧，完全可以轉化為上面所說的回撥使用方式的模板。 
現在在來看看為什麼要使用回撥，取得連線getConnection();是費時操作，A希望由B來進行這個費時的操作，執行完了之後通知A即可（即所謂的i call you back）。這就是這裡使用回撥的原因。 

在網上看到了一個比喻，覺得很形象，這裡借用一下： 
你有一個複雜的問題解決不了，打電話給你的同學，你的同學說可以解決這個問題，但是需要一些時間，那麼你不可能一直拿著電話在那裡等，你會把你的電話號碼告訴他，讓他解決之後打電話通知你。回撥就是體現在你的同學又反過來撥打你的號碼。 
結合到前面所分析的，你打電話給你同學就是【you call me】，你同學解決完之後打電話給你就是【i call you back】。 

怎麼樣，現在理解了吧？  

---------------------------------以下為更新---------------------------------- 

看了有些朋友的回帖，我又思考了一下，感覺自己之前對回撥作用的理解的確存在偏差。 
下面把自己整理之後的想法共享一下，如果有錯誤希望指出！多謝！ 

先說上面這段程式碼，本來完全可以用模板模式來進行實現： 
Java程式碼  收藏程式碼
  1. public abstract class B{  
  2.      public void execute(){   
  3.             getConnection();    
  4.             doCRUD();    
  5.             releaseConnection();    
  6.         }    
  7.   
  8.       public abstract void doCRUD();  
  9.   
  10.       public void getConnection(){    
  11.             System.out.println("獲得連線...");    
  12.         }    
  13.             
  14.         public void releaseConnection(){    
  15.             System.out.println("釋放連線...");    
  16.         }    
  17. }  
  18.   
  19. public class A extends B{  
  20.     public void doCRUD(){    
  21.           System.out.println("執行add操作...");    
  22.      }    
  23.   
  24.      public void add(){    
  25.              doCRUD();  
  26.         }    
  27. }  
  28.   
  29. public class C extends B{  
  30.     public void doCRUD(){    
  31.           System.out.println("執行delete操作...");    
  32.      }    
  33.   
  34.      public void delete(){    
  35.              doCRUD();  
  36.         }    
  37. }  

如果改為回撥實現是這樣的： 
Java程式碼  收藏程式碼
  1. interface CallBack{     
  2.     public void doCRUD();     
  3. }    
  4.     
  5. public class HibernateTemplate {     
  6.     public void execute(CallBack action){    
  7.         getConnection();    
  8.         action.doCRUD();    
  9.         releaseConnection();    
  10.     }    
  11.      
  12.     public void add(){    
  13.          execute(new CallBack(){    
  14.             public void doCRUD(){    
  15.                 System.out.println("執行add操作...");    
  16.             }    
  17.          });    
  18.      }     
  19.   
  20.      public void delete(){    
  21.          execute(new CallBack(){    
  22.             public void doCRUD(){    
  23.                 System.out.println("執行delete操作...");    
  24.             }    
  25.          });    
  26.      }   
  27.     
  28.     public void getConnection(){    
  29.         System.out.println("獲得連線...");    
  30.     }    
  31.         
  32.     public void releaseConnection(){    
  33.         System.out.println("釋放連線...");    
  34.     }    
  35.         
  36. }    

可見摒棄了繼承抽象類方式的回撥方式更加簡便靈活。不需要為了實現抽象方法而總是繼承抽象類，而是隻需要通過回撥來增加一個方法即可，更加的直觀簡潔靈活。這算是回撥的好處之一。 

下面再給出一個關於利用回撥配合非同步呼叫的很不錯的例子，來源於http://kt8668.iteye.com/blog/205739 
回撥介面： 
Java程式碼  收藏程式碼
  1. public interface CallBack {    
  2.     /**  
  3.      * 執行回撥方法  
  4.      * @param objects   將處理後的結果作為引數返回給回撥方法  
  5.      */    
  6.     public void execute(Object... objects );    
  7. }    

訊息的傳送者： 
Java程式碼  收藏程式碼
  1. /** 
  2.  * 這個類相當於你自己 
  3.  */  
  4. public class Local implements CallBack,Runnable{    
  5.      
  6.     private Remote remote;    
  7.         
  8.     /**  
  9.      * 傳送出去的訊息  
  10.      */    
  11.     private String message;    
  12.         
  13.     public Local(Remote remote, String message) {    
  14.         super();    
  15.         this.remote = remote;    
  16.         this.message = message;    
  17.     }    
  18.     
  19.     /**  
  20.      * 傳送訊息  
  21.      */    
  22.     public void sendMessage()    
  23.     {    
  24.         /**當前執行緒的名稱**/    
  25.         System.out.println(Thread.currentThread().getName());    
  26.         /**建立一個新的執行緒傳送訊息**/    
  27.         Thread thread = new Thread(this);    
  28.         thread.start();    
  29.         /**當前執行緒繼續執行**/    
  30.         System.out.println("Message has been sent by Local~!");    
  31.     }    
  32.     
  33.     /**  
  34.      * 傳送訊息後的回撥函式  
  35.      */    
  36.     public void execute(Object... objects ) {    
  37.         /**列印返回的訊息**/    
  38.         System.out.println(objects[0]);    
  39.         /**列印傳送訊息的執行緒名稱**/    
  40.         System.out.println(Thread.currentThread().getName());    
  41.         /**中斷髮送訊息的執行緒**/    
  42.         Thread.interrupted();    
  43.     }    
  44.         
  45.     public static void main(String[] args)    
  46.     {    
  47.         Local local = new Local(new Remote(),"Hello");    
  48.             
  49.         local.sendMessage();    
  50.     }    
  51.     
  52.     public void run() {    
  53.         remote.executeMessage(message, this);  //這相當於給同學打電話，打完電話之後，這個執行緒就可以去做其他事情了，只不過等到你的同學打回電話給你的時候你要做出響應  
  54.             
  55.     }    
  56. }    

訊息的接收者： 
Java程式碼  收藏程式碼
  1. /** 
  2.  * 這個類相當於你的同學 
  3.  */  
  4. public class Remote {    
  5.     
  6.     /**  
  7.      * 處理訊息  
  8.      * @param msg   接收的訊息  
  9.      * @param callBack  回撥函式處理類  
  10.      */    
  11.     public void executeMessage(String msg,CallBack callBack)    
  12.     {    
  13.         /**模擬遠端類正在處理其他事情，可能需要花費許多時間**/    
  14.         for(int i=0;i<1000000000;i++)    
  15.         {    
  16.                 
  17.         }    
  18.         /**處理完其他事情，現在來處理訊息**/    
  19.         System.out.println(msg);    
  20.         System.out.println("I hava executed the message by Local");    
  21.         /**執行回撥**/    
  22.         callBack.execute(new String[]{"Nice to meet you~!"});  //這相當於同學執行完之後打電話給你  
  23.     }    
  24.         
  25. }    

由上面這個例子可見，回撥可以作為非同步呼叫的基礎來實現非同步呼叫。

相關文章