Java回调机制与在Android编程中的使用

最新推荐文章于 2024-03-26 15:25:23 发布

GuoXuan_CHN

最新推荐文章于 2024-03-26 15:25:23 发布

阅读量287

点赞数

分类专栏：麻麻Android卒

本文链接：https://blog.csdn.net/GuoXuan_CHN/article/details/81568299

版权

麻麻Android卒专栏收录该内容

34 篇文章 2 订阅

订阅专栏

本文介绍了Java回调机制，包括同步调用、异步调用和回调的概念，并通过一个老师提问、学生回答的示例详细解释了回调的实现。在Android编程中，回调机制用于处理异步操作，例如在网络访问成功后更新UI。文章还探讨了在Android中使用回调的场景和优势。

摘要由CSDN通过智能技术生成

说明

Java回调机制为引用转载，原文：https://www.cnblogs.com/xrq730/p/6424471.html

作者：五月的仓颉

Android中使用部分为原创内容，转载请注明出处。

作者：GuoXuan_CHN

Java回调机制

模块间调用

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

（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传递给调用方，这样调用方就可以在调用完毕之后告诉回调方它想要知道的信息。回调是一种思想、是一种机制，至于具体如何实现，如何通过代码将回调实现得优雅、实现得可扩展性比较高，一看开发者的个人水平，二看开发者对业务的理解程度。

同步回调与异步回调

上面的例子，可能有人会提出这样的疑问：

这个例子需要用什么回调啊，使用同步调用的方式，学生对象回答完毕问题之后直接把回答的答案返回给老师对象不就好了？

这个问题的提出没有任何问题，可以从两个角度去理解这个问题。

首先，老师不仅仅想要得到学生的答案怎么办？可能这个老师是个更喜欢听学生解题思路的老师，在得到学生的答案之前，老师更想先知道学生姓名和学生的解题思路，当然有些人可以说，那我可以定义一个对象，里面加上学生的姓名和解题思路不就好了。这个说法在我看来有两个问题：

（1）如果老师想要的数据越来越多，那么返回的对象得越来越大，而使用回调则可以进行数据分离，将一批数据放在回调方法中进行处理，至于哪些数据依具体业务而定，如果需要增加返回参数，直接在回调方法中增加即可

（2）无法解决老师希望得到学生姓名、学生解题思路先于学生回答的答案的问题

因此我认为简单的返回某个结果确实没有必要使用回调而可以直接使用同步调用，但是如果有多种数据需要处理且数据有主次之分，使用回调会是一种更加合适的选择，优先处理的数据放在回调方法中先处理掉。

另外一个理解的角度则更加重要，就是标题说的同步回调和异步回调了。例子是一个同步回调的例子，意思是老师向Ricky问问题，Ricky给出答案，老师问下一个同学，得到答案之后继续问下一个同学，这是一种正常的场景，但是如果我把场景改一下：

老师并不想One-By-One这样提问，而是同时向Ricky、Mike、Lucy、Bruce、Kate五位同学提问，让同学们自己思考，哪位同学思考好了就直接告诉老师答案即可。

这种场景相当于是说，同学思考完毕完毕问题要有一个办法告诉老师，有两个解决方案：

（1）使用Future+Callable的方式，等待异步线程执行结果，这相当于就是同步调用的一种变种，因为其本质还是方法返回一个结果，即学生的回答

（2）使用异步回调，同学回答完毕问题，调用回调接口方法告诉老师答案即可。由于老师对象被抽象成了Callback接口，因此这种做法的扩展性非常好，就像之前说的，即使老师换了换了一茬又一茬，对于同学来说，只关心的是调用Callback接口回传必要的信息即可

回调机制在Android编程中的使用

背景介绍

本人刚刚大学毕业，入行Android开发。在大学期间主要使用C语言进行编程。在公司自己尝试写了一个界面。需求是一个界面展示，默认是无网络访问，对无网络访问的界面设置点击，进行网络访问。当然，在一开始的时候也要尝试网络访问。如果网络访问成功，则修改页面，显示从服务器获得的数据。可能是因为以前是面向过程，对于面向对象编程不怎么了解，犯了一些问题，问题就不过多叙述。

说明

主要是四个代码。下面看到的是公司的学姐给我修改以后的。您可以在代码中看到，匿名内部类访问权限和回调机制的联合使用。因为是莹姐帮忙改的。就姑且命名为莹氏调用。其中重点是在MainActivity.java中的void init() 函数中。

莹氏调用

MainActivity.java

// Write By GX、ZY
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v7.app.ActionBar;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;


public class MainActivity extends AppCompatActivity {

    NetWorks mNetWorks;

    LoadDataListener loadDataListener;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();
        hideActionBar();
        requsetData();
    }

    @Override
    protected void onResume() {
        super.onResume();

        FragmentNotFound fragmentNotFound = new FragmentNotFound();
        fragmentNotFound.setmLoadDataListener(loadDataListener);
        initFragment(R.id.Fragment_show,new FragmentNotFound());
    }

    private void requsetData() {
        loadDataListener.loadData();
    }

    void hideActionBar() {
        ActionBar actionBar = getSupportActionBar();
        if (actionBar != null)  actionBar.hide();
    }

    void init(){
        mNetWorks = new NetWorks();
        loadDataListener = new LoadDataListener() {
            @Override
            public void loadData() {
                    mNetWorks.setmNetworkcall(new NetWorks.NetworkCallback() {
                        @Override
                        public void onResponde(String response) {
                            replaceFragment(R.id.Fragment_show,new FragmentShowRanking());
                        }
                    }
                    );
                    mNetWorks.getPinking(NetWorksBean.PinkingURL);
            }
        };
    }

   void replaceFragment(int Layout ,Fragment fragment){
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.replace(Layout,fragment);
        transaction.commit();
    }
    void initFragment(int Layout ,Fragment fragment) {
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.add(Layout, fragment);
        transaction.commit();
    }
}

LoadDataListener.java

// Write By GX、ZY
public interface LoadDataListener {
    void loadData();
}

NetWorks.java

// Write By GX、ZY
import android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.widget.Toast;

import com.example.leeco.mysearch.MainActivity;
import com.squareup.okhttp.Call;
import com.squareup.okhttp.Callback;
import com.squareup.okhttp.OkHttpClient;
import com.squareup.okhttp.Request;
import com.squareup.okhttp.Response;


import java.io.IOException;


public class NetWorks{
    String get;
    NetworkCallback mNetWorkCallback;

    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case 1:
                    get = (String) msg.obj;
                    mNetWorkCallback.onResponde(get);
                    Log.d("gx_get","OK: get string");
                    Log.d("gx_get","OK: get - " + get);
                    break;
            }
        }
    };

    public void setmNetworkcall(NetworkCallback mNetworkcall) {
        this.mNetWorkCallback = mNetworkcall;
    }

    //nul
    void getPinking(String url){
        //1.okhttpClient对象
        OkHttpClient okHttpClient = new OkHttpClient();
        //2构造Request,
        //builder.get()代表的是get请求，url方法里面放的参数是一个网络地址
        Request.Builder builder = new Request.Builder();
        Request request = builder.get().url(url).build();

        //3将Request封装成call
        Call call = okHttpClient.newCall(request);

        //4，执行call，这个方法是异步请求数据
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Request request, IOException e) {
                Log.d("gx_get","error:" + request.toString());
            }

            @Override
            public void onResponse(Response response) throws IOException {
                String  string = response.body().string();
                Log.d("gx_get","OK:" + string);
                Message msg = new Message();
                msg.what = 1;
                msg.obj = string;
                handler.sendMessage(msg);
            }
        });
    }

    public interface NetworkCallback {
        void onResponde(String response);
    }
}

FragmentNotFound.java

// Write By GX、ZY
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.RelativeLayout;

public class FragmentNotFound extends Fragment {
    View mView;
    RelativeLayout mRelativeLayout;
    LoadDataListener mLoadDataListener;

    public void setmLoadDataListener(LoadDataListener mLoadDataListener) {
        this.mLoadDataListener = mLoadDataListener;
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        super.onCreateView(inflater, container, savedInstanceState);
        mView = inflater.inflate(R.layout.not_search, container,false);
        initTools();
        return mView;
    }

    void initTools(){
        mRelativeLayout = mView.findViewById(R.id.Layout_NotFound);
        mRelativeLayout.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mLoadDataListener.loadData();
            }
        });
    }
}

由于是公司的电脑，我把包名都删掉了。代码逻辑很简单，功能就像背景介绍中的一样。

对于回调模式的思考

回调模式使用接口的原因是，在java中不能将函数作为参数传递。只能借助于借口类，将方法封装，从而作为参数进行传递。
回调机制的出现是因为面向对象编程中存在的访问边界问题。C的函数只要include就是使用(函数名作为内存地址)。而Android-java中如果要使用，需创建对象(开辟内存空间)，或书写为static(程序创建之初即放在堆中)。而静态方法因为依赖关系，所以使用起来范围较为狭窄，同时如果不经常使用，未免消耗内存空间。而如果仅为了使用其中的一个方法去创建对象，其中的消耗未免过大。所以回调机制似乎是最完美的方法。
上面的骚操作对于我这种Android菜鸟来说已经是奇技淫巧了。看得懂，写不出来。但是，对比改前与改后的区别，从效果看，这种使用模式，模糊了面向对象的访问边界，其中主要是“内部类可以直接访问外部类中的成员”这一原则。