Android 中Binder跨进程通信的原理

邓琴文

1. Binder是什么

Android 中有很多使用跨进程通信(IPC)的场景,在IPC机制的几种方法中,AIDL,Messenger,ContentProvider,这些机制底层全部都是用了Binder机制来实现的,那么什么是Binder?

Binder中文即粘合剂,意思为粘合了两个不同的进程。

对于Binder的定义,在不同场景下其定义不同! image


2. 相关基础知识

2.1 进程空间分配

  • 一个进程空间分为 用户空间 & 内核空间(Kernel),即把进程内 用户 & 内核 隔离开来
  • 二者区别:
    1. 进程间,用户空间的数据不可共享,所以用户空间 = 不可共享空间
    2. 进程间,内核空间的数据可共享,所以内核空间 = 可共享空间
  • 进程内 用户 与 内核 进行交互 称为系统调用

image

2.2进程隔离与进程间通信

android中,一个进程是不能直接操作访问另一个进程的,即Android的进程是相互独立、隔离的。
但是有的时候,隔离的进程又需要进行交互,这就是跨进程通信(IPC)

  • 跨进程间通信的原理
    1. 先通过 进程间 的内核空间进行 数据交互
    2. 再通过 进程内 的用户空间 & 内核空间进行 数据交互,从而实现 进程间的用户空间 的数据交互 image

而Binder,就是充当连接两个进程(内核空间)的通道。


3.Binder跨进程通信机制

  • Binder跨进程通信机制是基于 Client-Server模式 image

在这个通信模型中,这其中的四个角色到底是怎么交互来完成Client与Server的通信的呢?


过程:
  1. Server注册服务
    1. Server进程向Binder驱动发起注册服务请求
    2. Binder驱动将注册请求转发给ServiceManager进程
    3. ServiceManager进程添加该Server进程,即注册了服务

此时,ServiceManager进程拥有了Server进程的信息

  1. Client获取服务
    1. Client向Binder驱动发起获取服务请求,传递需要获取的服务名称
    2. Binder驱动将该请求转发给ServiceManager进程
    3. ServiceManager进程查找到Client需要的Server对应的服务信息
    4. 通过Binder驱动将上述服务信息返回给Client进程(注意此时返回的Server信息并不是真正的Server信息,是经过了一层包装的,下面讲

此时,Client进程与Server进程的已经建立了联系

  1. 使用服务方法
    1. Client 进程将需要传送的数据放入到Client的共享内存中(此时,当前线程被挂起)
    2. Binder驱动从Client共享内存中读取数据,并查询ServiceManager进程里面的Server信息找到对应的Server进程
    3. Binder驱动把上述数据拷贝到Server进程的共享内存中,并通知Server 进程处理。
    4. Server进程收到通知后,从线程池中取出线程,进行数据处理调用方法等操作
    5. Server进程将最终执行的结果写入到自己的共享内存中
    6. Binder驱动将最终数据拷贝到Client进程的共享内存中,
    7. 通知Client进程拿结果(此时之前被挂起的线程重新被唤醒)
我们上面说过Client进程去获取Server进程信息时返回的不是真正的Server进程对象,而是经过包装的Server代理对象。Client进程去调用服务方法使用服务时,也是先调用的代理对象的方法,然后代理对象拿到参数之后放入内存发送给Binder驱动。

image

一句话总结就是:Client进程只不过是持有了Server端的代理;代理对象协助驱动完成了跨进程通信。


4.Binder在Android中的具体实现原理

  • 实例说明:Client进程 需要调用 Server进程的添加函数和查询函数

  • 过程描述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 机制的优点有:

  1. 高效

    • Binder数据拷贝只需要一次,而管道、消息队列、Socket都需要2次
    • 通过驱动在内核空间拷贝数据,不需要额外的同步处理
  2. 安全性高

    • Binder 机制为每个进程分配了 UID/PID 来作为鉴别身份的标示,并且在 Binder 通信时会根据 UID/PID 进行有效性检测

    • 传统的进程通信方式对于通信双方的身份并没有做出严格的验证如,Socket通信 ip地址是客户端手动填入,容易出现伪造

  3. 使用简单
    • 采用Client/Server 架构
    • 实现面向对象的调用方式,即在使用Binder时就和调用一个本地对象实例一样