Android回调机制浅析

编程工作的层次可以分为系统编程和应用编程：

系统编程（system programming）：写库方法，API

应用编程（application programming）：调用API实现功能

系统和应用怎么统一起来实现一个功能呢？可以有三种机制来完成，同步机制，异步机制和回调机制。

本文主要讨论的是回调机制。

回调概述

　　一般的正向代码流程的都是是应用调用API中的方法实现功能。但有些情况对于应用开发者来说是透明的，比如说你想取快递，快递什么时候到你又不知道，解决的办法有两种，轮询（不停地下楼去看）和委托（叫保安电话通知你），回调机制正是委托的思想。

　　回调函数就是自己写的，但是不是自己来调，而是给别人来调的函数。也就是说，工作委托给了库函数(或者中间函数)，但是事件到达之后，库函数怎么执行（快递来了打电话给你还是跑楼下叫你）需要应用开发者注册给库函数，这个就是回调函数，也叫钩子函数.

如图，回调的过程分三个部分，三方联动：起始函数＋中间函数＋回调函数



　　如图，回调的过程就成了上层调用下层，下层在执行回调函数的过程，可以看到，回调函数和应用层一般处在同一抽象层。

在回调机制中，中间函数通过传参或者实现得到回调函数像。可以这么理解，在传入一个回调函数之前，中间函数是不完整的，程序可以在运行时，通过注册不同的回调函数，来决定、改变中间函数的行为。这就是回调函数带来的执行时机和执行逻辑的灵活性。

　　回调实际上有两种：阻塞式回调和延迟式回调。两者的区别在于：阻塞式回调里，回调函数的调用一定发生在起始函数返回之前；而延迟式回调里，回调函数的调用有可能是在起始函数返回之后，一般牵扯到多线程。

　　回调的思想是叫别人替你做事，委托的方法，那么事件到来别人需要一个你的引用，但是把自己整个暴露给别人是不安全的，典型的做法是定义接口实现。

　　回调方法最大的优势在于，异步回调，这样是其最被广为使用的原因，告知被委托人之后，就可以做自己的事情了。

精彩举例：

通过网上两个精彩的例子来加深对回调函数的例子

网例１：

你去食堂打饭，你喜欢吃小炒，所以你去了一个小炒窗口。

你跟老板说了要回锅肉盖饭，老板说：你是1１号，喊到你的号你就来拿菜。

然后你在旁边跟同学吹牛、或者看手机、或者干点你想干的任何事情。

然后你听到老板喊1１号并且把菜放到窗口，你走到窗口，拿到你的菜。

这里面有几个函数：

老板的部分：

1、老板提供一个点餐的函数 boss.Order(string 菜名,double 钱)

2、老板有个做饭的函数，此函数耗时较长boss.Cook()

3、 老板提供一个事件，当boss.cook()执行完时，该事件被触发，boss.OnCookFinish;

你的部分：

1、你需要有一个函数去订餐，也就是你的函数中需要执行类似于boss.Order("回锅肉盖浇饭",20)，比如是me.Hungry(),需要一个boss对象

2、你需要有一个函数作为回调函数去关注boss.OnCookFinish事件，这样当老板做好饭，你就可以知道是不是你的好了。

由于老板的事件发生的时候中会喊编号并且吧菜放到窗口，所以你的回调函数需要能够接受1个编号和1个菜作为参数。

比如me.AcceptFood(int currNumber,object food)

所以整个程序的流程其实是这样的。

me.Hungry(){

boss.Order("回锅肉盖浇饭",20);

boss.OnCookFinish+=me.AcceptFood;//此处表面，AcceptFood这个回调函数关心OnCookFinish事件，并且变成这个事件的回调函数

//此时这个函数执行完，不再等待

}

boss.Order("回锅肉盖浇饭",20){

boss.Cook();//此处一般会开新线程执行cook动作

}

boss.Cook(){

//cooking~~~~~~~~~~

OnCookFinish(1１号,回锅肉盖浇饭);

}

网例２：

有个这样的问题：老板（Boss）让工人（Worker）干完活告诉他干的情况如何

过程如下：

/**

* 回调事件接口

*/

public interface Event {

/**

* 返回发生事件信息

*/

//钩子函数

public String happendEvent();

}

/**

* 事件A

*/

public class EventA implements Event {

/**

* 返回发生事件信息

*/

public String happendEvent() {

return "发生了事件 EventA！";

}

}

/**

* 事件B

*/

public class EventB implements Event{

/**

* 返回发生事件信息

*/

public String getHappendEvent() {

return "发生了事件 EventB！";

}

}

/**

* 工人类，做重复的工作，做完了之后看发生了哪些事，报告给老板

*/

public class Worker {

private Event event; //事件

private String name; //工人姓名

private Boss boss; //工人所属的老板

//构造，初始化

public Worker(String name, Boss boss) {

this.name = name;

this.boss = boss;

}

/**

* 干活

*/

public void doWork() {

System.out.println(name + " is doing working...");

//工人干着枯燥乏味的重复工作

for (int i = 0; i < 2000000; i++) {

……

}

System.out.println(name + " was finished work.");

//结束了工作之后向老板说明发生的情况，进行回调

boss.happendEvent(this, event);

}

public Event getEvent() {

return event;

}

public void setEvent(Event event) {

this.event = event;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

/**

* 老板 委托给工人

*/

public class Boss {

private String name;

public Boss(String name) {

this.name = name;

}

/**

* 老板接收工人的事件，注册回调接口（继承或者作为接口传进来），我想在你们工作完成之后知道哪一组发生了什么事

* @param worker 工人

* @param event 事件

*/

public void getWorkerEvent(Worker worker, Event event) {

System.out.println("老板接收到事件信息： "+worker.getName() + ": " + event.happendEvent());

}

}

总结：例子中我们可以更深入的理解

１．上层委托给底层，同时实现了回调机制，注册了回调方法（定义接口，并实现接口）

２．注册函数，就是setCallback(),把继承实现了接口的类对象传过去

３．上层给底层发指令开始工作

４．底层开始工作，工作完成后把结果告诉上层（一般是一个异步耗时的工作）

５．上层之前已经定义了回调机制，根据底层传回的参数即可迅速反应（回调方法的执行）

实际代码举例

实际代码例１：（直接实现接口的方式）

网络操作返回后调用onFinish执行一定的操作

１．定义接口和钩子函数

/**

* HTTP 请求回调接口

*/

public interface HttpCallBack {

void onFinished(int rCode,String result);

}

２．实现该接口，

public class
TargetRes implements HttpCallBack{　
@Override

public void onFinished(int resCode, String result) {

　　　　Log.d(TAG, "onFinished->rCode:" + rCode);

}
｝

３．底层耗时或异步方法执行完成后调用回调函数

if(callBack != null){

callBack.onFinished(tatgetCode,result);

}

实际代码例2：(接口作为参数传递实现的例子)

１．定义接口

public interface ResultCallback {

public void onFileChanged(int code);

}

２．使用中ｎｅｗ一个接口并进行实现

ResultCallback mResultCallback = new ResultCallback (){

@Override

public void onFileChanged(int code) {

LogUtil.e(mContext, TAG, "ResultCallback ---onFileChanged code------"+code);

mResultCallback .onFileChanged (code);

if(100 == code){

...

}

}
｝
３．在某个方法中，将接口作为参数传入，实现回调接口的绑定

public void sendFileData(）｛
mResultCallback .startSendFile(filePath, version, Parameter, updateMode, mResultCallback );
｝

４．在某些类中根据逻辑调用已经注册的回调接口

a.onFileChanged(process);

实际代码例3：(Android中点击事件的回调机制举例)

//接口

public interface OnClickListener{
//回调方法

void onClick(View v);

}

//
public class MainActivity extends Activity implements OnClickListener{

private Button button;

@Override

public void onCreate(Bundle savedInstanceState){

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

button=(Button)findViewById(R.id.button1);
//注册回调接口，上层给底层分配任务，事件到来时的操作早已经规定好了

button.setOnClickListener(this);

}

//这个是回调函数

@Override

public void onClick(View v){

Toast.makeText(getApplication(), "OnClick", Toast.LENGTH_LONG).show();

}

}

public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource {

protected OnClickListener mOnClickListener;
//获取回调实例

public void setOnClickListener(OnClickListener l) {

if (!isClickable()) {

setClickable(true);

}

mOnClickListener = l;

}

　　//这里调用回调方法
public boolean performClick() {

sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

if (mOnClickListener != null) {

playSoundEffect(SoundEffectConstants.CLICK);
mOnClickListener.onClick(this);

return true;

}

return false;

}