Binder连接池

概述

有下面这样一种应用场景：一个Android应用有10个功能模块，供主应用通过aidl调用。按照aidl的标准使用方法，就是创建10个aidl接口并写10个类实现他们，然后创建10个服务，在这10个服务的onBind里面返回接口的实现。那么问题来了，有必要为每个模块都创建一个服务吗？如果有100个模块呢？也要这么创建100个服务吗？

答案是否定的，解决这样一个场景的方法就是Binder连接池。

Binder连接池的结构如下图所示：



BindPoolService是一个通过标准方式建立的远程服务，它只有一个方法：query。这个方法根据传递进去的参数返回对应的IBinder，客户端就可以利用这个IBinder调用不同模块的方法。在这种模式下，系统中只有一个服务在后台运行。

下面就来实现这样一种解决方案。

实现服务端

新建两个模块的aidl接口，并实现之。

// IAddCenter.aidl
package com.example.timothy.binderpoolservice;

interface IAddCenter {
int add(int a, int b);
}

// ISubCenter.aidl
package com.example.timothy.binderpoolservice;

interface ISubCenter {
int sub(int a, int b);
}

// AddCenterImpl.java
public class AddCenterImpl extends IAddCenter.Stub {
@Override
public int add(int a, int b) throws RemoteException {
return a + b;
}
}

// SubCenterImpl.java
public class SubCenterImpl extends ISubCenter.Stub {
@Override
public int sub(int a, int b) throws RemoteException {
return a - b;
}
}

定义IBinderPool接口并实现之。

// IBinderPool.aidl
package com.example.timothy.binderpoolservice;

interface IBinderPool {
IBinder query(int code);
}

// BinderPoolImpl.java
public class BinderPoolImpl extends IBinderPool.Stub {
private static final String TAG = "BinderPoolService";

@Override
public IBinder query(int code) throws RemoteException {
Log.d(TAG, "query() is called, code = " + code);
IBinder binder = null;
switch (code) {
case BinderPoolService.CODE_ADD:
binder = new AddCenterImpl();
break;
case BinderPoolService.CODE_SUB:
binder = new SubCenterImpl();
break;
default:
break;
}
return binder;
}
}

query方法就是根据请求功能模块的代码，返回相应模块的实现。

实现BinderPoolService。

// BinderPoolService.java
public class BinderPoolService extends Service {
private static final String TAG = "BinderPoolService";

// 服务代码
public static final int CODE_ADD = 0;
public static final int CODE_SUB = 1;

private BinderPoolImpl mBinderPoolImp = new BinderPoolImpl();

@Override
public IBinder onBind(Intent intent) {
return mBinderPoolImp;
}
}

配置服务

<service
android:name=".BinderPoolService"
android:enabled="true"
android:exported="true"
android:process=":remote">
<intent-filter>
<action android:name="com.example.timothy.binderpoolservice" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>

实现客户端

复制AIDL接口定义文件

客户端首先要做的是将AIDL文件全部从服务端复制过来。

实现一个BinderPool的管理器

为了操作方便，将所有的BinderPool操作放在同一个类里面。这个类的大体结构和标准的AIDL客户端基本相同。首先要有一个IBinderPool类型的私有变量，然后定义一个ServiceConnection类型的私有变量，并在它的onServiceConnected 方法里面给IBinderPool类型的变量赋值，然后定义一个bindBinderPoolService函数，在里面bingService。完整的代码如下：

public class BinderPoolOp {
private static final String TAG = "BinderPoolClient";

private Context mContext;
private static BinderPoolOp sInstance;
private IBinderPool mBinderPool;
private CountDownLatch mCountDownLatch;

private BinderPoolOp(Context context){
this.mContext = context;
bindBinderPoolService();
}

public static BinderPoolOp getInstance(Context context){
if(sInstance == null){
sInstance = new BinderPoolOp(context);
}
return sInstance;
}

private ServiceConnection mServiceConnection = new ServiceConnection(){
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.d(TAG, "onServiceConnected() is called");
mBinderPool = IBinderPool.Stub.asInterface(service);
try {
mBinderPool.asBinder().linkToDeath(new IBinder.DeathRecipient() {
@Override
public void binderDied() {
mBinderPool.asBinder().unlinkToDeath(this, 0);
mBinderPool = null;
bindBinderPoolService();
}
}, 0);
} catch (RemoteException e) {
e.printStackTrace();
}
mCountDownLatch.countDown();
}

@Override
public void onServiceDisconnected(ComponentName name) {

}
};

private void bindBinderPoolService(){
Log.d(TAG, "bindService() is called");
mCountDownLatch = new CountDownLatch(1);
Intent intent = new Intent("com.example.timothy.binderpoolservice");
intent.setPackage("com.example.timothy.binderpoolservice");
Log.d(TAG, "start to bind service");
mContext.bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
try {
mCountDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
Log.d(TAG, "finish to bind service");
}

public IBinder query(int code){
Log.d(TAG, "query() is called, code = " + code);
IBinder binder = null;
try {
binder = mBinderPool.query(code);
} catch (RemoteException e) {
e.printStackTrace();
}
return binder;
}
}

调用BinderPool管理器

在Activity里面新建一个线程，在线程里面调用管理器的query方法，就能获取相应的模块的IBinder对象，然后就能通过这个对象来调用模块的方法。代码如下：

protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new Thread(new Runnable() {
@Override
public void run() {
doWork();
}
}).start();
}

public void doWork(){
BinderPoolOp mBinderPoolOp = BinderPoolOp.getInstance(MainActivity.this);
int ret1 = 0, ret2 = 0;

IAddCenter adder = IAddCenter.Stub.asInterface(mBinderPoolOp.query(CODE_ADD));
try {
ret1 = adder.add(5, 8);
} catch (RemoteException e) {
e.printStackTrace();
}

ISubCenter subber = ISubCenter.Stub.asInterface(mBinderPoolOp.query(CODE_SUB));

try {
ret2 = subber.sub(5, 8);
} catch (RemoteException e) {
e.printStackTrace();
}
Log.d(TAG, "add ret is :" + ret1);
Log.d(TAG, "sub ret is :" + ret2);
}

运行结果

该程序的运行结果如下：

01-09 08:12:52.699 3852-3882/com.example.timothy.binderpoolclient D/BInderPoolClient: bindService() is called
01-09 08:12:52.699 3852-3882/com.example.timothy.binderpoolclient D/BInderPoolClient: start to bind service
01-09 08:12:52.715 3852-3852/com.example.timothy.binderpoolclient D/BInderPoolClient: onServiceConnected() is called
01-09 08:12:52.717 3852-3882/com.example.timothy.binderpoolclient D/BInderPoolClient: finish to bind service
01-09 08:12:52.717 3852-3882/com.example.timothy.binderpoolclient D/BInderPoolClient: query() is called, code = 0
01-09 08:12:52.721 3852-3882/com.example.timothy.binderpoolclient D/BInderPoolClient: query() is called, code = 1
01-09 08:12:52.727 3852-3882/com.example.timothy.binderpoolclient D/BinderPoolClient: add ret is :13
01-09 08:12:52.727 3852-3882/com.example.timothy.binderpoolclient D/BinderPoolClient: sub ret is :-3

这里有个点需要注意一下：为什么在activity里面要用新建线程来调用BinderPool管理器的方法？

我们可以看到在doWork方法里面，会创建一个BinderPool管理器，而在BinderPool管理器的构造函数里面，调用了bindBinderPoolService方法，这个方法会调用Context的bindService方法。bingService方法是一个异步的方法，它返回了并不代表服务已经绑定上，mBinderPool已经可以用了。只有当ServiceConnection对象的onServiceConnected回调被调用的时候，才代表已经绑定上了。所以，用了一个CountDownLatch做同步。关于耗时这点，我们可以从运行结果中看出:

01-09 08:12:52.699 3852-3882/com.example.timothy.binderpoolclient D/BInderPoolClient: start to bind service
01-09 08:12:52.715 3852-3852/com.example.timothy.binderpoolclient D/BInderPoolClient: onServiceConnected() is called
01-09 08:12:52.717 3852-3882/com.example.timothy.binderpoolclient D/BInderPoolClient: finish to bind service

bindService花费的时间是18ms。

除了绑定的过程，所有的AIDL调用也都是耗时操作，这个和Binder的底层实现有关，所以从性能考虑，AIDL调用都是不适合放在UI线程里面的。