回调函数机制

来源：互联网发布：淘宝联盟佣金怎么提现编辑：程序博客网时间：2024/06/09 06:47

1. 什么是回调函数
回调函数（callback Function），顾名思义，用于回调的函数。回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。回调函数是一个工作流的一部分，由工作流来决定函数的调用（回调）时机。回调函数包含下面几个特性：
1、属于工作流的一个部分；
2、必须按照工作流指定的调用约定来申明（定义）；
3、他的调用时机由工作流决定，回调函数的实现者不能直接调用回调函数来实现工作流的功能；

2. 回调机制
回调机制是一种常见的设计模型，他把工作流内的某个功能，按照约定的接口暴露给外部使用者，为外部使用者提供数据，或要求外部使用者提供数据。

=======================================================

java回调机制：

软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。

同步调用：一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；

回调：一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；

异步调用：一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。

回调和异步调用的关系非常紧密：使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。

下面使用java回调函数来实现一个测试函数运行时间的工具类：

如果我们要测试一个类的方法的执行时间，通常我们会这样做：
java 代码
public   class TestObject {
    /**
     * 一个用来被测试的方法，进行了一个比较耗时的循环
     */
    public   static   void testMethod(){
        for ( int i= 0 ; i< 100000000 ; i++){

        }
    }
    /**
     * 一个简单的测试方法执行时间的方法
     */
    public   void testTime(){
        long begin = System.currentTimeMillis(); //测试起始时间
        testMethod(); //测试方法
        long end = System.currentTimeMillis(); //测试结束时间
        System.out.println("[use time]:" + (end - begin)); //打印使用时间
    }

    public   static   void main(String[] args) {
        TestObject test=new TestObject();
        test.testTime();
    }
}

大家看到了testTime()方法，就只有"//测试方法"是需要改变的，下面我们来做一个函数实现相同功能但更灵活：
首先定一个回调接口：
java 代码
public   interface CallBack {
    //执行回调操作的方法
    void execute();
}

然后再写一个工具类：
java 代码
public   class Tools {

    /**
     * 测试函数使用时间，通过定义CallBack接口的execute方法
     * @param callBack
     */
    public   void testTime(CallBack callBack) {
        long begin = System.currentTimeMillis(); //测试起始时间
        callBack.execute(); ///进行回调操作
        long end = System.currentTimeMillis(); //测试结束时间
        System.out.println("[use time]:" + (end - begin)); //打印使用时间
    }

    public   static   void main(String[] args) {
        Tools tool = new Tools();
        tool.testTime(new CallBack(){
            //定义execute方法
            public   void execute(){
                //这里可以加放一个或多个要测试运行时间的方法
                TestObject.testMethod();
            }
        });
    }
}

大家看到，testTime()传入定义callback接口的execute()方法就可以实现回调功能

==============================================================

如果说匿名内部类的方式不容易理解，可以看下面的例子

其技巧就是：定义一个简单接口，并在该接口中声明我们要调用的方法。

下面举一个例子：

假定我们希望在某个事件发生时得到通知。我们可以定义一个接口：

/*
* 在某个事件发生时得到通知．
*/
public interface InterestingEvent {
　　 public void interestingEvent();
}

此接口中的方法，是个没有返回值的也没有任何参数，如果您愿意也可以有返回值，也可以带参数．这就要看具体需求而定．

这使得我们可以控制实现该接口的类的任何对象。因此，我们不必关心任何外部类型信息。与在将 C++ 代码用于Motif 时使用窗口小部件的数据域来容纳对象指针的难以控制的 C 函数相比，这种方法要好得多。

实现接口的代码如下：

public class CallMe implements InterestingEvent {
public CallMe() {
　　 }

　　 public void interestingEvent() {
　　 System.out.println("发生了打印事件，哈哈");
　　}

}

public class CallYou implements InterestingEvent {
public CallYou() {
　 }

public void interestingEvent() {

System.out.println("发生了查询事件，哈哈");
}

}

发出事件信号的类必须等待实现了 InterestingEvent 接口的对象，并在适当时候调用 interestingEvent() 方法。

public class EventNotifier {
private InterestingEvent ie;
private boolean somethingHappened ;
public EventNotifier() {
   somethingHappened = true ;
}
public void setInterestingEvent(InterestingEvent ie){
   this.ie = ie ;
}
public void doWork(){
   if(somethingHappened){
    ie.interestingEvent();
   }
}

}

下面做一下测试．

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
   CallMe cm = new CallMe();
   CallYou cy = new CallYou();
   EventNotifier en = new EventNotifier();

   en.setInterestingEvent(cm);
   en.doWork();
   en.setInterestingEvent(cy);
   en.doWork();
}

}

此测试在发生指定的调用CalMe事件时，就扫行CallMe下的命令，如发生CallYou事件时，就调用CallYou下的命令．此种方法可以结合Command模式．实现MS-Windows 和 X Window System 事件驱动编程模型．

回调方法另一测试用例：

熟悉MS－Windows和X Windows事件驱动设计模式的开发人员，通常是把一个方法的指针传递给事件源，当某一事件发生时来调用这个方法（也称为“回调”）。Java的面向对象的模型目前不支持方法指针，似乎不能使用这种方便的机制。

Java支持interface，通过interface可以实现相同的回调。其诀窍就在于定义一个简单的interface，申明一个被希望回调的方法。

例如，假定当某一事件发生时会得到通知，我们可以定义一个interface：
public interface InterestingEvent {
    // 这只是一个普通的方法，可以接收参数、也可以返回值
    public void interestingEvent();
}

这样我们就有了任何一个实现了这个接口类对象的手柄grip。

当一事件发生时，需要通知实现InterestingEvent 接口的对象，并调用interestingEvent() 方法。
class EventNotifier {
    private InterestingEvent ie;
    private boolean somethingHappened;

    public EventNotifier(InterestingEvent event) {
        ie = event;
        somethingHappened = false;
    }

    public void doWork() {
        if (somethingHappened) {
            // 事件发生时，通过调用接口的这个方法来通知
            ie.interestingEvent();
        }
    }
}

在这个例子中，用somethingHappened 来标志事件是否发生。

希望接收事件通知的类必须要实现InterestingEvent 接口，而且要把自己的引用传递给事件的通知者。
public class CallMe implements InterestingEvent {
    private EventNotifier en;

    public CallMe() {
        // 新建一个事件通知者对象，并把自己传递给它
        en = new EventNotifier(this);
    }

    // 实现事件发生时，实际处理事件的方法
    public void interestingEvent() {
        // 这个事件发生了，进行处理
    }
}

以上是通过一个非常简单的例子来说明Java中的回调的实现。

当然，也可以在事件管理或事件通知者类中，通过注册的方式来注册多个对此事件感兴趣的对象。

1. 定义一个接口InterestingEvent ，回调方法nterestingEvent(String event) 简单接收一个String 参数。

interface InterestingEvent {
public void interestingEvent(String event);
}

2. 实现InterestingEvent接口，事件处理类

class CallMe implements InterestingEvent {
    private String name;
    public CallMe(String name){
        this.name = name;
    }
    public void interestingEvent(String event) {
        System.out.println(name + ":[" +event + "] happened");
    }
}

3. 事件管理者，或事件通知者

class EventNotifier {
    private List<CallMe> callMes = new ArrayList<CallMe>();

    public void regist(CallMe callMe){
        callMes.add(callMe);
    }

    public void doWork(){
        for(CallMe callMe: callMes) {
            callMe.interestingEvent("sample event");
        }
    }
}

4. 测试

public class CallMeTest {
    public static void main(String[] args) {
        EventNotifier ren = new EventNotifier();
        CallMe a = new CallMe("CallMe A");
        CallMe b = new CallMe("CallMe B");

        // regiest
        ren.regist(a);
        ren.regist(b);

        // test
        ren.doWork();
    }
}

0 0