1. Binder是什么
Android 中有很多使用跨进程通信（IPC）的场景，在IPC机制的几种方法中，AIDL，Messenger，ContentProvider，这些机制底层全部都是用了Binder机制来实现的，那么什么是Binder？
Binder中文即粘合剂，意思为粘合了两个不同的进程。
对于Binder的定义，在不同场景下其定义不同!
image
2. 相关基础知识
2.1 进程空间分配
- 一个进程空间分为 用户空间 & 内核空间（Kernel），即把进程内 用户 & 内核 隔离开来
- 二者区别：
- 进程间，用户空间的数据不可共享，所以用户空间 = 不可共享空间
- 进程间，内核空间的数据可共享，所以内核空间 = 可共享空间
- 进程内 用户 与 内核 进行交互 称为系统调用
image
2.2进程隔离与进程间通信
android中，一个进程是不能直接操作访问另一个进程的，即Android的进程是相互独立、隔离的。
但是有的时候，隔离的进程又需要进行交互，这就是跨进程通信（IPC）
- 跨进程间通信的原理
- 先通过 进程间 的内核空间进行 数据交互
- 再通过 进程内 的用户空间 & 内核空间进行 数据交互，从而实现 进程间的用户空间 的数据交互
image
而Binder，就是充当连接两个进程（内核空间）的通道。
3.Binder跨进程通信机制
-
Binder跨进程通信机制是基于 Client-Server模式
image
在这个通信模型中，这其中的四个角色到底是怎么交互来完成Client与Server的通信的呢？
过程：
- Server注册服务
- Server进程向Binder驱动发起注册服务请求
- Binder驱动将注册请求转发给ServiceManager进程
- ServiceManager进程添加该Server进程，即注册了服务
此时，ServiceManager进程拥有了Server进程的信息
- Client获取服务
- Client向Binder驱动发起获取服务请求，传递需要获取的服务名称
- Binder驱动将该请求转发给ServiceManager进程
- ServiceManager进程查找到Client需要的Server对应的服务信息
- 通过Binder驱动将上述服务信息返回给Client进程（==注意此时返回的Server信息并不是真正的Server信息，是经过了一层包装的，下面讲==）
此时，Client进程与Server进程的已经建立了联系
- 使用服务方法
- Client 进程将需要传送的数据放入到Client的共享内存中（此时，当前线程被挂起）
- Binder驱动从Client共享内存中读取数据，并查询ServiceManager进程里面的Server信息找到对应的Server进程
- Binder驱动把上述数据拷贝到Server进程的共享内存中，并通知Server 进程处理。
- Server进程收到通知后，从线程池中取出线程，进行数据处理调用方法等操作
- Server进程将最终执行的结果写入到自己的共享内存中
- Binder驱动将最终数据拷贝到Client进程的共享内存中，
- 通知Client进程拿结果（此时之前被挂起的线程重新被唤醒）
我们上面说过Client进程去获取Server进程信息时返回的不是真正的Server进程对象，而是经过包装的Server代理对象。Client进程去调用服务方法使用服务时，也是先调用的代理对象的方法，然后代理对象拿到参数之后放入内存发送给Binder驱动。
image
一句话总结就是：Client进程只不过是持有了Server端的代理；代理对象协助驱动完成了跨进程通信。
4.Binder在Android中的具体实现原理
- 实例说明：Client进程 需要调用 Server进程的添加函数和查询函数
步骤1：注册服务
- 过程描述Server进程 通过Binder驱动 向 Service Manager进程 注册服务
- 代码实现
- 首先需要声明一个AIDL文件
/* AIDL 文件*/
package com.example.service;
// Declare any non-default types here with import statements
import com.example.service.Book;
interface IBookManager {
List<Book> getBookList();
void addBook(in Book book);
}
- 通过AIDL，可以让本地调用远程服务器的接口就像调用本地接口那么接单，真正内部的实现细节，可以参考看系统给我们生成的IBookManager实现类。
/** 系统生成的binder 类*/
public interface IBookManager extends android.os.IInterface { //所有在Binder中传输的接口都需要实现android.os.IInterface
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.example.service.IBookManager {
//DESCRIPTOR 当前Binder的唯一标识
private static final java.lang.String DESCRIPTOR = "com.example.service.IBookManager";
/** Construct the stub at attach it to the interface. */
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.example.service.IBookManager interface,
* generating a proxy if needed.
* 用于将服务端的Binder对象转换成客户端所需的AIDL接口类型的对象
* 如果客户端和服务端在同一个进程，则返回stub对象，否则返回stub.proxy对像，
*/
public static com.example.service.IBookManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.example.service.IBookManager))) {
return ((com.example.service.IBookManager) iin);
}
return new com.example.service.IBookManager.Stub.Proxy(obj);
}
/**
* 用于返回当前Binder的对象
* @return
*/
@Override
public android.os.IBinder asBinder() {
return this;
}
/**
* 该方法运行在服务端的binder线程池中，当客户端发起跨进程请求的时候，远程请求会通过系统底层封装后交由此方法处理
* @param code 服务端通过code 可以确定客户端所请求的目标方法是什么
* @param data 服务端从data从取出目标方法所需的参数，然后执行目标方法
* @param reply 目标方法执行完毕后，向reply中写入返回值（如果目标方法有返回值的话）
* @param flags
* @return 如果此方法返回false，则客户端请求失败，我们可以通过这个特性做权限处理
* @throws android.os.RemoteException
*/
@Override
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.example.service.Book> _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addBook: {
data.enforceInterface(DESCRIPTOR);
com.example.service.Book _arg0;
if ((0 != data.readInt())) {
_arg0 = com.example.service.Book.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.example.service.IBookManager {
//这里面的方法，是运行在客户端的，当客户端调用里面的方法时，会先创建该方法所需的输入型对象，输出型对象和返回值对象（如果有返回值的话）
//然后把该方法的参数信息写入——data中，然后调用transact方法来发送RPC请求（远程过程调用） ，同时当前线程挂起，然后服务端的onTransact方法会调用，
//直到RPC过程返回，当前线程继续执行，并从 _reply中取出返回结果返回数据。所以不能调用耗时的远程方法
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.example.service.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.example.service.Book> _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.example.service.Book.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void addBook(com.example.service.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();
}
}
}
static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_registerListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
static final int TRANSACTION_unregisterListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
}
public java.util.List<com.example.service.Book> getBookList() throws android.os.RemoteException;
public void addBook(com.example.service.Book book) throws android.os.RemoteException;
}
-
这就是核心的处理逻辑，总结出来就如下图：
image
5. 优点
对比 Linux （Android基于Linux）上的其他进程通信方式（管道/消息队列/共享内存/信号量/Socket），Binder 机制的优点有：
-
高效
- Binder数据拷贝只需要一次，而管道、消息队列、Socket都需要2次
- 通过驱动在内核空间拷贝数据，不需要额外的同步处理
-
安全性高
Binder 机制为每个进程分配了 UID/PID 来作为鉴别身份的标示，并且在 Binder 通信时会根据 UID/PID 进行有效性检测
传统的进程通信方式对于通信双方的身份并没有做出严格的验证如，Socket通信 ip地址是客户端手动填入，容易出现伪造
-
使用简单
- 采用Client/Server 架构
- 实现面向对象的调用方式，即在使用Binder时就和调用一个本地对象实例一样
