Android(安卓)IPC机制(四):细说Binder连接池

一、前言

在上一篇文章 Android IPC机制(三):浅谈Binder的使用中，笔者浅谈了Binder的使用及其工作机制，利用AIDL方式能很方便地进行客户端和服务端的跨进程通信。但是，我们想一下，如果按照我们之前的使用方法，必须满足一个AIDL接口对应一个service，那么问题来了，假如我们的应用，有很多模块，而每一个模块都需要和服务端通讯，那么我们也要为每一个模块创建特定的aidl文件，那么服务端service也会产生很多个，显然，如果aidl接口变多，那么service也会跟着变多，那么这样的用户体验就会非常不好，那么我们该怎么做呢？在任玉刚著的《Android 开发艺术探索》一书中，给出了一个Binder连接池的概念，即利用一个Binder连接池来管理所有Binder，服务端只需要管理这个Bindere连接池即可，这样就能实现一个service管理多个Binder，为不同的模块返回不同的Binder，以实现进程间通讯。所以，本文将讲述如何实现Binder连接池。

二、实现

1、先提供两个AIDL接口来模拟多个模块都要使用AIDL的情况：ISpeak接口和ICalculate接口：

package com.chenyu.service;interface ISpeak {    void speak();}

package com.chenyu.service;interface ICalculate {    int add(in int num1,in int num2);}

接着，实现这两个接口：分别为Speak.java和Calculate.java文件：

public class Speak extends Stub {    public Speak() {        Log.d("cylog","我被实例化了..............");    }    @Override    public void speak() throws RemoteException {        int pid = android.os.Process.myPid();        Log.d("cylog","当前进程ID为："+pid+"-----"+"这里收到了客户端的speak请求");    }}

public class Calculate extends ICalculate.Stub {    @Override    public int add(int num1, int num2) throws RemoteException {        int pid = android.os.Process.myPid();        Log.d("cylog", "当前进程ID为："+pid+"----"+"这里收到了客户端的Calculate请求");        return num1+num2;    }}

可以看到，这两个接口的实现类，都是继承了Interface.Stub类，这个在上一章的服务端代码出现过，是在服务端的service内部实现了接口的方法，而这里我们把实现了接口的方法从服务端抽离出来了，其实这个实现类依然是运行在服务端的进程中，从而实现了AIDL接口和服务端的解耦合工作，让服务端不再直接参与AIDL接口方法的实现工作。那么，服务端通过什么桥梁与AIDL接口联系呢？答案就是Binder连接池。Binder连接池管理着所有的AIDL接口，就如一位将军统帅着千军。客户端需要什么Binder，就提供信息给Binder连接池，而连接池根据相应信息返回正确的Binder，这样客户端就能执行特定的操作了。可以说，Binder连接池的思路，非常类似设计模式之中的工厂模式。接下来我们看Binder连接池的具体实现：

2、为Binder连接池创建AIDL接口：IBinderPool.aidl:

interface IBinderPool {    IBinder queryBinder(int binderCode);  //查找特定Binder的方法}

为什么需要这个接口？我们从上面的分析可以知道，service端并不直接提供具体的Binder，那么客户端和服务端连接的时候就应该返回一个IBinderPool对象，让客户端拿到这个IBinderPool的实例，然后由客户端决定应该用哪个Binder。所以服务端的代码很简单，只需要返回IBinderPool对象即可：

3、服务端service代码：

public class BinderPoolService extends Service {    private Binder mBinderPool = new BinderPool.BinderPoolImpl();   // 1    private int pid = Process.myPid();    @Override    public IBinder onBind(Intent intent) {        Log.d("cylog", "当前进程ID为："+pid+"----"+"客户端与服务端连接成功，服务端返回BinderPool.BinderPoolImpl 对象");        return mBinderPool;    }}

①号代码处，实例化了一个BinderPool.BinderPoolImpl类，并在onBind方法返回了这个mBinderPool对象。

4、接下来我们看BinderPool的具体实现，代码比较长，我们先大体上认识，再详细分析：

public class BinderPool {    public static final int BINDER_SPEAK = 0;    public static final int BINDER_CALCULATE = 1;    private Context mContext;    private IBinderPool mBinderPool;    private static volatile BinderPool sInstance;    private CountDownLatch mConnectBinderPoolCountDownLatch;    private BinderPool(Context context) {   // 1        mContext = context.getApplicationContext();        connectBinderPoolService();    }    public static BinderPool getInstance(Context context) {     // 2        if (sInstance == null) {            synchronized (BinderPool.class) {                if (sInstance == null) {                    sInstance = new BinderPool(context);                }            }        }        return sInstance;    }    private synchronized void connectBinderPoolService() {      // 3        mConnectBinderPoolCountDownLatch = new CountDownLatch(1);        Intent service = new Intent(mContext, BinderPoolService.class);        mContext.bindService(service, mBinderPoolConnection,                Context.BIND_AUTO_CREATE);        try {            mConnectBinderPoolCountDownLatch.await();        } catch (InterruptedException e) {            e.printStackTrace();        }    }        public IBinder queryBinder(int binderCode) {          // 4        IBinder binder = null;        try {            if (mBinderPool != null) {                binder = mBinderPool.queryBinder(binderCode);            }        } catch (RemoteException e) {            e.printStackTrace();        }        return binder;    }    private ServiceConnection mBinderPoolConnection = new ServiceConnection() {       // 5        @Override        public void onServiceDisconnected(ComponentName name) {                    }        @Override        public void onServiceConnected(ComponentName name, IBinder service) {            mBinderPool = IBinderPool.Stub.asInterface(service);            try {                mBinderPool.asBinder().linkToDeath(mBinderPoolDeathRecipient, 0);            } catch (RemoteException e) {                e.printStackTrace();            }            mConnectBinderPoolCountDownLatch.countDown();        }    };    private IBinder.DeathRecipient mBinderPoolDeathRecipient = new IBinder.DeathRecipient() {    // 6        @Override        public void binderDied() {            mBinderPool.asBinder().unlinkToDeath(mBinderPoolDeathRecipient, 0);            mBinderPool = null;            connectBinderPoolService();        }    };    public static class BinderPoolImpl extends IBinderPool.Stub {     // 7        public BinderPoolImpl() {            super();        }        @Override        public IBinder queryBinder(int binderCode) throws RemoteException {            IBinder binder = null;            switch (binderCode) {                case BINDER_SPEAK: {                    binder = new Speak();                    break;                }                case BINDER_CALCULATE: {                    binder = new Calculate();                    break;                }                default:                    break;            }            return binder;        }    }}

大体上看，这个类完成的功能有实现客户端和服务端的连接，同时内有还有一个静态内部类：BinderPoolImpl，继承了IBinderPool.Stub，这也非常眼熟，所以这个静态内部类应该是运行了服务端的。好了，我们从上往下分析每一个方法的作用：

①private BinderPool(Context context)构造方法：这里传递了context对象，注意到，这个构造方法使用了private修饰，那么外界是无法直接调用构造器的，所以有了②号方法。

②public static BinderPool getInstance(Context context):看到getInstance字样，熟悉设计模式的读者应该知道了这里是使用了单例模式，而且是线程同步的懒汉式单例模式，在方法内部，把传递进来的context上下文参数传递进构造函数，即此时调用了①号方法，接着①号方法调用了connectBinderPoolService()方法，即③号方法。

③private synchronized void connectBinderPoolService():这个方法主要用于客户端与服务端建立连接，在方法内部出现了CountDownLatch类，这个类是用于线程同步的，由于bindService()是异步操作，所以如果要确保客户端在执行其他操作之前已经绑定好服务端，就应该先实现线程同步。这里简单提一下这个类：

CountDownLatch类有三个主要方法：

(1)构造方法 CountDownLatch(int num)：这里传递一个num值，为countdownlatch内部的计时器赋值。

(2)countdown():每当调用一次这个方法，countdownlatch实例内部计时器数值 - 1。

(3)await():让当前线程等待，如果内部计时器变为0，那么唤醒当前线程。

④public IBinder queryBinder(int binderCode):根据具体的binderCode值来获得某个特定的Binder，并返回。

⑤private ServiceConnection mBinderPoolConnection = new ServiceConnection(){} :这个类似于上一章客户端的连接代码，在服务端与客户端连接成功的时候，会回调当前的onServiceConnected()函数，我们来着重看看这个函数：

@Override        public void onServiceConnected(ComponentName name, IBinder service) {            mBinderPool = IBinderPool.Stub.asInterface(service);            try {                mBinderPool.asBinder().linkToDeath(mBinderPoolDeathRecipient, 0);            } catch (RemoteException e) {                e.printStackTrace();            }            mConnectBinderPoolCountDownLatch.countDown();        }

注意到，方法内部执行了mBinderPool = IBinderPool.Stub.asInterface(service)方法，由上一章的分析可知，这里的mBinderPool实际上是IBinderPool的一个代理对象，即此时客户端获得了服务端Binder连接池的一个代理对象。

接着，最后执行了mConnectBinderPoolCountDownLatch.countDown()方法，此时，执行bindService()的线程就会被唤醒。

⑥private IBinder.DeathRecipient mBinderPoolDeathRecipient = new IBinder.DeathRecipient(){}：为IBinder设置死亡监听，如果连接意外中断，会自动重新连接。

⑦public static class BinderPoolImpl extends IBinderPool.Stub{} :这个类实现了IBinderPool.Stub，内部实现了IBinderPool的接口方法，这个实现类运行在服务端。内部是queryBinder()方法的实现，根据不同的Bindercode值来实例化不同的实现类，比如Speak或者Calculate，并作为Binder返回给客户端。当客户端调用这个方法的时候，实际上已经是进行了一次AIDL方式的跨进程通信。

5、分析完BinderPool代码，最后，我们实现客户端代码：

package com.chenyu.binderpool;import android.app.Activity;import android.os.*;import android.util.Log;import com.chenyu.service.BinderPool;import com.chenyu.service.Calculate;import com.chenyu.service.ICalculate;import com.chenyu.service.ISpeak;import com.chenyu.service.Speak;public class MainActivity extends Activity {    private ISpeak mSpeak;    private ICalculate mCalculate;    private int pid = android.os.Process.myPid();    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        new Thread(new Runnable() {            @Override            public void run() {                startWork();            }        }).start();    }    private void startWork() {        Log.d("cylog","当前进程ID为："+pid);        Log.d("cylog","获取BinderPool对象............");        BinderPool binderPool = BinderPool.getInsance(MainActivity.this);     // 1        Log.d("cylog","获取speakBinder对象...........");        IBinder speakBinder = binderPool.queryBinder(BinderPool.BINDER_SPEAK);  // 2        Log.d("cylog","获取speak的代理对象............");        mSpeak = (ISpeak) ISpeak.Stub.asInterface(speakBinder);    // 3         try {            mSpeak.speak();     // 4        } catch (RemoteException e) {            e.printStackTrace();        }        Log.d("cylog","获取calculateBinder对象...........");        IBinder calculateBinder = binderPool.queryBinder(BinderPool.BINDER_CALCULATE);        Log.d("cylog","获取calculate的代理对象............");        mCalculate = (ICalculate) ICalculate.Stub.asInterface(calculateBinder);        try {            Log.d("cylog",""+mCalculate.add(5,6));        } catch (RemoteException e) {            e.printStackTrace();        }    }}

由于跨进程通信是耗时操作，这里利用了子线程来进行绑定以及请求等操作。这里简单分析一下从子线程开始，整个跨进程通讯流程是怎样的：
首先，在①处，调用了BinderPool的getInstance()方法，在里面执行了绑定服务的操作，此时得到的binderPool是BinderPool对象。接着执行②号代码，调用BinderPool对象的queryBinder()方法，此时发生了AIDL跨进程请求，得到服务端返回的特定的IBinder对象。接着执行③号代码，调用ISpeak.Stub.asInterface(IBinder iBinder)方法，把刚才获得的IBinder对象传递进去，此时返回了Speak的Proxy代理对象。最后执行④号代码，调用代理对象mSpeak的speak()方法，此时再次发生了AIDL跨进程请求，调用了服务端Speak类的speak方法。

我们看一下运行结果：

三、总结

最后总结一下使用Binder连接池的流程：

（1）为每个业务模块创建AIDL接口，以及实现其接口的方法。

（2）创建IBinderPool.aidl文件，定义queryBinder(int BinderCode)方法，客户端通过调用该方法返回特定的Binder对象。

（3）创建BinderPoolService服务端，在onBind方法返回实例化的BinderPool.IBinderPoolImpl对象。

（4）创建BinderPool类，在该类实现客户端与服务端的连接，解决线程同步的问题，设置Binder的死亡代理等。在onServiceConnected()方法内，获取到IBinderPool的代理对象。此外，IBinderPool的实现类：IBinderPoolImpl是BinderPool的内部类，实现了IBinderPool.aidl的方法：queryBinder()。

更多相关文章

随机推荐