一、 前言

在上一篇文章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()。