Android Framework 学习（四）：Binder机制与代理模式

Binder是Android的进程间通信核心，Android的各种核心服务都是通过Binder机制进行相互通信的。熟悉Binder机制话就会知道，Binder的client部分就是通过代理模式来访问Server端的。本文我们就结合代理模式来详细讲解一下Java层Binder机制。

一、代理模式介绍

相信大家对设计模式都有一定的了解，这里我就不对代理模式进行过多的赘述了。这里我们只在阐释一下代理模式的使用场景：

远程代理(Remote Proxy)：如果某个对象无法实例化，不在同一个地址空间，需要通过编码来进行通信。比如需要访问网络服务器上面的一个对象操作，比如Binder。
虚代理(Virtual Proxy)：在需要的时候创建大对象，比如超大图片，我们可以使用一个虚代理代理图像，在真正需要的时候再去将图像完全加载出来，在这之前只需要在代理里面保存图像的大小，让它有个占位就好了。
保护代理(Protect Proxy)：需要对对象的某些操作进行隐藏，那么就可以使用代理对它的接口进行隐藏。
智能指引(Smart Reference)：当需要对对象的引用进行计数的时候，可以使用智能指引的代理模式。

二、Binder机制

Binder是一个接口形式的IPC。这里以Android开发过程中使用的.aidl文件声明生成的接口为例。

例如，我们在Client端声明了一个IUserVerifyInterface.aidl，用于向服务端发起用户校验：

// IUserVerifyInterface.aidl
package com.renhui.aidl;
import com.renhui.aidl.User;
// Declare any non-default types here with import statements

interface IUserVerifyInterface {

    boolean verifyUser(in User user);

}

在编译运行之前，编辑器会自动生成相关的类 IUserVerifyInterface.Stub 和 IUserVerifyInterface.Proxy，通过调用bindService就可以得到Binder的代理。

bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE); 
...
private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.w(TAG, "onServiceConnected: success ");
            userVerifyInterface = IUserVerifyInterface.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.w(TAG, "onServiceDisConnected! ");
            unbindService(serviceConnection);
        }
    };

访问查看一下asInterface方法的内容，我们就可以看到内部就是创建了一个Proxy对象

    /**
     * Cast an IBinder object into an com.renhui.aidl.IUserVerifyInterface interface,
     * generating a proxy if needed.
     */
    public static com.renhui.aidl.IUserVerifyInterface asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.renhui.aidl.IUserVerifyInterface))) {
        return ((com.renhui.aidl.IUserVerifyInterface)iin);
      }
      return new com.renhui.aidl.IUserVerifyInterface.Stub.Proxy(obj);
    }

Binder是一个非常典型的代理模式，是一种远程代理，实际上Proxy代理的是另外一个进程中的Stub对象。内部是将接口函数标记为对应的ID，然后根据这个ID来标识目前调用的是哪一个函数。由DESCRIPTOR来作为Token分隔不同的接口调用，另外通过Parcel来写入函数参数和接受函数返回值（Stub端对应接受参数和写入结果）。

  /** Local-side IPC implementation stub class. */
  public static abstract class Stub extends android.os.Binder implements com.renhui.aidl.IUserVerifyInterface
  {
    private static final java.lang.String DESCRIPTOR = "com.renhui.aidl.IUserVerifyInterface";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an com.renhui.aidl.IUserVerifyInterface interface,
     * generating a proxy if needed.
     */
    public static com.renhui.aidl.IUserVerifyInterface asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.renhui.aidl.IUserVerifyInterface))) {
        return ((com.renhui.aidl.IUserVerifyInterface)iin);
      }
      return new com.renhui.aidl.IUserVerifyInterface.Stub.Proxy(obj);
    }
    @Override public android.os.IBinder asBinder()
    {
      return this;
    }
    @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
    {
      java.lang.String descriptor = DESCRIPTOR;
      switch (code)
      {
        case INTERFACE_TRANSACTION:
        {
          reply.writeString(descriptor);
          return true;
        }
        case TRANSACTION_verifyUser:
        {
          data.enforceInterface(descriptor);
          com.renhui.aidl.User _arg0;
          if ((0!=data.readInt())) {
            _arg0 = com.renhui.aidl.User.CREATOR.createFromParcel(data);
          }
          else {
            _arg0 = null;
          }
          boolean _result = this.verifyUser(_arg0);
          reply.writeNoException();
          reply.writeInt(((_result)?(1):(0)));
          return true;
        }
        default:
        {
          return super.onTransact(code, data, reply, flags);
        }
      }
    }
    private static class Proxy implements com.renhui.aidl.IUserVerifyInterface
    {
      private android.os.IBinder mRemote;
      Proxy(android.os.IBinder remote)
      {
        mRemote = remote;
      }
      @Override public android.os.IBinder asBinder()
      {
        return mRemote;
      }
      public java.lang.String getInterfaceDescriptor()
      {
        return DESCRIPTOR;
      }
      @Override public boolean verifyUser(com.renhui.aidl.User user) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        boolean _result;
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          if ((user!=null)) {
            _data.writeInt(1);
            user.writeToParcel(_data, 0);
          }
          else {
            _data.writeInt(0);
          }
          boolean _status = mRemote.transact(Stub.TRANSACTION_verifyUser, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().verifyUser(user);
          }
          _reply.readException();
          _result = (0!=_reply.readInt());
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
      public static com.renhui.aidl.IUserVerifyInterface sDefaultImpl;
    }
    static final int TRANSACTION_verifyUser = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    public static boolean setDefaultImpl(com.renhui.aidl.IUserVerifyInterface impl) {
      if (Stub.Proxy.sDefaultImpl == null && impl != null) {
        Stub.Proxy.sDefaultImpl = impl;
        return true;
      }
      return false;
    }
    public static com.renhui.aidl.IUserVerifyInterface getDefaultImpl() {
      return Stub.Proxy.sDefaultImpl;
    }
  }

可以看出代理模式在Binder机制中可以说是代理模式的经典使用。因为当我们在客户端无法直接访问服务端（因为跨进程，地址空间都不一致）的时候，通过代理模式就能够很轻松的进行访问。　　

补充：

在客户端需要请求服务端的时候，我怎么知道我究竟想要请求哪一个服务端呢？ServiceManager。ServiceManager是保存了所有的Service的fd(驱动文件号)。

通过请求ServiceManager的getService(String name)就可以获取对应的服务。而ServiceManager也是一个服务，它的fd是0,是服务中心管理器。客户端指定name，通过Binder请求ServiceManager，然后得到客户端想要的服务BinderProxy，然后就可以请求服务端了。