Java回调

weixin_30629977

于 2019-05-13 15:40:00 发布

阅读量41

点赞数

原文链接：http://www.cnblogs.com/jarekpierre/p/10856987.html

版权

引用 https://www.cnblogs.com/xrq730/p/6424471.html

引用 https://blog.csdn.net/xiaanming/article/details/8703708/

模块间调用

在一个应用系统中，无论使用何种语言开发，必然存在模块之间的调用，调用的方式分为几种：

（1）同步调用

同步调用是最基本并且最简单的一种调用方式，类A的方法a()调用类B的方法b()，一直等待b()方法执行完毕，a()方法继续往下走。这种调用方式适用于方法b()执行时间不长的情况，因为b()方法执行时间一长或者直接阻塞的话，a()方法的余下代码是无法执行下去的，这样会造成整个流程的阻塞。

（2）异步调用

异步调用是为了解决同步调用可能出现阻塞，导致整个流程卡住而产生的一种调用方式。类A的方法方法a()通过新起线程的方式调用类B的方法b()，代码接着直接往下执行，这样无论方法b()执行时间多久，都不会阻塞住方法a()的执行。但是这种方式，由于方法a()不等待方法b()的执行完成，在方法a()需要方法b()执行结果的情况下（视具体业务而定，有些业务比如启异步线程发个微信通知、刷新一个缓存这种就没必要），必须通过一定的方式对方法b()的执行结果进行监听。在Java中，可以使用Future+Callable的方式做到这一点，具体做法可以参见我的这篇文章Java多线程21：多线程下其他组件之CyclicBarrier、Callable、Future和FutureTask。

（3）回调

最后是回调，回调的思想是：

类A的a()方法调用类B的b()方法
类B的b()方法执行完毕主动调用类A的callback()方法

这样一种调用方式组成了上图，也就是一种双向的调用方式。

代码示例

接下来看一下回调的代码示例，代码模拟的是这样一种场景：老师问学生问题，学生思考完毕回答老师。

首先定义一个回调接口，只有一个方法tellAnswer(int answer)，即学生思考完毕告诉老师答案：

1 /**
2  * 回调接口，原文出处http://www.cnblogs.com/xrq730/p/6424471.html
3  */
4 public interface Callback {
5 
6     public void tellAnswer(int answer);
7     
8 }

定义一个老师对象，实现Callback接口：

 1 /**
 2  * 老师对象，原文出处http://www.cnblogs.com/xrq730/p/6424471.html
 3  */
 4 public class Teacher implements Callback {
 5 
 6     private Student student;
 7     
 8     public Teacher(Student student) {
 9         this.student = student;
10     }
11     
12     public void askQuestion() {
13         student.resolveQuestion(this);
14     }
15     
16     @Override
17     public void tellAnswer(int answer) {
18         System.out.println("知道了，你的答案是" + answer);
19     }
20     
21 }

老师对象有两个public方法：

（1）回调接口tellAnswer(int answer)，即学生回答完毕问题之后，老师要做的事情

（2）问问题方法askQuestion()，即向学生问问题

接着定义一个学生接口，学生当然是解决问题，但是接收一个Callback参数，这样学生就知道解决完毕问题向谁报告：

1 /**
2  * 学生接口，原文出处http://www.cnblogs.com/xrq730/p/6424471.html
3  */
4 public interface Student {
5     
6     public void resolveQuestion(Callback callback);
7     
8 }

最后定义一个具体的学生叫Ricky：

 1 /**
 2  * 一个名叫Ricky的同学解决老师提出的问题，原文出处http://www.cnblogs.com/xrq730/p/6424471.html
 3  */
 4 public class Ricky implements Student {
 5 
 6     @Override
 7     public void resolveQuestion(Callback callback) {
 8         // 模拟解决问题
 9         try {
10             Thread.sleep(3000);
11         } catch (InterruptedException e) {
12             
13         }
14         
15         // 回调，告诉老师作业写了多久
16         callback.tellAnswer(3);
17     }
18 
19 }

在解决完毕问题之后，第16行向老师报告答案。

写一个测试类，比较简单：

 1 /**
 2  * 回调测试，原文出处http://www.cnblogs.com/xrq730/p/6424471.html
 3  */
 4 public class CallbackTest {
 5 
 6     @Test
 7     public void testCallback() {
 8         Student student = new Ricky();
 9         Teacher teacher = new Teacher(student);
10         
11         teacher.askQuestion();
12         
13     }
14     
15 }

代码运行结果就一行：

知道了，你的答案是3

简单总结、分析一下这个例子就是：

（1）老师调用学生接口的方法resolveQuestion，向学生提问

（2）学生解决完毕问题之后调用老师的回调方法tellAnswer

这样一套流程，构成了一种双向调用的关系。

代码分析

分析一下上面的代码，上面的代码我这里做了两层的抽象：

（1）将老师进行抽象

将老师进行抽象之后，对于学生来说，就不需要关心到底是哪位老师询问我问题，只要我根据询问的问题，得出答案，然后告诉提问的老师就可以了，即使老师换了一茬又一茬，对我学生而言都是没有任何影响的

（2）将学生进行抽象

将学生进行抽象之后，对于老师这边来说就非常灵活，因为老师未必对一个学生进行提问，可能同时对Ricky、Jack、Lucy三个学生进行提问，这样就可以将成员变量Student改为List<Student>，这样在提问的时候遍历Student列表进行提问，然后得到每个学生的回答即可

这个例子是一个典型的体现接口作用的例子，之所以这么说是因为我想到有些朋友可能不太明白接口的好处，不太明白接口好处的朋友可以重点看一下这个例子，多多理解。

总结起来，回调的核心就是回调方将本身即this传递给调用方，这样调用方就可以在调用完毕之后告诉回调方它想要知道的信息。回调是一种思想、是一种机制，至于具体如何实现，如何通过代码将回调实现得优雅、实现得可扩展性比较高，一看开发者的个人水平，二看开发者对业务的理解程度。

以下为引用的第二篇https://blog.csdn.net/xiaanming/article/details/8703708/

所谓回调：就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法，这样子说你是不是有点晕晕的，其实我刚开始也是这样不理解，看了人家说比较经典的回调方式：

Class A实现接口CallBack callback——背景1
class A中包含一个class B的引用b ——背景2
class B有一个参数为callback的方法f(CallBack callback) ——背景3
A的对象a调用B的方法 f(CallBack callback) ——A类调用B类的某个方法 C
然后b就可以在f(CallBack callback)方法中调用A的方法 ——B类调用A类的某个方法D
大家都喜欢用打电话的例子，好吧，为了跟上时代，我也用这个例子好了，我这个例子采用异步加回调

有一天小王遇到一个很难的问题，问题是“1 + 1 = ?”，就打电话问小李，小李一下子也不知道，就跟小王说，等我办完手上的事情，就去想想答案，小王也不会傻傻的拿着电话去等小李的答案吧，于是小王就对小李说，我还要去逛街，你知道了答案就打我电话告诉我，于是挂了电话，自己办自己的事情，过了一个小时，小李打了小王的电话，告诉他答案是2

/**
 * 这是一个回调接口
 * @author xiaanming
 *
 */
public interface CallBack {
    /**
     * 这个是小李知道答案时要调用的函数告诉小王，也就是回调函数
     * @param result 是答案
     */
    public void solve(String result);
}

/**
 * 这个是小王
 * @author xiaanming
 * 实现了一个回调接口CallBack，相当于----->背景一
 */
public class Wang implements CallBack {
    /**
     * 小李对象的引用
     * 相当于----->背景二
     */
    private Li li; 
 
    /**
     * 小王的构造方法，持有小李的引用
     * @param li
     */
    public Wang(Li li){
        this.li = li;
    }
    
    /**
     * 小王通过这个方法去问小李的问题
     * @param question  就是小王要问的问题,1 + 1 = ?
     */
    public void askQuestion(final String question){
        //这里用一个线程就是异步，
        new Thread(new Runnable() {
            @Override
            public void run() {
                /**
                 * 小王调用小李中的方法，在这里注册回调接口
                 * 这就相当于A类调用B的方法C
                 */
                li.executeMessage(Wang.this, question); 
            }
        }).start();
        
        //小网问完问题挂掉电话就去干其他的事情了，诳街去了
        play();
    }
 
    public void play(){
        System.out.println("我要逛街去了");
    }
 
    /**
     * 小李知道答案后调用此方法告诉小王，就是所谓的小王的回调方法
     */
    @Override
    public void solve(String result) {
        System.out.println("小李告诉小王的答案是--->" + result);
    }
    
}

 1 /**
 2  * 这个就是小李啦
 3  * @author xiaanming
 4  *
 5  */
 6 public class Li {
 7     /**
 8      * 相当于B类有参数为CallBack callBack的f()---->背景三
 9      * @param callBack  
10      * @param question  小王问的问题
11      */
12     public void executeMessage(CallBack callBack, String question){
13         System.out.println("小王问的问题--->" + question);
14         
15         //模拟小李办自己的事情需要很长时间
16         for(int i=0; i<10000;i++){
17             
18         }
19         
20         /**
21          * 小李办完自己的事情之后想到了答案是2
22          */
23         String result = "答案是2";
24         
25         /**
26          * 于是就打电话告诉小王，调用小王中的方法
27          * 这就相当于B类反过来调用A的方法D
28          */
29         callBack.solve(result); 
30  
31         
32         
33     }
34     
35 }

 1 /**
 2  * 测试类
 3  * @author xiaanming
 4  *
 5  */
 6 public class Test {
 7     public static void main(String[]args){
 8         /**
 9          * new 一个小李
10          */
11         Li li = new Li();
12  
13         /**
14          * new 一个小王
15          */
16         Wang wang = new Wang(li);
17         
18         /**
19          * 小王问小李问题
20          */
21         wang.askQuestion("1 + 1 = ?");
22     }
23 }

通过上面的那个例子你是不是差不多明白了回调机制呢，上面是一个异步回调，我们看看同步回调吧，onClick（）方法

现在来分析分析下Android View的点击方法onclick（）;我们知道onclick()是一个回调方法，当用户点击View就执行这个方法，我们用Button来举例好了

 1 //这个是View的一个回调接口
 2 /**
 3  * Interface definition for a callback to be invoked when a view is clicked.
 4  */
 5 public interface OnClickListener {
 6     /**
 7      * Called when a view has been clicked.
 8      *
 9      * @param v The view that was clicked.
10      */
11     void onClick(View v);
12 }

 1 package com.example.demoactivity;
 2  
 3 import android.app.Activity;
 4 import android.os.Bundle;
 5 import android.view.View;
 6 import android.view.View.OnClickListener;
 7 import android.widget.Button;
 8 import android.widget.Toast;
 9  
10 /**
11  * 这个就相当于Class A
12  * @author xiaanming
13  * 实现了 OnClickListener接口---->背景一
14  */
15 public class MainActivity extends Activity implements OnClickListener{
16     /**
17      * Class A 包含Class B的引用----->背景二
18      */
19     private Button button;
20  
21     @Override
22     public void onCreate(Bundle savedInstanceState) {
23         super.onCreate(savedInstanceState);
24         setContentView(R.layout.activity_main);
25         button = (Button)findViewById(R.id.button1);
26         
27         /**
28          * Class A 调用View的方法,而Button extends View----->A类调用B类的某个方法 C
29          */
30         button.setOnClickListener(this);
31     }
32  
33     /**
34      * 用户点击Button时调用的回调函数，你可以做你要做的事
35      * 这里我做的是用Toast提示OnClick
36      */
37     @Override
38     public void onClick(View v) {
39         Toast.makeText(getApplication(), "OnClick", Toast.LENGTH_LONG).show();
40     }
41  
42 }

下面是View类的setOnClickListener方法，就相当于B类咯，只把关键代码贴出来

 1 /**
 2  * 这个View就相当于B类
 3  * @author xiaanming
 4  *
 5  */
 6 public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource {
 7     /**
 8      * Listener used to dispatch click events.
 9      * This field should be made private, so it is hidden from the SDK.
10      * {@hide}
11      */
12     protected OnClickListener mOnClickListener;
13     
14     /**
15      * setOnClickListener()的参数是OnClickListener接口------>背景三
16      * Register a callback to be invoked when this view is clicked. If this view is not
17      * clickable, it becomes clickable.
18      *
19      * @param l The callback that will run
20      *
21      * @see #setClickable(boolean)
22      */
23     
24     public void setOnClickListener(OnClickListener l) {
25         if (!isClickable()) {
26             setClickable(true);
27         }
28         mOnClickListener = l;
29     }
30     
31     
32     /**
33      * Call this view's OnClickListener, if it is defined.
34      *
35      * @return True there was an assigned OnClickListener that was called, false
36      *         otherwise is returned.
37      */
38     public boolean performClick() {
39         sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
40  
41         if (mOnClickListener != null) {
42             playSoundEffect(SoundEffectConstants.CLICK);
43             
44             //这个不就是相当于B类调用A类的某个方法D，这个D就是所谓的回调方法咯
45             mOnClickListener.onClick(this);
46             return true;
47         }
48  
49         return false;
50     }
51 }

这个例子就是Android典型的回调机制，看完这个你是不是更进一步的理解了回调机制呢？线程run()也是一个回调方法，当执行Thread的start（）方法就会回调这个run()方法，还有处理消息都比较经典等等

转载于:https://www.cnblogs.com/jarekpierre/p/10856987.html

weixin_30629977

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java回调

引用 https://www.cnblogs.com/xrq730/p/6424471.html引用 https://blog.csdn.net/xiaanming/article/details/8703708/模块间调用在一个应用系统中，无论使用何种语言开发，必然存在模块之间的调用，调用的方式分为几种：（1）同步调用同步调用是最基本并且最简单的一种调用方式，类A的...
复制链接

扫一扫