Java回调机制分析

来源：互联网发布：如何兼职软件开发编辑：程序博客网时间：2024/05/02 01:47

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：这个例子来源于网络，由于这个例子表现的功能极度拉风，令我感觉想想出一个超越它的例子确实比较困难，所以直接搬过来）

//相当于接口InA
public interface BoomWTC {
   //获得拉登的决定Java实现Ping
      public boolean benLaDengDecide();

      // 执行轰炸世贸
      public void boom();
}

//相当于class A
public class At$911 implements BoomWTC{//相当于【背景1】
      private boolean decide;
      private TerroristAttack ta;//相当于【背景2】

      public At$911(){
        Date now=new Date();
        SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm");
        this.decide= myFmt1.format(now).equals("01/09/11 09:44");
        this.ta=new TerroristAttack();
      }

      //获得拉登的决定
      public boolean benLaDengDecide(){
       System.out.println("回调决定："+decide);
         return decide;
      }

      // 执行轰炸世贸
      public void boom(){
          System.out.println(" TerroristAttack的对象ta调用attack的方法传入自己At$911");
          ta.attack(new At$911());//class A调用class B的方法传入自己的对象，相当于【you call me】
      }

      public static void main(String[] args) {
          At$911 at$911=new At$911();
          at$911.boom();
      }
}

//相当于class B
   public TerroristAttack(){
   }

   public void attack(BoomWTC bmw){//——这相当于【背景3】
       System.out.println("TerroristAttack就可以在attack方法中调用benLaDengDecide的方法");
        if(bmw.benLaDengDecide()){//class B在方法中回调class A的方法，相当于【i call you back】
         //let's go.........
        }
      }

现在应该对回调有一点概念了吧。
可是问题来了，对于上面这个例子来说，看不出用回调有什么好处，直接在调用方法不就可以了，为什么要使用回调呢？
事实上，很多需要进行回调的操作是比较费时的，被调用者进行费时操作，然后操作完之后将结果回调给调用者。看这样一个例子：

//模拟Spring中HibernateTemplate回调机制的代码
    interface CallBack{
        public void doCRUD();
    }

    public class HibernateTemplate {

        public void execute(CallBack action){
            getConnection();
            action.doCRUD();
            releaseConnection();
        }

        public void add(){
             execute(new CallBack(){
                public void doCRUD(){
                    System.out.println("执行add操作...");
                }
             });
        }

        public void getConnection(){
            System.out.println("获得连接...");
        }

        public void releaseConnection(){
            System.out.println("释放连接...");
        }

    }
可能上面这个例子你不能一眼看出个所以然来，因为其实这里A是作为一个内部匿名类存在的。好，不要急，让我们把这个例子来重构一下：

interface CallBack{   //相当于接口InA
    public void doCRUD();
}

public class A implements CallBack{//【背景1】
    private B b;//【背景2】
    public void doCRUD(){
          System.out.println("执行add操作...");
     }

     public void add(){
             b.execute(new A());//【you call me】
        }
}

public class B{
     public void execute(CallBack action){ //【背景3】
            getConnection();
            action.doCRUD(); //【i call you back】
            releaseConnection();
        }

      public void getConnection(){
            System.out.println("获得连接...");
        }

        public void releaseConnection(){
            System.out.println("释放连接...");
        }

转 http://my.oschina.net/linuxred/blog/28589