通常情况下，如果两个对象能够直接相互访问，那么这两个对象存在于同一个内存空间中。如果两个对象分别存在于两个不同的进程的时候，那么这两个对象是不能相互访问的，这个时候就需要使用跨进程通信的技术了。而Android是基于Linux系统的，Linux传统的跨进程技术主要是Socket，信号量，管道，消息队列等，但是这些技术都有不同的缺点，如Socket开销大效率不高，管道和消息队列拷贝次数多，而对于Android系统来讲，更重要的是安全性要高，而这些技术安全性都不是很高，大部分情况下接收方并不能得到发送发进程的PID/UID，很难识别身份。所以Android系统就设计出了Binder跨进程通信机制，来保证传输性能和安全性。

Binder

Binder主要模块

BinderDriver

存在于内核空间中，以字符设备的misc类型注册，用户可以从/dev/binder设备文件节点上，通过open和ioctl文件操作函数与BinderDriver进行通信，主要是负责Binder通信的建立，进程间的传递、Binder引用计数管理/数据包的管理。
BinderClient

存在于用户空间中，它和BinderServer的跨进程通信都是通过BinderDriver来处理转发的。对于BinderClient只需要知道自己需要使用的Binder的名字和该Binder在ServerManager中的0号引用就可以了。通过0号引用去访问ServerManager获取Binder的引用，得到引用后就可以直接调用Binder的方法了。
ServerManager

存在于用户空间中，用来管理BinderServer，BinderClient可以通过它来查询BinderServer接口，查询到之后就可以获取到Binder的映射。
BinderServer

BinderServer会生成一个Binder实体，并会给Binder绑定一个名字，最终封装成一个数据包传递给BinderDriver，BinderDriver在获取到这个数据包之后，如果发现这个数据包是新传递过来的，就会给其在内核空间中创建相应的Binder实体节点和对应的实体节点的引用。 BinderDriver会将Binder的引用传递给ServerManager，ServerManager收到后就会取出Binder的名字和引用插入一张数据表中，这个就和DNS存储域名到IP的映射原理一样。

系统如何使用Binder

在客户端中ServerManager的接口定义主要是在IServiceManager中：

public interface IServiceManager extends IInterface
{
    /**
     * Retrieve an existing service called @a name from the
     * service manager.  Blocks for a few seconds waiting for it to be
     * published if it does not already exist.
     */
    public IBinder getService(String name) throws RemoteException;
    
    /**
     * Retrieve an existing service called @a name from the
     * service manager.  Non-blocking.
     */
    public IBinder checkService(String name) throws RemoteException;

    /**
     * Place a new @a service called @a name into the service
     * manager.
     */
    public void addService(String name, IBinder service, boolean allowIsolated)
                throws RemoteException;

    /**
     * Return a list of all currently running services.
     */
    public String[] listServices() throws RemoteException;

    /**
     * Assign a permission controller to the service manager.  After set, this
     * interface is checked before any services are added.
     */
    public void setPermissionController(IPermissionController controller)
            throws RemoteException;
    
    static final String descriptor = "android.os.IServiceManager";

    int GET_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION;
    int CHECK_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+1;
    int ADD_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+2;
    int LIST_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+3;
    int CHECK_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+4;
    int SET_PERMISSION_CONTROLLER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+5;
}

可以看到IServiceManager定义的方法主要是添加，获取，检查等关于各种服务。主要作用其实就是像上面所说的简单的将Binder以字符表示的名字转换成引用。而对于BinderClient的实现其实就是ServiceManagerNative和ServiceManagerProxy，这两个类实现了该接口，我们在AIDL的时候在分析。

AIDL

我们以具体的例子来分析，首先我们创建相关aidl文件：

// Book.java
public class Book implements Parcelable {
    public int bookId;
    public String bookName;

    protected Book(Parcel in) {
        bookId = in.readInt();
        bookName = in.readString();
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(bookId);
        dest.writeString(bookName);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };
}

// Book.aidl
package com.fastaoe.proficient;
parcelable Book;

// IBookManager.aidl
package com.fastaoe.proficient;

import com.fastaoe.proficient.Book;

interface IBookManager {
    List<Book> getBookList();
    void addBook(in Book book);
}

上面3个文件，Book.java表示图书信息，实现了Parcelable接口。 Book.aidl是Book.java在AIDL中的声明。 IBookManager是定义了用来操作Book的方法，getBookList从服务器中获取图书列表，addBook向服务器图书列表中插入一本新书。当我们声明好了AIDL之后，IDE编译好之后，就生成了IBookManager.java这个类。

public interface IBookManager extends android.os.IInterface {
    // 代码省略，下面在分析
}

可以看到这个系统为我们生成的类，实现了IInterface这个接口，自己本身也是一个接口，我们可以实现这个接口来实现相关的方法。我们来具体分析下这个生成的接口：

private static final java.lang.String DESCRIPTOR = "com.fastaoe.proficient.IBookManager";

Binder的唯一标识，一般情况下使用当前的类来表示。

public static com.fastaoe.proficient.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.fastaoe.proficient.IBookManager))) {
                return ((com.fastaoe.proficient.IBookManager) iin);
            }
            return new com.fastaoe.proficient.IBookManager.Stub.Proxy(obj);
        }

用来将服务器中的Binder对象转换成客户端中所需要的AIDL接口类型的对象。可以看到当客户端和服务端在同一个进程的时候，返回的就是服务端的Stub本身，如果不在同一个进程，返回的是系统封装好的Stub.proxy对象，这表示当不在同一个进程的时候，客户端拿到的其实不是服务端Binder本身，而是一个副本。

public android.os.IBinder asBinder() {
            return this;
        }

返回Binder对象本身。

public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
       switch (code) {
           case INTERFACE_TRANSACTION: {
               reply.writeString(DESCRIPTOR);
               return true;
           }
           case TRANSACTION_getBookList: {
               data.enforceInterface(DESCRIPTOR);
               java.util.List<com.fastaoe.proficient.Book> _result = this.getBookList();
               reply.writeNoException();
               reply.writeTypedList(_result);
               return true;
           }
           case TRANSACTION_addBook: {
               data.enforceInterface(DESCRIPTOR);
               com.fastaoe.proficient.Book _arg0;
               if ((0 != data.readInt())) {
                   _arg0 = com.fastaoe.proficient.Book.CREATOR.createFromParcel(data);
               } else {
                   _arg0 = null;
               }
               this.addBook(_arg0);
               reply.writeNoException();
               return true;
           }
       }
       return super.onTransact(code, data, reply, flags);
   }

这个方法运行在服务器端的Binder线程池中，当客户端发起跨进程的请求的时候，请求会通过底层封装之后交给此方法执行。服务器端通过code来判断客户端请求的方法是什么，接着从data中获取目标方法所需要的数据，并执行目标方法。当方法执行完之后通过reply写入返回值，最后返回是否成功，如果成功返回true，否则则是false失败。

private static class Proxy implements com.fastaoe.proficient.IBookManager {
       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 java.util.List<com.fastaoe.proficient.Book> getBookList() throws android.os.RemoteException {
           android.os.Parcel _data = android.os.Parcel.obtain();
           android.os.Parcel _reply = android.os.Parcel.obtain();
           java.util.List<com.fastaoe.proficient.Book> _result;
           try {
               _data.writeInterfaceToken(DESCRIPTOR);
               mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
               _reply.readException();
               _result = _reply.createTypedArrayList(com.fastaoe.proficient.Book.CREATOR);
           } finally {
               _reply.recycle();
               _data.recycle();
           }
           return _result;
       }

       @Override
       public void addBook(com.fastaoe.proficient.Book book) throws android.os.RemoteException {
           android.os.Parcel _data = android.os.Parcel.obtain();
           android.os.Parcel _reply = android.os.Parcel.obtain();
           try {
               _data.writeInterfaceToken(DESCRIPTOR);
               if ((book != null)) {
                   _data.writeInt(1);
                   book.writeToParcel(_data, 0);
               } else {
                   _data.writeInt(0);
               }
               mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
               _reply.readException();
           } finally {
               _reply.recycle();
               _data.recycle();
           }
       }
   }

这个类运行在客户端中，当客户端调用此方法之后，首先会创建parcel的类型的输入对象_data，输出对象_reply，返回值对象_result（如果有的话），接着通过_data将参数存储起来，在通过transact方法来发送RPC请求，同时线程会被挂起。接着服务端的onTransact方法会调用，最终RPC过程返回后，当前线程继续执行，从_reply获取到返回的结果。

通过AIDL实现跨进程通信（参考《Android开发艺术探索第二章例子》）

我们把AIDL生成的类分析完之后，就来实现一个服务器和客户端通信的例子吧。

首先定义AIDL文件，就是上面图书的例子

其中需要注意的是：

AIDL支持的数据类型：

基本数据类型
String和CharSequence
ArrayList和HashMap
Parcelable
AIDL本身

当我们自定义了Parcelable的时候，必须新建一个同名的.aidl文件，并将其声明为parcelable类型。 AIDL中所有的实现了Parcelabe接口的类都需要声明相对应的aidl文件，并且需要标识in(输入)、out(输出)、inout(输入输出)。

服务端的实现

public class ServerService extends Service {
    
   private CopyOnWriteArrayList<Book> list = new CopyOnWriteArrayList<>();
   private RemoteCallbackList<IAddBookListener> listeners = new RemoteCallbackList<>();
    
   @Override
   public void onCreate() {
       super.onCreate();
       list.add(new Book(1, "岛上书店"));
       list.add(new Book(2, "白夜行"));
   }
    
   @Nullable
   @Override
   public IBinder onBind(Intent intent) {
       return binder;
   }
    
   private IBinder binder = new IBookManager.Stub(){
    
       @Override
       public List<Book> getListBook() throws RemoteException {
           return list;
       }
    
       @Override
       public void addBook(Book book) throws RemoteException {
           onNewBookAdd(book);
       }
    
       @Override
       public void registerListener(IAddBookListener listener) throws RemoteException {
           listeners.register(listener);
       }
    
       @Override
       public void unregisterListener(IAddBookListener listener) throws RemoteException {
           listeners.unregister(listener);
       }
   };
    
   private void onNewBookAdd(Book book) throws RemoteException {
       list.add(book);
       int N = listeners.beginBroadcast();
       for (int i = 0; i < N; i++) {
           IAddBookListener broadcastItem = listeners.getBroadcastItem(i);
           broadcastItem.OnNewBookAddListener(book);
       }
       listeners.finishBroadcast();
   }
}

在服务端中我们首先初始化了图书列表，并创建了Binder对象并在onBind中返回。

使用了CopyOnWriteArrayList，这个List是支持并发读写的，因为当多个客户端同时连接的时候，会出现多个线程同时访问的问题，所以需要在AIDL中处理线程问题。
使用RemoteCallbackList来管理跨进程的listener接口，因为如果使用List的话，并不能在unregister的时候删除掉当前listener接口，虽然我们使用的看上去是同一个listener，但是其实并不是同一个对象。

客户端和服务端在多进程的环境中，而对象是不可能在多进程下传递的，所以Binder会将客户端传递过来的对象重新转化成新的对象，并不是原来的对象，这其实是反序列化的过程，所以AIDL中的自定义对象必须实现Parcelable接口。

那么怎么解除注册呢？

可以通过RemoteCallbackList，RemoteCallbackList是系统专门提供用来删除跨进程listener的接口，在它的内部有一个Map用来保存所有的AIDL回调，key是IBinder，value是callback。虽然在跨进程的环境中，生成的对象不是同一个对象，但是它们底层的Binder肯定是同一个，所以可以利用这个来实现解除注册。当客户端要解除注册的时候，服务端通过RemoteCallbackList找到具有相同Binder对象的服务端listener并将其删除。

客户端实现

public class MainActivity extends AppCompatActivity {
    
   private List<Book> list = new ArrayList<>();
    
   private int index = 3;
    
   Handler handler = new Handler(){
       @Override
       public void handleMessage(Message msg) {
           switch (msg.what) {
               case 1:
                   list.add((Book) msg.obj);
                   tv_book.setText(list.toString());
                   break;
    
           }
       }
   };
    
   private ServiceConnection conn = new ServiceConnection() {
       @Override
       public void onServiceConnected(ComponentName name, IBinder service) {
           iBookManager = IBookManager.Stub.asInterface(service);
           try {
               iBookManager.registerListener(listener);
           } catch (RemoteException e) {
               e.printStackTrace();
           }
       }
    
       @Override
       public void onServiceDisconnected(ComponentName name) {
           iBookManager = null;
       }
   };
    
   private IBookManager iBookManager;
   private IAddBookListener listener = new IAddBookListener.Stub() {
       @Override
       public void OnNewBookAddListener(Book book) throws RemoteException {
           handler.obtainMessage(1, book).sendToTarget();
       }
   };
   private Button btn_search;
   private Button btn_add;
   private TextView tv_book;
    
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
    
       btn_search = (Button) findViewById(R.id.btn_search);
       btn_add = (Button) findViewById(R.id.btn_add);
       tv_book = (TextView) findViewById(R.id.tv_book);
    
       btn_search.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               if (iBookManager != null) {
                   try {
                       // TODO: 2017/7/9 放在子线程中 
                       list = iBookManager.getListBook();
                   } catch (RemoteException e) {
                       e.printStackTrace();
                   }
                   tv_book.setText(list.toString());
               }
           }
       });
    
       btn_add.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               if (iBookManager != null) {
                   Book book = new Book(index, "图书"+ index);
                   index += 1;
                   try {
                       // TODO: 2017/7/9 放在子线程中 
                       iBookManager.addBook(book);
                   } catch (RemoteException e) {
                       e.printStackTrace();
                   }
               }
           }
       });
    
       Intent intent = new Intent();
       intent.setAction("com.fastaoe.server.ServerService");
       intent.setComponent(new ComponentName("com.fastaoe.server", "com.fastaoe.server.ServerService"));
       bindService(intent, conn, Context.BIND_AUTO_CREATE);
   }
    
   @Override
   protected void onDestroy() {
       try {
           iBookManager.unregisterListener(listener);
       } catch (RemoteException e) {
           e.printStackTrace();
       }
       unbindService(conn);
       super.onDestroy();
   }
}

首先绑定远程服务，接着将远程服务返回的Binder对象转换成AIDL接口，接着就可以调用服务端中的方法了。

需要注意的是如果aidl中的方法在服务端是耗时的操作的时候，需要处理，不然会导致ANR的产生，同样的当服务端调用客户端的耗时操作的时候，也需要保证在服务端的方法运行在非UI线程，因为Service本身是运行在UI线程中的。
OnNewBookAddListener运行在Binder线程池中，所以不能在其中访问UI相关的内容，如果需要访问的话，则需要通过Handler切换线程。
Binder在连接过程中是可能意外死亡的，主要是因为服务端的进程被终止了，所以我们需要重新连接服务。
1. 可以通过在onServiceDisconnected中重连。
2. 也可以通过DeathRecipient来监听是否被断开。

具体的Demo可以查看AIDL的简单实现