Android中实现IPC通信的8种方式

[TOC]

1.使用Bundle ----> 用于android四大组件间的进程间通信

android的四大组件都可使用Bundle传递数据所以如果要实现四大组件间的进程间通信完全可以使用Bundle来实现简单方便

2.使用文件共享 ---->用于单线程读写

这种方式在单线程读写的时候比较好用如果有多个线程并发读写的话需要限制线程的同步读写
另外 SharePreference是个特例它底层基于xml实现但是系统对它的读写会基于缓存，也就是说再多进程模式下就变得不那么可靠了，有很大几率丢失数据

3.使用Messenger ---->用于可存放在message中的数据的传递

使用这个方式可以在不同进程间传递message对象这是一种轻量级的IPC方案当传递的对象可以放入message中时可以考虑用这种方式但是msg.object最好不要放
因为不一定可以序列化
使用它的步骤如下：
假设这样一个需求需要在客户端A发送消息给服务端B接受然后服务端B再回复给客户端A

1. 首先是客户端A发送消息给服务端B 所以在客户端A中声明一个Handler用来接受消息并创建一个Messenger对象用Handler作为参数构造然后onBinder方法返回messenger.getBinder() 即可

public class MyServiceA extends Service {

        private class MessageHandler extends Handler{  //创建的接受消息的handler
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what){
                    case 1:
                        Bundle bundle = msg.getData();
                        String str = bundle.getString("aaa");
                        System.out.println("----"+str);
                        Messenger replyTo = msg.replyTo; //此处往下是用来回复消息给客户端A的   
                        Message replyMsg = Message.obtain(null,2);
                        Bundle bundle1 = new Bundle();
                        bundle1.putString("bbb","remote222给主进程回复消息啦");
                        replyMsg.setData(bundle1);
                        try {
                            replyTo.send(replyMsg);
                        } catch (RemoteException e) {
                            e.printStackTrace();
                        }
                        break;
                }
                super.handleMessage(msg);
            }
        }
        Messenger messenger = new Messenger(new MessageHandler());
        public MyServiceA() {
        }
        
        public IBinder onBind(Intent intent) {
            return messenger.getBinder();
        }
    }

2.在客户端A自然是需要发送消息给服务端B的所以需要在服务绑定完成之后获取到binder对象之后用该对象构造一个Messenger对象然后用messenger发送
消息给服务端即可代码如下：

public void onServiceConnected(ComponentName name, IBinder service) {
                Messenger messenger = new Messenger(service);
                Message msg = Message.obtain(null,1);
                Bundle bundle = new Bundle();
                bundle.putString("aaa", "主进程给remote22进程发消息啦");
                msg.setData(bundle);
                msg.replyTo = mmessenger; //这行代码用于客户端A接收服务端请求 设置的消息接收者 
                try {
                    messenger.send(msg);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }

            }

3.由于在服务端接收到了客户端的消息还需要回复所以在服务端代码中获取 msg中的replyTo对象用这个对象发送消息给客户端即可
在客户端需要创建一个handler和Messenger 将发送的msg.replyTo设置成Messenger对象就可

4.AIDL android 接口定义语言 ---->主要用于调用远程服务的方法的情况还可以注册接口

使用方法很简单
在服务端定义aidl文件自动生成java文件然后在service中实现这个aidl 在onbind中返回这个对象
在客户端把服务端的aidl文件完全复制过来包名必须完全一致在onServiceConnected方法中把 Ibinder对象用asInterface方法转化成 aidl对象
然后调用方法即可

需要注意的地方：
在aidl文件中并不是支持所有类型
仅支持如下6种类型：
基本数据类型---- int long char boolean double
String charSequence
List 只支持ArrayList CopyOnWriteArrayList也可以。。里面元素也必须被aidl支持
Map 只支持HashMap ConCurrentHashMap也可以里面元素也必须支持aidl
Parcelable 所有实现了此接口的对象
AIDL 所有的AIDL接口因此如果需要使用接口必须使用AIDL接口

其中自定义的类型和AIDL对象必须显示import进来不管是不是在一个包中
如果AIDL文件中用到了自定义的Parcelable对象必须创建同名的AIDL文件并声明为Parcelable类型
AIDL文件中除了基本数据类型外其他类型必须标上方向 in out inout
AIDL接口中只支持方法不支持声明静态常量
在使用aidl时最好把所有aidl文件都放在一个包中这样方便复制到客户端
其实所有的跨进程对象传递都是对象的序列化与反序列化所以必须包名一致

现在加入有这样一个需求如果服务端是图书馆添加和查看书的任务客户端可以查看和添加书这时候需要添加一个功能当服务端每添加了一本书
需要通知客户端注册用户有一本新书上架了这个功能如何实现？
想想可知这是一个观察者模式如果在同一进程中很容易实现，只需要在服务端中的代码中维护一个集合里面放的是注册监听的用户然后用户需要实现一个新书到来的回调接口
当有新书上架时遍历这个集合调用每个注册者的接口方法即可实现
现在我们是跨进程通信所以自然不能如此简单了但也不是很复杂想一想其实就是把以往的接口定义变成了aidl接口定义然后其他的一样即可
但是这样还是存在一个问题如果注册了listener 我们又想解除注册是不是在客户端传入listener对象在服务端把它移除就可以呢？
其实是不可以的因为这是跨进程的所以对象并不是真正的传递只是在另一个进程中重新创建了一个一样的对象内存地址不同所以根本不是同一个对象
所以是不可以的如果要解决这个问题需要使用RemoteCallbackList 类不要使用CopyWriteArrayList
在RemoteCallBackList中封装了一个Map 专门用来保存所有的AIDL回调 key为IBinder value是CallBack 使用IBinder 来区别不同的对象，
因为跨进程传输时会产生很多个不同的对象但这些对象的底层的Binder都是同一个对象所以可以
在使用RemoteCallBackList时 add 变为 register remove 变为 unregister 遍历的时候需要先 beginBroadcast 这个方法同时也获取集合大小
获取集合中对象使用 getBoardCastItem(i) 最后不要忘记finishBoardCast方法

还有一个情况由于onServiceConnected方法是在主线程执行的如果在这里执行服务端的耗时代码会ANR 所以需要开启一个子线程执行
同理在服务端中也不可以运行客户端的耗时程序
总结起来就是在执行其他进程的耗时程序时都需要开启另外的线程防止阻塞UI线程如果要访问UI相关的东西使用handler

为了程序的健壮性有时候Binder可能意外死亡这时候需要重连服务有2种方法：
1.在onServiceDisconnected方法中重连服务
2. 给Binder注册DeathRecipient监听当binder死亡时我们可以收到回调这时候我们可以重连远程服务

最后有时候我们不想所有的程序都可以访问我们的远程服务所以可以给服务设置权限和过滤：
1.我们在onbind中进行校验用某种方式如果验证不通过那么就直接返回null
2.我们可以在服务端的AndroidManiFest.xml中设置所需的权限
<permission android:name="aaaaaa" android:protectionLevel="normal"/>
然后在onbind中检查是否有这个权限了如果没有那么直接返回null即可判断方法如下：


int check = checkCallingOrSelfPermission("aaa");
            if(check== PackageManager.PERMISSION_DENIED){
                return null;
            }

3.可以在onTransact方法中进行权限验证如果验证失败直接返回false 可以采用permission方法验证还可以用Uid和Pid验证很多方法

其中声明权限与添加权限的方式是在Service所在的AndroidMinifest中声明权限
比如
<permission android:name="com.zhxh.android_lb.myaidlpro.book" android:protectionLevel="normal"></permission>
然后在需要远程调用的 app中添加这个权限
<uses-permission android:name="com.zhxh.android_lb.myaidlpro.book"/>
这样就可以在 onbind中验证权限了

至此 AIDL 大体介绍完了以后需要在使用中提升了

aidl demo 下载： https://github.com/zhxhcoder/IPCdemo

5.ContentProvider方式实现对另一个应用进程开放provider数据的查询

此方法使用起来也比较简单底层是对Binder的封装使之可以实现进程间通信使用方法如下
1. 在需要共享数据的应用进程中建立一个ContentProvider类重写它的CRUD 和getType方法在这几个方法中调用对本应用进程数据的调用
然后在AndroidMinifest.xml文件中声明provider

 <provider 
                android:authorities="com.zhxh.book"  //这个是用来标识provider的唯一标识  路径uri也是这个
                android:name=".BookProdiver"
                android:process=":remote_provider"/>   //此句为了创建多进程  正常不需要使用

2. 在需要获取共享数据的应用进程中调用getContentResolver().crud方法即可实现数据的查询

需要注意的问题：
1.关于 sqlite crud的各个参数的意义
query函数参数
Cursor query(boolean distinct, String table, String[] columns,
String selection, String[] selectionArgs, String groupBy,
String having, String orderBy, String limit)
第一个参数 distinct 英语单词意思独特的如果true 那么返回的数据都是唯一的意思就是实现查询数据的去重
第二个参数 table 表名
第三个参数 columns 要查询的行的名字数组例如 new String[]{"id","name","sex"}
第四个参数 selection 选择语句 sql语句中where后面的语句值用？代替例如 "id=? and sex=?"
第五个参数 selectionArgs 对应第四个参数的 ? 例如 new String[]{"1","男"}
第六个参数 groupBy 用于分组
第七个参数 having 筛选分组后的数据
第八个参数 orderby 用于排序 desc/asc 升序和降序例如 id desc / id asc
最后一个参数 limit 用于限制查询的数据的个数默认不限制
其他几个函数根据query函数的参数猜想即可

2.由于每次ipc操作都是靠uri来区别想要获取的数据位置所以provider在调取数据的时候根据uri并不知道要查询的数据是在哪个位置
所以我们可以通过 UriMatcher 这个类来给每个uri标上号根据编号对应适当的位置例如：

public static final int BOOK_CODE = 0;
            public static final int USER_CODE = 1;
            public static UriMatcher matcher = new UriMatcher(UriMatcher.NO_MATCH);

            static {
                matcher.addURI("book uri", "book", BOOK_CODE);
                matcher.addURI("user uri", "user", USER_CODE);
            }
            这样我们可以通过 下面这个样子来获取位置（此处是表名 其他类型也一样）
            private String getTableName(Uri uri) {
                switch (matcher.match(uri)) {
                    case BOOK_CODE:
                        return "bookTable";
                    case USER_CODE:
                        return "userTable";
                }
                return "";
            }

3.另外ContentProvider除了crud四个方法外，还支持自定义调用通过ContentProvider 和ContentResolver的 call方法来实现

ContentProviderdemo下载：https://github.com/zhxhcoder/IPCdemo

6.Socket方法实现Ipc 这种方式也可以实现但是不常用

需要权限
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
这种方式需要一个服务端socket 和一个客户端socket 建立连接后通过流循环获取消息即可
1.在服务端开启一个serverSocket 不断获取客户端连接注意要在子线程中开启

ServerSocket serverSocket = new ServerSocket(8688);
        while(isActive) { //表示服务生存着
                try {
                    final Socket client = serverSocket.accept();  //不断获取客户端连接
                    System.out.println("---服务端已获取客户端连接");
                    new Thread(){
                        @Override
                        public void run() {
                            try {
                                dealWithMessageFromClient(client);  //处理客户端的消息 就是开启一个线程循环获取out 和 in  流 进行通信
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }.start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

2.在客户端开启一个线程使用ip和端口号连接服务端socket 连接成功后一样开启子线程循环获取消息处理

Socket socket = null;
                while(socket==null){  //失败重连
                    try {
                        socket = new Socket("localhost",8688);
                        out = new PrintWriter(socket.getOutputStream(),true);
                        handler.sendEmptyMessage(1);
                        final Socket finalSocket = socket;
                        new Thread(){
                            @Override
                            public void run() {
                                try {
                                    reader = new BufferedReader(new InputStreamReader(finalSocket.getInputStream()));
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                                while(!MainActivity.this.isFinishing()){  //循环获取消息  这里必须用 循环 否则 只能获取一条消息 服务端也一样
                                    try {
                                        String msg = reader.readLine();
                                        System.out.println("---"+msg);
                                        if (msg!=null){
                                            handler.sendMessage(handler.obtainMessage(2,msg));
                                        }
                                    } catch (IOException e) {
                                        e.printStackTrace();
                                    }
                                }
                            }
                        }.start();
                    } catch (IOException e) {
                        SystemClock.sleep(1000);
                        e.printStackTrace();
                    }
                }

7.Binder 连接池的使用很好用

我们在android中进程间通信一般都使用 AIDL实现因为它强大但是普通的使用方法每次使用AIDL 都需要开启一个服务如果有多个AIDL请求那岂不是要开启很多个服务
这明显是不可以的比如你让你用户的手机发现你这一个应用程序绑定了10个服务那是极差的所以我们在多个AIDL 请求的时候可以使用Binder连接池技术
只开启一个服务根据需要获取的AIDL不同转化成需要的AIDL 接口执行不同的方法
实现的基本原理就是在onbind中返回一个BinderPool 接口这个接口有个方法可以根据不同的标志位返回不同的aidl接口这样我们在asInTerface之后调用哪个方法
传入标志位即可返回需要的aidl接口
说起来简单让我们来实现一个试试吧
1.假设原来有2个AIDL接口需要实现(可以扩展成多个) 在服务端建立好AIDL文件并且建立一个IBinderPool aidl接口只有一个查询binder的方法用于查询需要的binder

interface IBinderPool {
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
IBinder queryBinder(int code);  //此方法返回Ibinder  用于转化成需要的AIDL接口
}

2.在服务端 onbind方法中返回 IBinderPool的实现类实现query方法按照传入的code 返回需要的ibinder

@Override
public IBinder onBind(Intent intent) {
return iBinderPool;
}
private Binder iBinderPool = new IBinderPool.Stub() {
@Override
public IBinder queryBinder(int code) throws RemoteException {
switch (code) {
  case 1:
return new IBookManger.Stub() {

@Override
public void getBook() throws RemoteException {
System.out.println("--->book");
}
};
  case 2:
return new IPersonManager.Stub() {

@Override
public void getPerson() throws RemoteException {
System.out.println("---->person");
}
};
}
return null;
}
};

3.客户端实现一个BinderPool类这个类主要是封装了 AIDL的一些实现方法方便调用罢了其中涉及到一个可以实现同步机制的类
CountDownLatch 这个类当他的值不是0的时候执行了await方法后会使方法一直停在await处不进行直到他的值变成了0 才可以继续执行
也就是说当执行了await方法这个线程就会阻塞等待这个数值变到0后继续执行
而在BinderPool中的应用场景是这样的

private void connectService(){
countDownLatch = new CountDownLatch(1);  //实现同步机制 
Intent intent = new Intent();
intent.setClass(ctx,MyService.class);
ctx.bindService(intent,connection,Context.BIND_AUTO_CREATE);
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

首先为什么在这里要使用同步机制我们要搞清楚让我们看这个方法调用的时机：

binderPool = BinderPool.getInstance(MainActivity.this);  //connectService方法 是在这个方法中调用的  
                IBinder iBinder = binderPool.queryBinder(2);
                iPersonManager = IPersonManager.Stub.asInterface(iBinder);
                try {
                    iPersonManager.getPerson();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }

因为我们最终的目的是在bind服务连接到远程服务之后获取到 binderPool对象调用它的 binderPool.queryBinder(2) 方法如果不加同步机制
异步执行就有可能在 connectService方法执行完之后执行IBinder iBinder = binderPool.queryBinder(2);这行代码的时候binderPool对象还
没有被赋值这样就会产生问题所以我们让 connectService方法阻塞当BinderPool中的 binderPool对象赋值之后让CountDownLatch的值countDown到0

这样 connectService方法就会继续执行然后执行下一行代码了

BinderPool demo下载：https://github.com/zhxhcoder/IPCdemo

最后针对这几种IPC通信方式分析一下优缺点

1.bundle ：
简单易用但是只能传输Bundle支持的对象常用于四大组件间进程间通信
2.文件共享：
简单易用但不适合在高并发的情况下并且读取文件需要时间不能即时通信常用于并发程度不高并且实时性要求不高的情况
3.AIDL ：
功能强大支持一对多并发通信支持即时通信但是使用起来比其他的复杂需要处理好多线程的同步问题常用于一对多通信且有RPC 需求的场合(服务端和客户端通信)
4.Messenger ：
功能一般支持一对多串行通信支持实时通信但是不能很好处理高并发情况只能传输Bundle支持的类型常用于低并发的无RPC需求一对多的场合
5.ContentProvider ：
在数据源访问方面功能强大支持一对多并发操作可扩展call方法可以理解为约束版的AIDL 提供CRUD操作和自定义函数常用于一对多的数据共享场合
6.Socket ：
功能强大可以通过网络传输字节流支持一对多并发操作但是实现起来比较麻烦不支持直接的RPC 常用于网络数据交换

总结

当仅仅是跨进程的四大组件间的传递数据时使用Bundle就可以简单方便
当要共享一个应用程序的内部数据的时候使用ContentProvider实现比较方便
当并发程度不高也就是偶尔访问一次那种进程间通信用Messenger就可以
当设计网络数据的共享时使用socket
当需求比较复杂高并发并且还要求实时通信而且有RPC需求时就得使用AIDL了
文件共享的方法用于一些缓存共享之类的功能

Android中实现IPC通信的8种方式

1.使用Bundle ----> 用于android四大组件间的进程间通信

2.使用文件共享 ---->用于单线程读写

3.使用Messenger ---->用于可存放在message中的数据的传递

4.AIDL android 接口定义语言 ---->主要用于调用远程服务的方法的情况 还可以注册接口

5.ContentProvider方式 实现对另一个应用进程开放provider数据的查询

6.Socket方法实现Ipc 这种方式也可以实现 但是不常用

7.Binder 连接池的使用 很好用

最后针对这几种IPC通信方式分析一下优缺点

总结

4.AIDL android 接口定义语言 ---->主要用于调用远程服务的方法的情况还可以注册接口

5.ContentProvider方式实现对另一个应用进程开放provider数据的查询

6.Socket方法实现Ipc 这种方式也可以实现但是不常用

7.Binder 连接池的使用很好用