Java 消息机制之回调详解

以下内容转自：http://blog.csdn.net/lemon_tree12138/article/details/51231841

Java 消息机制之回调详解

版权声明：本文为博主原创文章，未经博主允许不得转载。

 

目录(?)[+]

 

1. 概述

Java 中的回调机制是一个比较常见的机制，只是有可能在你的程序中使用得比较少，在一些大型的框架中回调机制随处可见。而在之前的博文《Java设计模式——观察者模式》及 Android 中对 ListView 的相关操作也有回调身影。本文就通过一些具体的实例，慢慢走近 Java 的回调机制。

2. 版权说明

著作权归作者所有。 
商业转载请联系作者获得授权，非商业转载请注明出处。 
本文作者：Q-WHai 
发表日期： 2016年4月24日 
本文链接：http://blog.csdn.net/lemon_tree12138/article/details/51231841 
来源：CSDN 
更多内容：分类 >> Thinking in java 

3. 目录

 

 

4. 回调

所谓回调：就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法。实际在使用的时候，也会有不同的回调形式，比如下面的这几种。

4.1 同步回调

这里我假设这样的一种情况。 
A 公司的总监 B 跟他的下属（项目经理 C）说要做一个调研，不过不用 C 自己亲力亲为。可以让经理 C 去安排他下面的程序员 D 去完成。 
经理 C 找到了程序员 D，并告诉他，现在要完成一个调研任务。并且把调研的结果告诉经理 C。如果有问题，还是要继续的。 
因为这里是 C 让 D 去做一件事情，之后 D 还是要将结果与 C 进行沟通。这样就是回调的模型了。下面是一般回调的类图： 
这里写图片描述

首先我们要有一个回调的接口 CallbackInterface 
CallbackInterface.java

public interface CallbackInterface {
    public boolean check(int result);
}

背景里，程序员 D 是要将结果与项目经理 C 进行沟通的，所以这里项目经理需要实现上面的回调接口： 

Manager.java

public class Manager implements CallbackInterface {

    private Programmer programmer = null;

    public Manager(Programmer _programmer) {
        this.programmer = _programmer;
    }

    /**
     * 用于 Boss 下达的委托
     */
    public void entrust() {
        arrange();
    }

    // 进行安排下属进行 study 工作
    private void arrange() {
        System.out.println("Manager 正在为 Programmer 安排工作");
        programmer.study(Manager.this);
        System.out.println("为 Programmer 安排工作已经完成，Manager 做其他的事情去了。");
    }

    @Override
    public boolean check(int result) {
        if (result == 5) {
            return true;
        }
        return false;
    }

}

 

对于程序员 D 来说他需要持有一个经理 C 的引用，以便与他沟通。不过，这里是总监 B 让 经理 C 去安排的任务。也就是说这里也可以让其他的经理，比如说经理 B1， B2等等。因为经理都实现了回调的接口，所以这里就可以直接让程序员 D 持有这个接口就可以了。如下： 

Programmer.java

public class Programmer {

    public void study(CallbackInterface callback) {
        int result = 0;
        do {
            result++;
            System.out.println("第 " + result + " 次研究的结果");
        } while (!callback.check(result));

        System.out.println("调研任务结束");
    }
}

 

对于总监来说就更简单明了了，因为这相当于一个 Client 测试： 
Boss.java

public class Boss {

    public static void main(String[] args) {
        Manager manager = new Manager(new Programmer());
        manager.entrust();
    }
}

 

运行结果

Manager 正在为 Programmer 安排工作
第 1 次研究的结果
第 2 次研究的结果
第 3 次研究的结果
第 4 次研究的结果
第 5 次研究的结果
调研任务结束
为 Programmer 安排工作已经完成，Manager 做其他的事情去了。

4.2 异步回调

还是上面的例子，你的项目经理不可能要一直等你调研的结果。而是把这个任务交给你之后，他就不管了，他做他的，你做你的。所以，这里需要对回调的函数进行异步处理。 
所以，这里我们需要修改 Programmer 类的代码，修改如下： 
Programmer.java

public class Programmer {

    public Programmer() {
    }

    public void study(CallbackInterface callback) {
        new StudyThread(callback).start();
    }

    // --------------------------- Programmer 正在做的工作 ---------------------------

    class StudyThread extends Thread {

        CallbackInterface callback = null;

        public StudyThread(CallbackInterface _callback) {
            callback = _callback;
        }

        @Override
        public void run() {
            int result = 0;
            do {
                result++;
                System.out.println("第 " + result + " 次研究的结果");
            } while (!callback.check(result));

            System.out.println("调研任务结束");
        }
    }
}

 

运行结果

Manager 正在为 Programmer 安排工作
为 Programmer 安排工作已经完成，Manager 做其他的事情去了。
第 1 次研究的结果
第 2 次研究的结果
第 3 次研究的结果
第 4 次研究的结果
第 5 次研究的结果
调研任务结束

4.3 闭包与回调

闭包（closure）是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。

这一部分的内容主要是参见于《Java 编程思想》一书，具体细节大家可以参见此书。 
可能很多人在阅读《Java 编程思想》的时候有一些小迷糊，迷糊的原因可能多种多样。只是书中的代码展示部分的确有一些头痛，没有什么结构可言（这个只是我个人的阅读习惯，无关书籍本身的经典性），所以阅读起来不是很给力吧。下面就我阅读时的一个小总结。

4.3.1 普通调用

首先，我们可以看看在正常情况下的调用是怎么进行的。 
Incrementable.java

interface Incrementable {
    void increment();
}

这是一个普通的接口（在普通调用里只是普通接口，在回调中就是回调接口，这一点应该很好理解吧）。

Callee1.java

class Callee1 implements Incrementable {

    private int i = 0;

    @Override
    public void increment() {
        i++;
        System.out.println(i);
    }

}

Callbacks.java

public class Callbacks {
    public static void main(String[] args) {
        Callee1 callee1 = new Callee1();
        callee1.increment();
    }
}

Callbacks 是一个测试客户端类，没啥好说的，直接看上面的代码。

4.3.2 回调初试

上面的普通调用也没啥好说的，因为这对于一个正常的 Java 程序员来说都应该是想都不用想就可以搞定的事情。 
现在如果要构成回调，那么对于程序的结构或是逻辑的思维上都不可能只有一个被调用者（被回调的对象 Callee1），还需要一个调用者对象。调用者可以像下面这样来编写： 
Caller.java

class Caller {

    private Incrementable callbackReference;

    public Caller(Incrementable _callbackReference) {
        callbackReference = _callbackReference;
    }

    void go() {
        callbackReference.increment();
    }
}

这里 Caller 持有一个回调接口的引用 callbackReference，就像在上面说到的程序员需要持有一个项目经理的引用，这样就可以通过这个引用来与项目经理沟通。这里的 callbackReference 也正是起到了这个作用。 
现在我们来看看测试类的编写： 
Callbacks.java

public class Callbacks {
    public static void main(String[] args) {
        Callee1 callee1 = new Callee1();        
        Caller caller1 = new Caller(callee1);
        caller1.go();
    }
}

对于到目前为止的程序代码，完全可以对比上面项目经理安排程序员调研技术难题的代码。有异曲同工之妙。

4.3.3 闭包回调

相比于正常的回调，闭包回调的核心自然是在于闭包，也就是对作用域的控制。 
现在假设有一个用户（其他程序员）自定义了一个 MyInCrement 类，同时包含了一个 increment 的方法。如下：

class MyInCrement {

    public void increment() {
        System.out.println("MyCrement.increment");
    }

    static void f(MyInCrement increment) {
        increment.increment();
    }
}

另外有一个类 Callee2 继承自上面这个类：

class Callee2 extends MyInCrement {

    private int i = 0;

    public void increment() {
        super.increment();
        i++;
        System.out.println(i);
    }
}

显而易见这里如果要调用 increment() 方法，就变成了一般的函数调用了。所以这里我们需要修改上面的 Callee2 类，修改的目标就是让 Callee2 类可以兼容 MyInCrement 类的 increment() 方法和 Incrementable 的 increment() 方法。修改后：

class Callee2 extends MyInCrement {

    private int i = 0;

    public void increment() {
        super.increment();
        i++;
        System.out.println(i);
    }

    private class Closure implements Incrementable {

        @Override
        public void increment() {
            Callee2.this.increment();
        }
    }

    Incrementable getCallbackReference() {
        return new Closure();
    }
}

注意，这里的 Closure 类是一个私有的类，这是一个闭包的要素。因为 Closure 类是私有的，那么就要有一个对外开放的接口，用来对 Closure 对象的操作，这里就是上面的 getCallbackReference() 方法。 Caller 类则没有改变。 
对于测试客户端就直接看代码吧：

public class Callbacks {
    public static void main(String[] args) {        
        Callee2 callee2 = new Callee2();
        Caller caller2 = new Caller(callee2.getCallbackReference());
        caller2.go();
    }
}

5. Ref

 

 

以下内容转自：http://www.cnblogs.com/yaoyinglong/p/Java-CallBack.html

Java异步回调

 
 
 
 

作者：禅楼望月（http://www.cnblogs.com/yaoyinglong）

1.开始讲故事：

午饭的时候到了，可是天气太冷，根本不想出办公室的门，于是你拨通了某饭店的订餐电话“喂！你好，我是某某公司的小菜，我要点……;。然后以继续干你的工作了，过了一会儿，“你好，是某某公司的小菜吧，你的午饭到了”。这个过程便是一个典型的异步回调。那么我们来看一下，这个里面有什么必须的条件：

  1. 某饭店必须有送饭的业务；
  2. 你必须接受饭菜，如果你不接受饭菜，你就吃不到饭了。

这两个协议双方都必须遵守，其中一方不遵守，这项工作就办不成了。

首先我们定义一个送饭的业务协议：

1 public interface SendFood {
2     void sendFood(ReceiveFood receive,String foodName);
3 }

 然后我们定义一个将饭送到哪里的协议：

1 public interface ReceiveFood {
2     void receiveFood(Food food);
3 }

 然后我们定义一个餐馆让他遵守送饭的协议：

复制代码
 1 public class XXXRestaurant implements SendFood {
 2 
 3     @Override
 4     public void sendFood(ReceiveFood receive,String foodName) {
 5         //告诉厨房做饭……
 6         Food lunch=cook(foodName);
 7         //将午餐送到你们约定的地点
 8         receive.receiveFood(lunch);
 9     }
10     private Food cook(String foodName){
11         //经过一段时间，一些美食已经错出来了
12         Food someFood=new Food(foodName);    
13         return someFood;
14     }
15 }
复制代码

 然后就是定义我们自己，我们遵守接受饭菜的协议：

复制代码
 1 public class XiaoCai implements ReceiveFood {
 2     private SendFood restaurant;
 3     public XiaoCai(SendFood restaurant){
 4         this.restaurant=restaurant;
 5     }
 6     public void orderFood(final String foodName){
 7         new Runnable() {        
 8             @Override
 9             public void run() {
10                 restaurant.sendFood(XiaoCai.this,foodName);
11             }
12         }.run();
13     }
14     @Override
15     public void receiveFood(Food food) {
16         System.out.println("饭好了");
17     }
18 }
复制代码

 测试一下：

 

2.理解

因此，我们可以这样理解回调：A委托B去办一件事情，然后B办完之后通知A。表现在代码中即：类A的方法fa调用类B的方法fb,饭后fb中又调用了类A的方法fa1。

3.多线程与异步的区别[转载]

首先非常感谢YDHL iPhone Dev的贡献

3.1异步操作的本质

　　所有的程序最终都会由计算机硬件来执行，所以为了更好的理解异步操作的本质，我们有必要了解一下它的硬件基础。 熟悉电脑硬件的朋友肯定对DMA这个词不陌生，硬盘、光驱的技术规格中都有明确DMA的模式指标，其实网卡、声卡、显卡也是有DMA功能的。DMA就是直接内存访问的意思，也就是说，拥有DMA功能的硬件在和内存进行数据交换的时候可以不消耗CPU资源。只要CPU在发起数据传输时发送一个指令，硬件就开始自己和内存交换数据，在传输完成之后硬件会触发一个中断来通知操作完成。这些无须消耗CPU时间的I/O操作正是异步操作的硬件基础。所以即使在DOS这样的单进程（而且无线程概念）系统中也同样可以发起异步的DMA操作。

3.2线程的本质

　　线程不是一个计算机硬件的功能，而是操作系统提供的一种逻辑功能，线程本质上是进程中一段并发运行的代码，所以线程需要操作系统投入CPU资源来运行和调度。

3.3异步操作的优缺点

　　因为异步操作无须额外的线程负担，并且使用回调的方式进行处理，在设计良好的情况下，处理函数可以不必使用共享变量（即使无法完全不用，最起码可以减少共享变量的数量），减少了死锁的可能。当然异步操作也并非完美无暇。编写异步操作的复杂程度较高，程序主要使用回调方式进行处理，与普通人的思维方式有些初入，而且难以调试。

3.4多线程的优缺点

　　多线程的优点很明显，线程中的处理程序依然是顺序执行，符合普通人的思维习惯，所以编程简单。但是多线程的缺点也同样明显，线程的使用（滥用）会给系统带来上下文切换的额外负担。并且线程间的共享变量可能造成死锁的出现。

3.5适用范围

　　在了解了线程与异步操作各自的优缺点之后，我们可以来探讨一下线程和异步的合理用途。我认为：当需要执行I/O操作时，使用异步操作比使用线程+同步I/O操作更合适。I/O操作不仅包括了直接的文件、网络的读写，还包括数据库操作、Web Service、HttpRequest以及.Net Remoting等跨进程的调用。
　　而线程的适用范围则是那种需要长时间CPU运算的场合，例如耗时较长的图形处理和算法执行。但是往往由于使用线程编程的简单和符合习惯，所以很多朋友往往会使用线程来执行耗时较长的I/O操作。这样在只有少数几个并发操作的时候还无伤大雅，如果需要处理大量的并发操作时就不合适了。

Java异步回调

 
 

目录(?)[+]

 
 

作者：禅楼望月（http://www.cnblogs.com/yaoyinglong）

1.开始讲故事：

午饭的时候到了，可是天气太冷，根本不想出办公室的门，于是你拨通了某饭店的订餐电话“喂！你好，我是某某公司的小菜，我要点……;。然后以继续干你的工作了，过了一会儿，“你好，是某某公司的小菜吧，你的午饭到了”。这个过程便是一个典型的异步回调。那么我们来看一下，这个里面有什么必须的条件：

  1. 某饭店必须有送饭的业务；
  2. 你必须接受饭菜，如果你不接受饭菜，你就吃不到饭了。

这两个协议双方都必须遵守，其中一方不遵守，这项工作就办不成了。

首先我们定义一个送饭的业务协议：

 View Code

 然后我们定义一个将饭送到哪里的协议：

 View Code

 然后我们定义一个餐馆让他遵守送饭的协议：

 View Code

 然后就是定义我们自己，我们遵守接受饭菜的协议：

 View Code

 测试一下：

 

2.理解

因此，我们可以这样理解回调：A委托B去办一件事情，然后B办完之后通知A。表现在代码中即：类A的方法fa调用类B的方法fb,饭后fb中又调用了类A的方法fa1。

3.多线程与异步的区别[转载]

首先非常感谢YDHL iPhone Dev的贡献

3.1异步操作的本质

　　所有的程序最终都会由计算机硬件来执行，所以为了更好的理解异步操作的本质，我们有必要了解一下它的硬件基础。 熟悉电脑硬件的朋友肯定对DMA这个词不陌生，硬盘、光驱的技术规格中都有明确DMA的模式指标，其实网卡、声卡、显卡也是有DMA功能的。DMA就是直接内存访问的意思，也就是说，拥有DMA功能的硬件在和内存进行数据交换的时候可以不消耗CPU资源。只要CPU在发起数据传输时发送一个指令，硬件就开始自己和内存交换数据，在传输完成之后硬件会触发一个中断来通知操作完成。这些无须消耗CPU时间的I/O操作正是异步操作的硬件基础。所以即使在DOS这样的单进程（而且无线程概念）系统中也同样可以发起异步的DMA操作。

3.2线程的本质

　　线程不是一个计算机硬件的功能，而是操作系统提供的一种逻辑功能，线程本质上是进程中一段并发运行的代码，所以线程需要操作系统投入CPU资源来运行和调度。

3.3异步操作的优缺点

　　因为异步操作无须额外的线程负担，并且使用回调的方式进行处理，在设计良好的情况下，处理函数可以不必使用共享变量（即使无法完全不用，最起码可以减少共享变量的数量），减少了死锁的可能。当然异步操作也并非完美无暇。编写异步操作的复杂程度较高，程序主要使用回调方式进行处理，与普通人的思维方式有些初入，而且难以调试。

3.4多线程的优缺点

　　多线程的优点很明显，线程中的处理程序依然是顺序执行，符合普通人的思维习惯，所以编程简单。但是多线程的缺点也同样明显，线程的使用（滥用）会给系统带来上下文切换的额外负担。并且线程间的共享变量可能造成死锁的出现。

3.5适用范围

　　在了解了线程与异步操作各自的优缺点之后，我们可以来探讨一下线程和异步的合理用途。我认为：当需要执行I/O操作时，使用异步操作比使用线程+同步I/O操作更合适。I/O操作不仅包括了直接的文件、网络的读写，还包括数据库操作、Web Service、HttpRequest以及.Net Remoting等跨进程的调用。
　　而线程的适用范围则是那种需要长时间CPU运算的场合，例如耗时较长的图形处理和算法执行。但是往往由于使用线程编程的简单和符合习惯，所以很多朋友往往会使用线程来执行耗时较长的I/O操作。这样在只有少数几个并发操作的时候还无伤大雅，如果需要处理大量的并发操作时就不合适了。

 

 

posted on 2017-06-20 11:35  傻瓜乐园  阅读(809)  评论(0)    收藏  举报

导航