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 classTargetRes 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;
    }