深入浅出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. }    


可见摒弃了继承抽象类方式的回调方式更加简便灵活。不需要为了实现抽象方法而总是继承抽象类，而是只需要通过回调来增加一个方法即可，更加的直观简洁灵活。这算是回调的好处之一。 

下面再给出一个关于利用回调配合异步调用的很不错的例子 
回调接口： 

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. }    


由上面这个例子可见，回调可以作为异步调用的基础来实现异步调用。

posted @ 2014-07-10 09:16  gegewx  阅读(481)  评论(0)  编辑  收藏  举报