Android：安卓学习笔记之Binder 机制的简单理解和使用

最新推荐文章于 2024-06-22 11:09:14 发布

JMW1407

最新推荐文章于 2024-06-22 11:09:14 发布

阅读量3.8k

点赞数 12

分类专栏： Android 文章标签： android java Binder 机制

本文链接：https://blog.csdn.net/JMW1407/article/details/122377533

版权

Android 专栏收录该内容

83 篇文章 40 订阅

订阅专栏

Binder 机制

1、背景

在讲解Binder前，我们先了解一些Linux的基础知识

1.1、进程空间划分

在这里插入图片描述

IPC 即 Inter-Process Communication (进程间通信)。Android 基于 Linux，而 Linux 出于安全考虑，不同进程间不能之间操作对方的数据，这叫做“进程隔离”。

1.2、进程隔离 & 跨进程通信（ IPC）

进程隔离

为了保证安全性 & 独立性，一个进程不能直接操作或者访问另一个进程，即Android的进程是相互独立、隔离的

跨进程通信（ IPC ）

即进程间需进行数据交互、通信

跨进程通信的基本原理

在这里插入图片描述

Android应用和系统services运行在不同进程中是为了安全，稳定，以及内存管理的原因，但是应用和系统服务需要通信和分享数据。

优点

安全性：每个进程都单独运行的，可以保证应用层对系统层的隔离。
稳定性：如果某个进程崩溃了不会导致其他进程崩溃。
内存分配：如果某个进程以及不需要了可以从内存中移除，并且回收相应的内存。

2、Binder到底是什么？

在这里插入图片描述
拿Activity举例从上图可以看出来：Activity是由ActivityManager来控制的，而ActivityManager其实是通过Binder获取ActivityManagerService服务来控制Activity的，并且ActivityManager是Android系统FrameWork层的，和应用中的activity不是同一个进程。

在这里插入图片描述

一个进程空间分为用户空间 & 内核空间（Kernel），即把进程内用户 & 内核隔离开来；
用户空间的数据不可共享,内核空间的数据可共享,一个进程不能直接操作或者访问另一个进程，即Android的进程是相互独立、隔离的
跨进程通信机制模型基于 Client - Server 模式，client\server\serverManager属于不同的进程，如果想要实现跨进程通信就需要Binder等进程间通信方式。

3、Binder 跨进程通信机制模型

3.1、模型原理图

Binder 跨进程通信机制模型基于 Client - Server 模式
在这里插入图片描述

3.1.1、模型拓展

一个进程是不能直接直接操作另一个进程的，比如说读取另一个进程的数据，或者往另一个进程的内存空间写数据，进程之间的通信要通过内核进程才可以，因此这里就要使用到进程通信工具Binder了如下图：
在这里插入图片描述
但是上面还有个问题就是client和service要直接和binder driver打交道，但是实际上client和service并不想知道binder相关协议，所以进一步client通过添加proxy代理，service通过添加stub来进一步处理与binder的交互。

在这里插入图片描述
这样的好处是client和service都可以不用直接去和binder打交道。上面的图好像已经很完善了，但是Android系统更进一步封装，不让client知道Binder的存在，Android系统提供了Manager来管理client。如下图：

这样client只需要交给manager来管理就好了，根本就不用关心进程通信相关的事，关于manager其实是很熟悉的，比如说activity的就是由ActivityManager来控制的，ActivityManager是通过Binder获取ActivityManagerService来控制activity的。这样就不用我们自己来使用Binder来ActivityManagerService通信了。

3.2、模型组成角色说明

在这里插入图片描述

3.3、Binder驱动

在这里插入图片描述
跨进程通信的核心原理

关于其核心原理：内存映射，具体请看文章：操作系统：图文详解内存映射
在这里插入图片描述

3.4、模型原理步骤说明

在这里插入图片描述

3.5、额外说明

说明1：Client进程、Server进程 & Service Manager 进程之间的交互都必须通过Binder驱动（使用 open 和 ioctl文件操作函数），而非直接交互

在这里插入图片描述
原因：

Client进程、Server进程 & Service Manager进程属于进程空间的用户空间，不可进行进程间交互
Binder驱动属于进程空间的内核空间，可进行进程间 & 进程内交互

说明2： Binder驱动 & Service Manager进程属于 Android基础架构（即系统已经实现好了）；而Client 进程和 Server 进程属于Android应用层（需要开发者自己实现）

在这里插入图片描述

说明3：Binder请求的线程管理

在这里插入图片描述

4、Binder机制的具体实现原理

Binder机制在 Android中的实现主要依靠 Binder类，其实现了IBinder 接口
在这里插入图片描述

4.1、实例说明

Client进程需要调用 Server进程的加法函数（将整数a和b相加）

Client进程需要传两个整数给 Server进程
Server进程需要把相加后的结果返回给Client进程

4.1.1、步骤1：注册服务

在这里插入图片描述

    
    Binder binder = new Stub();
    // 步骤1：创建Binder对象 ->>分析1

    // 步骤2：创建 IInterface 接口类 的匿名类
    // 创建前，需要预先定义 继承了IInterface 接口的接口 -->分析3
    IInterface plus = new IPlus(){

          // 确定Client进程需要调用的方法
          public int add(int a,int b) {
               return a+b;
         }

          // 实现IInterface接口中唯一的方法
          public IBinder asBinder（）{ 
                return null ;
           }
};
          // 步骤3
          binder.attachInterface(plus，"add two int");
         // 1. 将（add two int，plus）作为（key,value）对存入到Binder对象中的一个Map<String,IInterface>对象中
         // 2. 之后，Binder对象 可根据add two int通过queryLocalIInterface（）获得对应IInterface对象（即plus）的引用，可依靠该引用完成对请求方法的调用
        // 分析完毕，跳出


<-- 分析1：Stub类 -->
    public class Stub extends Binder {
    // 继承自Binder类 ->>分析2

          // 复写onTransact（）
          @Override
          boolean onTransact(int code, Parcel data, Parcel reply, int flags){
          // 具体逻辑等到步骤3再具体讲解，此处先跳过
          switch (code) { 
                case Stub.add： { 

                       data.enforceInterface("add two int"); 

                       int  arg0  = data.readInt();
                       int  arg1  = data.readInt();

                       int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 

                        reply.writeInt(result); 

                        return true; 
                  }
           } 
      return super.onTransact(code, data, reply, flags); 

}
// 回到上面的步骤1，继续看步骤2

<-- 分析2：Binder 类 -->
 public class Binder implement IBinder{
    // Binder机制在Android中的实现主要依靠的是Binder类，其实现了IBinder接口
    // IBinder接口：定义了远程操作对象的基本接口，代表了一种跨进程传输的能力
    // 系统会为每个实现了IBinder接口的对象提供跨进程传输能力
    // 即Binder类对象具备了跨进程传输的能力

        void attachInterface(IInterface plus, String descriptor)；
        // 作用：
          // 1. 将（descriptor，plus）作为（key,value）对存入到Binder对象中的一个Map<String,IInterface>对象中
          // 2. 之后，Binder对象 可根据descriptor通过queryLocalIInterface（）获得对应IInterface对象（即plus）的引用，可依靠该引用完成对请求方法的调用

        IInterface queryLocalInterface(Stringdescriptor) ；
        // 作用：根据 参数 descriptor 查找相应的IInterface对象（即plus引用）

        boolean onTransact(int code, Parcel data, Parcel reply, int flags)；
        // 定义：继承自IBinder接口的
        // 作用：执行Client进程所请求的目标方法（子类需要复写）
        // 参数说明：
        // code：Client进程请求方法标识符。即Server进程根据该标识确定所请求的目标方法
        // data：目标方法的参数。（Client进程传进来的，此处就是整数a和b）
        // reply：目标方法执行后的结果（返回给Client进程）
         // 注：运行在Server进程的Binder线程池中；当Client进程发起远程请求时，远程请求会要求系统底层执行回调该方法

        final class BinderProxy implements IBinder {
         // 即Server进程创建的Binder对象的代理对象类
         // 该类属于Binder的内部类
        }
        // 回到分析1原处
}

<-- 分析3：IInterface接口实现类 -->

 public interface IPlus extends IInterface {
          // 继承自IInterface接口->>分析4
          // 定义需要实现的接口方法，即Client进程需要调用的方法
         public int add(int a,int b);
// 返回步骤2
}

<-- 分析4：IInterface接口类 -->
// 进程间通信定义的通用接口
// 通过定义接口，然后再服务端实现接口、客户端调用接口，就可实现跨进程通信。
public interface IInterface
{
    // 只有一个方法：返回当前接口关联的 Binder 对象。
    public IBinder asBinder();
}
  // 回到分析3原处

注册服务后，Binder驱动持有 Server进程创建的Binder实体

4.1.2、步骤2：获取服务

Client进程使用某个 service前（此处是相加函数），须通过Binder驱动向 ServiceManager进程获取相应的Service信息

在这里插入图片描述

4.1.3、步骤3: 使用服务

在这里插入图片描述

步骤1： Client进程将参数（整数a和b）发送到Server进程

// 1. Client进程 将需要传送的数据写入到Parcel对象中
// data = 数据 = 目标方法的参数（Client进程传进来的，此处就是整数a和b） + IInterface接口对象的标识符descriptor
  android.os.Parcel data = android.os.Parcel.obtain();
  data.writeInt(a); 
  data.writeInt(b); 

  data.writeInterfaceToken("add two int");；
  // 方法对象标识符让Server进程在Binder对象中根据"add two int"通过queryLocalIInterface（）查找相应的IInterface对象（即Server创建的plus），Client进程需要调用的相加方法就在该对象中

  android.os.Parcel reply = android.os.Parcel.obtain();
  // reply：目标方法执行后的结果（此处是相加后的结果）

// 2. 通过 调用代理对象的transact（） 将 上述数据发送到Binder驱动
  binderproxy.transact(Stub.add, data, reply, 0)
  // 参数说明：
    // 1. Stub.add：目标方法的标识符（Client进程 和 Server进程 自身约定，可为任意）
    // 2. data ：上述的Parcel对象
    // 3. reply：返回结果
    // 0：可不管

// 注：在发送数据后，Client进程的该线程会暂时被挂起
// 所以，若Server进程执行的耗时操作，请不要使用主线程，以防止ANR


// 3. Binder驱动根据 代理对象 找到对应的真身Binder对象所在的Server 进程（系统自动执行）
// 4. Binder驱动把 数据 发送到Server 进程中，并通知Server 进程执行解包（系统自动执行）

步骤2：Server进程根据Client进要求调用目标方法（即加法函数）

// 1. 收到Binder驱动通知后，Server 进程通过回调Binder对象onTransact（）进行数据解包 & 调用目标方法
  public class Stub extends Binder {

          // 复写onTransact（）
          @Override
          boolean onTransact(int code, Parcel data, Parcel reply, int flags){
          // code即在transact（）中约定的目标方法的标识符

          switch (code) { 
                case Stub.add： { 
                  // a. 解包Parcel中的数据
                       data.enforceInterface("add two int"); 
                        // a1. 解析目标方法对象的标识符

                       int  arg0  = data.readInt();
                       int  arg1  = data.readInt();
                       // a2. 获得目标方法的参数
                      
                       // b. 根据"add two int"通过queryLocalIInterface（）获取相应的IInterface对象（即Server创建的plus）的引用，通过该对象引用调用方法
                       int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 
                      
                        // c. 将计算结果写入到reply
                        reply.writeInt(result); 
                        
                        return true; 
                  }
           } 
      return super.onTransact(code, data, reply, flags); 
      // 2. 将结算结果返回 到Binder驱动

步骤3：Server进程将目标方法的结果（即加法后的结果）返回给Client进程

  // 1. Binder驱动根据 代理对象 沿原路 将结果返回 并通知Client进程获取返回结果
  // 2. 通过代理对象 接收结果（之前被挂起的线程被唤醒）

    binderproxy.transact(Stub.ADD, data, reply, 0)；
    reply.readException();；
    result = reply.readInt()；
          }
}

4.1.4、总结

在这里插入图片描述

在这里插入图片描述
优点

Binder 相较于传统 IPC 来说更适合于Android系统，具体原因的包括如下三点：

Binder 本身是 C/S 架构的，这一点更符合 Android 系统的架构
性能上更有优势：管道，消息队列，Socket 的通讯都需要两次数据拷贝，而 Binder 只需要一次。要知道，对于系统底层的 IPC形式，少一次数据拷贝，对整体性能的影响是非常之大的
安全性更好：传统 IPC 形式，无法得到对方的身份标识（UID/GID)，而在使用 Binder IPC
时，这些身份标示是跟随调用过程而自动传递的。Server 端很容易就可以知道 Client 端的身份，非常便于做安全检查

在这里插入图片描述

5、面试问题

Android开发面试被问Binder还不会，收藏这一篇就够了（附图解）

参考

1、图解Android中的Binder机制
2、Android Binder（也许是最容易理解的）
3、图文详解Binder跨进程通信原理
4、Android 接口定义语言 (AIDL)
5、[学习笔记]Android开发艺术探索：IPC机制

JMW1407

关注

12
点赞
踩
34

收藏

觉得还不错? 一键收藏
1
评论
Android：安卓学习笔记之Binder 机制的简单理解和使用

Binder 机制的简单理解和使用Binder 机制参考Binder 机制参考1、图解Android中的Binder机制2、Android Binder（也许是最容易理解的）3、图文详解Binder跨进程通信原理4、Android 接口定义语言 (AIDL)...
复制链接

扫一扫