android跨进程观察者模式,Android轻松实现跨进程/跨app通讯框架及其原理

Android轻松实现跨进程/跨app通讯框架及其原理

先给没耐心的朋友上酸菜:

框架GitHub

如果觉得好用,希望给个star支持一下

现有跨进程方案:

- aidl

- Messenger

- broadcast

- socket

以上实现都很繁琐

现基于Messenger 封装一个跨进程跨app通讯框架

关于Messenger :

可以先看这篇博客:

Android 基于Message的进程间通信 Messenger完全解析

先简单介绍下Messenger的原理:

Messenger是系统基于aidl封装的一个简易的 通过 handler 传输数据

跨进程通信框架;

创建简单服务端:

```

mMessenger = new Messenger(handler)

```

在服务里面返回它的binder即可:

```

@Override

public IBinder onBind(Intent intent)

{

return mMessenger.getBinder();

}

```

在handler 的 handleMessage 即可拿到对面进程的 Messenger

```

static class ServiceHandler extends Handler {

@Override

public void handleMessage(Message msg) {

Messenger client = msg.replyTo;

}

}

```

简单客户端:

```

mContext.bindService(intent, mConnection, Context.BIND_AUTO_CREATE);

```

对,绑定服务端的服务即可

```

static class ClientConn implements ServiceConnection {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

mServer = new Messenger(service);

reg();

}

@Override

public void onServiceDisconnected(ComponentName name) {

mServer = null;

connect();

}

}

```

mServer 即为服务端 的 Messenger 对象;

通过它就可以把消息发到服务端

服务端在handler里收到消息,同时拿到 客户端的 Messenger

客户端也要 new 一个 Messenger

```

private static ClientHandler handler = new ClientHandler();

private static Messenger mMessenger = new Messenger(handler);

```

Messenger 里包含客户端的handler:

用来处理接受到的服务端发送来的消息

```

static class ClientHandler extends Handler {

@Override

public void handleMessage(Message msg) {

//这里是服务端发来的消息

}

}

```

客户端必须主动向服务端发送消息,同时把自己的Messenger 放到消息里面发送给服务端

```

public void sendMsg(Bundle bundle) {

Message msg = Message.obtain(handler, Constant.SEND_MSG_TO_TARGET);

msg.setData(bundle);

msg.replyTo = mMessenger; //把客户端自己的Messenger 放到消息里面发送给服务端

try {

if (mServer != null) {

mServer.send(msg);

}

} catch (RemoteException e) {

e.printStackTrace();

}

}

```

这样,服务端拿到了客户端的Messenger

它们互相持有对方的 Messenger 就可以做到跨进程的双向通信!

注意:Message 为handler的消息对象,但是不能使用它的obj传递消息

只能用它的 what,arg1,arg2和setData(bundle)传递消息,否则会报:

不可跨进程传递非序列化对象错误,即时obj传递的是一个序列化对象

下面来介绍框架实现思路:

上面这类互相持有对方内部对象的现象是不是跟 接口回调非常类似!

既然做到了接口回调,那么观察者模式还会远吗?

对的,如果服务端通过map持有多个客户端的Messenger 那不就实现了

观察者模式吗?

想到这里相比就很简单了

我一开始的思路是,在主进程创建服务;用这个服务持有其他需要通讯的客户端的

Messenger;

其他通讯的客户端每个对象创建一个 Messenger;

但是我发现在服务端给每个客户端保存对象的map集合不好区分每个对象的key

因为我用的key是Integer;

后来我采用的办法是获取客户端进程的进程名,然后拿进程名的hashCode作为key

这样每个进程只有一个Messenger对象,但是每个进程可能有多个消息传递

所以再给每个进程创建一个消息中心

把每个需要接收消息的对象在消息中心订阅;

然后服务端每次接收到消息都转发给所有客户端Messenger

客户端Messenger再在消息中心遍历接收对象订阅消息时候的key,把消息发送到指定对象

框架基本原理说清楚了!

下面说说跨app通信

原理:

通过aidl 的跨app通信,其实就是绑定另一个app的远程服务:

本框架实现原理是一样的:

框架用变量${applicationId}表示包名;

这样包名就是使用本框架的app包名,达到框架在任意项目使用的目的;

android:name="cn.leo.messenger.BinderPool"

android:exported="true">

Intent intent = new Intent(mPkgName + ".messenger");

intent.setPackage(mPkgName);

mContext.bindService(intent, mConnection, Context.BIND_AUTO_CREATE);

剩下的操作就和上面跨进程一样一样的了;都是绑定服务而已

框架使用方法:

第一步:

在 application 里面初始化

MagicMessenger.init(this); //跨进程需要

MagicMessenger.bindOtherAPP(this, "包名"); //跨app需要,不跨app可以去掉

跨app需要主app初始化跨进程功能

注意!初始化代码需要在每个进程都初始化,所以不要加进程判断代码

第二步:

在需要接受消息的对象中,订阅消息,第一个参数,是接收消息的标志,需要唯一;否则可能会收不到消息!

消息依赖bundle传递,可传递类型跟bundle 允许类型一致

MagicMessenger.subscribe("key", new MessageCallback() {

@Override

public void onMsgCallBack(Bundle data) {

}

});

发送消息示例:

Bundle bundle = new Bundle();

bundle.putString("test", "activity1 发送消息到服务");

MagicMessenger.post("key", bundle); //第一个参数为消息订阅标志,需要唯一

第三步:

在对象销毁时,取消订阅,否则会导致内存泄漏

参数key 是订阅时候的唯一标识

MagicMessenger.unsubscribe("key");

依赖方法:

1.在全局build里添加仓库:

allprojects {

repositories {

......

maven { url 'https://jitpack.io' }

}

}

2.在app的build里添加依赖:

dependencies {

......

implementation 'com.github.jarryleo:MagicMessenger:v2.0'

}