Binder是Android中的一个类，她实现了IBinder接口。从IPC角度来说，Binder是客户端和服务端进行通讯的媒介！（PS：在Android系统有两个不同的进程，请求数据的进程为客户端，接收请求的进程为服务端）
Service与Binder之间的关系
Android开发中，Binder主要用在Service：
- 同一个进程bindService
- Messenger发送Message
- 通过AIDL跨进程bindService
第一种bindService在ServiceConnection中的onServiceConnected(ComponentName name, IBinder service)的service是绑定的Service自身，这就可以直接调用Service中的方法，没有涉及Binder核心功能。第二种Messenger发送Message底层其实是封装AIDL，所以我们用AIDL来分析Binder的工作原理。
AIDL进行IPC
- 创建AIDL文件
- User.aidl
由于User类无法在AIDL中直接使用，所以要创建User.aidl对User.java进行描述package com.hk.b.aidl; parcelable User;- IUserManager.aidl
AIDL不同于Java，即使两个aidl文件处于同一个包下，也要对引用进行importpackage com.hk.b.aidl; import com.hk.b.aidl.User; interface IUserManager { ListgetUserList(); void addUser(in User u); }
2.使用.aidl文件生成的.java文件
定义好aidl文件后，系统会自动在Android Studio的ProjectName/ModuleName/build/generated/source/com.hk.b.aidl/IUserManager.java,可以直接在Service中使用这个类，这个类的内容是Binder原理的关键，稍后解析。
public class UserService extends Service {
private CopyOnWriteArrayList mUserList = new CopyOnWriteArrayList<>();
public UserService() {
}
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
private IBinder mBinder = new IUserManager.Stub() {
@Override
public List getUserList() throws RemoteException {
Log.d("hvcker","server getUsers");
return mUserList;
}
@Override
public void addUser(User u) throws RemoteException {
Log.d("hvcker","server add");
mUserList.add(u);
}
};
}
另外这个Service在AndroidManifest.xml文件中要配置使该Service运行在新的进程中，这样才能达到IPC
3.客户端绑定服务端
-
定义一个IUserManager变量
private IUserManager mUserManager; -
定义一个ServiceConnection
private ServiceConnection mConn = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { mUserManager = IUserManager.Stub.asInterface(service); } @Override public void onServiceDisconnected(ComponentName name) { mUserManager = null; } }; -
绑定Service
bindService(new Intent(this, UserService.class), mConn, BIND_AUTO_CREATE);
这个时候就可以用mUserManager来执行addUser和getUserList，那么问题来了，mUserManager是怎么把客户端的数据添加到服务端，又是怎么获取服务端的数据呢？
Binder工作原理
首先，我们来看一下根据IUserManager.aidl文件生成的Java类中有什么乾坤
1.先来大概看一下IUserManager.java
public interface IUserManager extends android.os.IInterface {
public static abstract class Stub extends android.os.Binder implements com.hk.b.aidl.IUserManager {
//...
}
public java.util.List getUserList() throws android.os.RemoteException;
public void addUser(com.hk.b.aidl.User u) throws android.os.RemoteException;
}
-
IUserManager继承IInterface这个接口，要想在Binder中用，这是必须的。 - 内部类Stub继承Binder,同时它又实现了IUserManager。Stub他是一个抽象类，是因为它没有实现IUserManager的未实现方法，这两个方法要在使用该Stub的时候实现。
2.再来看一下IUserManager.Stub
public static abstract class Stub extends android.os.Binder implements com.hk.b.aidl.IUserManager {
private static final java.lang.String DESCRIPTOR = "com.hk.b.aidl.IUserManager";
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
public static com.hk.b.aidl.IUserManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.hk.b.aidl.IUserManager))) {
return ((com.hk.b.aidl.IUserManager) iin);
}
return new com.hk.b.aidl.IUserManager.Stub.Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, android.os.Parcel data,
//...
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.hk.b.aidl.IUserManager {
//...
}
//...
}
- DESCRIPTOR:Binder的唯一标识，一般用当前aidl生成类的类名表示，例如：
com.hk.b.aidl.IUserManager - Stub():构造函数，把该接口添加到本地接口中
- asBinder():返回当前Binder对象
- asInterface(android.os.IBinder obj):
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);客户端查询本地接口，如果本地接口有，说明客户端和服务端是属于同一个进程，则返回该进程里的IInterface，如果没有说明客户端和服务端不属于同一个进程，则new com.hk.b.aidl.IUserManager.Stub.Proxy(obj),返回Binder代理类Sub.Proxy,Binder跨进程的关键来了
3.IUserManager.Stub.Proxy和它用到的一些Stub成员或方法
public static abstract class Stub extends android.os.Binder implements com.hk.b.aidl.IUserManager {
//...
@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_getUserList: {
data.enforceInterface(DESCRIPTOR);
java.util.List _result = this.getUserList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addUser: {
data.enforceInterface(DESCRIPTOR);
com.hk.b.aidl.User _arg0;
if ((0 != data.readInt())) {
_arg0 = com.hk.b.aidl.User.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addUser(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.hk.b.aidl.IUserManager {
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 getUserList() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getUserList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.hk.b.aidl.User.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void addUser(com.hk.b.aidl.User u) 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 ((u != null)) {
_data.writeInt(1);
u.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_addUser, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_getUserList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addUser = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
TRANSACTION_getUserList和TRANSACTION_addUser接口方法id，如果有更多方法，依次递增-
Proxy实现了IUserManager，并实现了它的两个方法getUserList()，addUser(com.hk.b.aidl.User u)，这两个方法是在客户端执行的，做了什么事呢？- 创建android.os.Parcel类型的_data和_replay，_data用来存放方法参数，_replay用来存放RPC的返回值。
-
_data.writeInterfaceToken(DESCRIPTOR)写入唯一标识，如果方法有参数，写入1，然后把参数信息写入_data -
mRemote.transact(Stub.TRANSACTION_xxx, _data, _reply, 0)Binder发起RPC,传入方法id,参数，返回值和标志位，0表示普通RPC -
_result = _reply.createTypedArrayList(com.hk.b.aidl.User.CREATOR)如果方法有返回值的话，_reply调用.createXxx()方法，Xxx表示返回值类型，比如TypedArrayList返回的类型是带泛型的ArrayList - 最后回收_data和_reply避免资源的浪费
-
一旦客户端执行transact，客户端发起RPC的线程就会挂起，等待服务端的响应，这个时候就会调用服务端Stub的onTransact方法，这个方法又干了什么呢？
- 匹配方法id，不用多说
- 从服务端Binder线程池中用唯一标示符匹配客户端传过来android.os.Parcel类型的data和reply，如果
data.readInt()不为0，取出参数 - 调用与客户端请求对应的服务端实现IUserManager的方法
- 如果方法有返回值，则写入reply
- 返回true，如果返回false，则服务端拒绝，可以用这个来做权限判断。
总结
这样我们就很清晰的知道了Binder的工作原理，我们完全可以不用aidl文件自己写一个Binder，但是存在即是合理，还是要用aidl文件来节约开发成本，最后来画一下Binder的流程图吧
Client->Server: bindService
Server-->Client: 返回一个Binder
Client->Server: Binder请求数据，写入参数，调用transact，挂起
Note right of Server:onTransact从Binder线程池中得到与客户端对应的Binder，处理请求
Server-->Client: 写入结果，返回给客户端Binder，并唤醒客户端