IPC机制之Binder连接池

Posted 2021-04-06 帝都小崔Cayden

AIDL典型的使用流程

      首先是创建一个Service和一个AIDL接口,接着创建一个类继承自AIDL接口中的Stub 并实现Stub中的抽象方法，在Service的onBind方法返回这个类的对象,然后客户端就可以绑定服务端的Service，建立连接之后可以访问远程服务端的方法.

Binder连接池

       但是如果公司的项目越来越大，有很多个业务模块需要使用AIDL来进行进程间通信，如果按照之前的就需要创建多个service,但是service是系统四大组件之一，过多使用会造成性能资源消耗。 因此，这个时候有必要使用Binder连接池。
流程大致是：
每个业务模块创建自己的AIDL接口并实现此接口，这个时候不同业务模块之间不能有耦合的，所有实现细节我们要单独开来，然后向服务端提供一个属于自己的key和其对应的对象；那么服务端只需要一个Service然后提供一个查询的queryBinder接口，然后根据业务模块来返回对应的Binder。工作原理如图所示

Binder连接池的工作原理

具体可以通过代码来实现一下。

Example代码

新建AIDL ISecurityCenter

声明如下

// ISecurityCenter.aidl
package com.cayden.collect.study.binder;

// Declare any non-default types here with import statements

interface ISecurityCenter {
    String encrypt(String content);
    String decrypt(String password);
}

再新建一个提供计算的AIDL ICompute

// ICompute.aidl
package com.cayden.collect.study.binder;

// Declare any non-default types here with import statements

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

然后需要build工程 再对上面2个AIDL接口做具体的实现操作

package com.cayden.collect.study.binder;

import android.os.RemoteException;

/**
 * Created by cuiran
 * Time  16/9/18 14:24
 * Email [e-mail]
 * Description
 */
public class SecurityCenterImpl extends ISecurityCenter.Stub {

    private static  final  char SECRET_CODE='^';

    @Override
    public String encrypt(String content) throws RemoteException {
        char[] chars=content.toCharArray();
        for(int i=0;i<chars.length;i++){
            chars[i]^=SECRET_CODE;
        }
        return new String(chars);
    }

    @Override
    public String decrypt(String password) throws RemoteException {
        return encrypt(password);
    }
}

package com.cayden.collect.study.binder;

import android.os.RemoteException;

/**
 * Created by cuiran
 * Time  16/9/18 14:28
 * Email [e-mail]
 * Description
 */
public class ComputeImpl extends ICompute.Stub {
    @Override
    public int add(int a, int b) throws RemoteException {
        return a+b;
    }
}

接着需要为连接池创建一个AIDL接口 IBinderPool

// IBinderPool.aidl
package com.cayden.collect.study.binder;

// Declare any non-default types here with import statements

interface IBinderPool {
    IBinder queryBinder(int binderCode);
}

然后创建连接池

package com.cayden.collect.study.binder;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

import java.util.concurrent.CountDownLatch;


/**
 * Created by cuiran
 * Time  16/9/18 14:36
 * Email [e-mail]
 * Description
 */
public class BinderPool {

    private static final String TAG="BinderPool";
    public static final int BINDER_NONE=-1;
    public static final int BINDER_COMPUTE=0;
    public static final int BINDER_SECRITY_CENTER=1;

    private Context mContext;

    private IBinderPool mBinderPool;
    private static volatile BinderPool sInstance;
    private CountDownLatch mCountDownLatch;

    private BinderPool(Context context){
        mContext=context.getApplicationContext();
        connectBinderPoolService();
    }

    public static BinderPool getInstance(Context context){
        if(sInstance==null){
            synchronized (BinderPool.class){
                if(sInstance==null){
                    sInstance=new BinderPool(context);
                }
            }
        }
        return sInstance;
    }

    private synchronized void connectBinderPoolService(){
        mCountDownLatch=new CountDownLatch(1);
        Intent service=new Intent(mContext,BinderPoolService.class);
        mContext.bindService(service,mBinderPoolConnection,Context.BIND_AUTO_CREATE);
        try{
            mCountDownLatch.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    public IBinder queryBinder(int binderCode){
        IBinder binder=null;
        try{
            if(mBinderPool!=null){
                binder=mBinderPool.queryBinder(binderCode);
            }
        }catch (RemoteException e){
            e.printStackTrace();
        }
        return binder;
    }

    private ServiceConnection mBinderPoolConnection=new ServiceConnection() {
         @Override
         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                  mBinderPool=IBinderPool.Stub.asInterface(iBinder);
             try{
                 mBinderPool.asBinder().linkToDeath(mBinderPoolDeathRecipient,0);
             }catch (RemoteException e){
                 e.printStackTrace();
             }
             mCountDownLatch.countDown();
         }

         @Override
         public void onServiceDisconnected(ComponentName componentName) {

         }
     };





    private IBinder.DeathRecipient mBinderPoolDeathRecipient=new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            Log.d(TAG,"binder died");
            mBinderPool.asBinder().unlinkToDeath(mBinderPoolDeathRecipient,0);
            mBinderPool=null;
            connectBinderPoolService();

        }
    };

  public static class  BinderPoolImpl extends IBinderPool.Stub{
      public BinderPoolImpl(){
          super();
      }

      @Override
      public IBinder queryBinder(int binderCode) throws RemoteException {
          IBinder binder=null;
          switch (binderCode){
              case BINDER_SECRITY_CENTER:{
                  binder=new SecurityCenterImpl();
                  break;
              }
              case BINDER_COMPUTE:{
                  binder=new ComputeImpl();
                  break;
              }
              default:

                  break;
          }
          return binder;
      }
  }
}

接着需要实现远程service

package com.cayden.collect.study.binder;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.support.annotation.Nullable;

/**
 * Created by cuiran
 * Time  16/9/18 14:33
 * Email [e-mail]
 * Description
 */
public class BinderPoolService extends Service {

    private static final String TAG="BinderPoolService";

    private Binder mBinderPool=new BinderPool.BinderPoolImpl();


    @Override
    public void onCreate() {
        super.onCreate();
    }

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

    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

最后执行 验证一下

需要在Activity的线程里面调用方法

 ISecurityCenter securityCenter;
    ICompute mCompute;
    private void doWork(){
        Log.d(TAG,"doWork.......");
        BinderPool binderPool=BinderPool.getInstance(getActivity());
        IBinder securityBinder=binderPool.queryBinder(BinderPool.BINDER_SECRITY_CENTER);
        securityCenter=(ISecurityCenter) SecurityCenterImpl.asInterface(securityBinder);

        Log.d(TAG,"访问ISecurityCenter");
        String msg="HelloWorld ,I'm cayden";
        Log.d(TAG,"content="+msg);
        try {
            String password=securityCenter.encrypt(msg);
            Log.d(TAG,"password="+password);
            Log.d(TAG,"decrypt="+securityCenter.decrypt(password));
        }catch (Exception e){
            e.printStackTrace();
        }


        Log.d(TAG,"访问ICompute");
        IBinder computeBinder=binderPool.queryBinder(BinderPool.BINDER_COMPUTE);
        mCompute=(ICompute) ComputeImpl.asInterface(computeBinder);
        try {
            Log.d(TAG,"3+5="+mCompute.add(3,5));
        }catch (Exception e){
            e.printStackTrace();
        }
    }

执行结果如下

09-19 11:46:56.080 7923-9643/com.cayden.collect D/MessengerFragment: doWork.......
09-19 11:46:56.132 7923-9643/com.cayden.collect D/MessengerFragment: 访问ISecurityCenter
09-19 11:46:56.132 7923-9643/com.cayden.collect D/MessengerFragment: content=HelloWorld ,I'm cayden
09-19 11:46:56.132 7923-9643/com.cayden.collect D/MessengerFragment: password=;221    1,2:~ry3~=?':;0
09-19 11:46:56.132 7923-9643/com.cayden.collect D/MessengerFragment: decrypt=HelloWorld ,I'm cayden
09-19 11:46:56.132 7923-9643/com.cayden.collect D/MessengerFragment: 访问ICompute
09-19 11:46:56.136 7923-9643/com.cayden.collect D/MessengerFragment: 3+5=8

这样Binder的连接池的demo版就结束了

https://github.com/cayden/AndroidCollect.git