Android面试抱佛脚：进程间通讯学习，从Binder使用看起

本文主要是介绍Android面试抱佛脚：进程间通讯学习，从Binder使用看起，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

val file = File(“aaaa”)

file.createNewFile()

///序列化过程

ObjectOutputStream(FileOutputStream(file))

.use {

it.writeObject(User(“张三”))

}

///反序列化

val user: User? =

ObjectInputStream(FileInputStream(file)).use {

it.readObject() as User?

}

println(“序列化结果”)

println(user?.name)

上述代码完成了Serializable 方式序列化的整个过程。很简单，直接使用ObjectOutputStream 和 ObjectInputStream 就可以了。

Parcelable

========================================================================

介绍完Serializable，再来看看Parcelable 。Parcelable也是一个接口，只要实现这个接口，就可以实现序列化并通过intent和binder进行传递。看看一个经典的用法：

class User(val name: String? = “小王”) : Parcelable {

constructor(parcel: Parcel) : this(parcel.readString()) {

}

override fun writeToParcel(parcel: Parcel, flags: Int) {

parcel.writeString(name)

}

override fun describeContents(): Int {

return 0

}

companion object CREATOR : Parcelable.Creator {

override fun createFromParcel(parcel: Parcel): User {

return User(parcel)

}

override fun newArray(size: Int): Array<User?> {

return arrayOfNulls(size)

}

可以看到有这么四个自定义的方法，说明如下：

writeToParcel 实现序列化功能，写入到parcel
describeContents 提供内容描述，几乎都是返回0，只有在存在文件描述符的时候才返回1
createFromParcel 实现反序列功能，从序列化后的对象中创建原始对象
newArray 提供数组容器

Parcelale和Serializable 都能实现序列化，怎么选呢？我们可以根据两种方案的区别来选择。Serializable使用简单，但是开销比较大，在序列化和反序列化的过程中需要大量的I/O操作。而Parcelable 的使用稍微复杂一些，但是性能比较好是Android 推荐的序列化方式。所以在进行内存传递的时候，可以使用Parcelable进行序列化，但是在涉及到持久化和网络传输的时候，Parcelable也能实现，但是使用会比较复杂，所以在这两种情况下建议使用Serializable。上面就是两种序列化方案的区别。

Binder

====================================================================

Binder是Android专有的一种通信方式，Binder底层有kernel驱动的支持，设备驱动文件是/dev/binder，通过该驱动，android 在native层有一整套C/S架构，在java层也封装了一层相应实现。直观来说，Binder是Android中的一个类，它继承了IBinder接口。 Binder 可以进行跨进程通讯，也可以进行本地进程通讯。我们在写一个无须跨进程的本地服务 LocalService 时，可以直接获取Binder类来进行通讯。基于binder,Android实现了多个ManagerService。因为android 系统有各种系统组件硬件需要暴露给其他进程，并且要集中管理，所以安卓在实现管理方案之后，再通过binder来暴露对应的接口服务，比如pms，ams，wms。 Android开发中，开发者对于Binder最直接的应用就是使用AIDL，相关使用流程大概有以下几步：

创建aidl文件，声明方法
继承生成的Stub类(Binder的抽象子类)，实现服务端操作的相关接口方法
创建另一个进程中运行的service，在其onBind方法中返回该Binder实例
使用该Service，通过ServiceConnection#onServiceConnected回调中得到的参数IBinder 获取定义接口的Binder实例。如IHelloManager.Stub.asInterface(service)。
通过Binder实例进行远程方法调用。

AIDL ( Android 接口定义语言 )

先看谷歌官方开发者文档的介绍我们可以利用AIDL定义客户端与服务均认可的编程接口，以便二者使用进程间通信 (IPC) 进行相互通信。在安卓中，编写进程间通信的代码较为繁琐，Android 会使用AIDL 帮我们处理这类问题。我们先从一个典型的AIDL实例入手来探究。

定义AIDL接口

我们来定义一个 aidl 接口文件

//IHelloManager.aidl

package top.guuguo.wanandroid.tv;

import top.guuguo.wanandroid.tv.User;

interface IHelloManager {

User getFriend();

void setFriend(in User friend);

}

//User.aidl

package top.guuguo.wanandroid.tv;

parcelable User;

其中用到了User对象，所以上文还定义了该User.aidl，该对象实现Parcelable接口。我们找到generated/aidl_source_output_dir观察对应生成的java 类:IHelloManager.java。

public interface IHelloManager extends android.os.IInterface {

/**

Default implementation for IHe
lloManager.

public static class Default implements top.guuguo.wanandroid.tv.IHelloManager {

/***/

}

/**

Local-side IPC implementation stub class.

public static abstract class Stub extends android.os.Binder implements top.guuguo.wanandroid.tv.IHelloManager {

/***/

private static class Proxy implements top.guuguo.wanandroid.tv.IHelloManager {

/***/

}

public top.guuguo.wanandroid.tv.User getFriend() throws android.os.RemoteException;

public void setFriend(top.guuguo.wanandroid.tv.User friend) throws android.os.RemoteException;

}

可以看到生成了IHelloManager 接口，实现IInterface。可以看到默认生成了三个该接口的实现类。Default，Stub 和Stub.Proxy。 Stub 是一个Binder类,是一个实例是服务端对象。Stub.Proxy 是Proxy的服务端代理类，其中执行方法的时候，调用了服务端的transact方法进行进程间数据交互转换，这两个实现类就是IHelloManager的核心类。看看Stub类的代码：

public static abstract class Stub extends android.os.Binder implements top.guuguo.wanandroid.tv.IHelloManager {

private static final java.lang.String DESCRIPTOR = “top.guuguo.wanandroid.tv.IHelloManager”;

public Stub() {

this.attachInterface(this, DESCRIPTOR);

}

public static top.guuguo.wanandroid.tv.IHelloManager asInterface(android.os.IBinder obj) {

if ((obj == null)) {

return null;

}

android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);

if (((iin != null) && (iin instanceof top.guuguo.wanandroid.tv.IHelloManager))) {

return ((top.guuguo.wanandroid.tv.IHelloManager) iin);

}

return new top.guuguo.wanandroid.tv.IHelloManager.Stub.Proxy(obj);

}

@Override

public android.os.IBinder asBinder() {}

@Override

public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {

java.lang.String descriptor = DESCRIPTOR;

switch (code) {

case INTERFACE_TRANSACTION: {

reply.writeString(descriptor);

return true;

}

case TRANSACTION_getFriend: {

data.enforceInterface(descriptor);

top.guuguo.wanandroid.tv.User _result = this.getFriend();

reply.writeNoException();

if ((_result != null)) {

reply.writeInt(1);

_result.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);

} else {

reply.writeInt(0);

}

return true;

}

case TRANSACTION_setFriend: {

data.enforceInterface(descriptor);

top.guuguo.wanandroid.tv.User _arg0;

if ((0 != data.readInt())) {

_arg0 = top.guuguo.wanandroid.tv.User.CREATOR.createFromParcel(data);

} else {

_arg0 = null;

}

this.setFriend(_arg0);

reply.writeNoException();

return true;

}

default: {

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

}

static final int TRANSACTION_getFriend = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);

static final int TRANSACTION_setFriend = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);

public static boolean setDefaultImpl(top.guuguo.wanandroid.tv.IHelloManager impl) {

if (Stub.Proxy.sDefaultImpl != null) {

throw new IllegalStateException(“setDefaultImpl() called twice”);

}

if (impl != null) {

Stub.Proxy.sDefaultImpl = impl;

return true;

}

return false;

}

public static top.guuguo.wanandroid.tv.IHelloManager getDefaultImpl() {

return Stub.Proxy.sDefaultImpl;

}

下面介绍一下Stub类中成员的含义：

DESCRIPTOR

Binder的唯一标识，一般是当前Binder的类名。本例是"top.guuguo.wanandroid.tv.IHelloManager"

asInterface(android.os.IBinder obj)

将服务端的Binder对象转换成对应AIDL接口对象。通过queryLocalInterface区分进程，如果双端是在同一进程中，返回的对象就是Stub对象，如果是在不同的进程中，则返回其Proxy代理对象。

asBinder

返回当前Binder实例

onTransact

该方法对传输的数据进行序列化和反序列化操作。完整的方法是public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)。该方法中，通过code定位客户端所请求的方法是什么，接着从data中取出方法所需的参数，然后执行目标方法，如果目标方法有返回值，向reply写入返回结果。该方法如果返回false，那么客户端的请求就会失败。我们可以在该方法做一些调用限制，避开一些不期望的进程调用该方法。

Proxy#getFriend 和Proxy#setFriend

这两个代理方法先处理传入参数，将其写入到Parcel中，然后调用mRemote.transact发起RPC(远程过程调用)请求。同时当前线程挂起，直到RPC过程返回后，再继续执行当前线程，并取出reply的返回结果。反序列化后返回数据。

bindService

通过上面AIDL 及其生成代码的分析，我们知道了AIDL 只是个便于我们快速生成Binder通讯模板代码的方式。我们要在相关组件中使用该Binder进行IPC时，需要通过绑定服务获取Binder实例。下面是绑定服务获取binder的相关代码:

val connection = object : ServiceConnection {

override fun onServiceConnected(name: ComponentName?, service: IBinder?) {

“onServiceConnected”.toast()

binder = IHelloManager.Stub.asInterface(service)

}

override fun onServiceDisconnected(name: ComponentName?) {

“onServiceDisconnected”.toast()

}

override fun onStart() {

super.onStart()

val intent = Intent(this, HelloService::class.java)

intent.action = “:startHello”

bindService(intent, connection, BIND_AUTO_CREATE)

}

override fun onStop() {

super.onStop()

unbindService(connection)

}

从上面的代码中，我们就可以通过bindService 获取aidl定义的Binder实例。通过该Binder实例，直接就可以对远程进程进行方法调用了。绑定服务具体的流程是什么呢？现在看一下整个调用路径

发起绑定服务： mBase.bindService
定位到具体的绑定方法：经过查阅Activity#attach方法、ActivityThread#performLaunchActivity方法和 createBaseContextForActivity 方法，得知mBase是ContextImpl实例。

HelloService::class.java)

intent.action = “:startHello”

bindService(intent, connection, BIND_AUTO_CREATE)

}

override fun onStop() {

super.onStop()

unbindService(connection)

}

发起绑定服务： mBase.bindService
定位到具体的绑定方法：经过查阅Activity#attach方法、ActivityThread#performLaunchActivity方法和 createBaseContextForActivity 方法，得知mBase是ContextImpl实例。

这篇关于Android面试抱佛脚：进程间通讯学习，从Binder使用看起的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Android开发