我们了解了IPC的几个基础知识:序列化和Binder,本节详细分析各种跨进程通信方式。具体方式有很多,比如可以通过在Intent中附加extras来传递消息,或者通过共享文件的方式来共享数据,还可以采用Binder方式来跨进程通信,另外,ContentProvider天生就是支持跨进程访问的。通过Socket也可以实现IPC,上述的各种方法都能实现IPC,他们的使用方式和侧重点上有很大的区别,我们在这里都会一一展开。
1、使用Bundle
2、使用文件共享
文件共享是一种不错的进程间通讯的方式,两个进程通过读/写同一个文件来交换数据,比如A进程把数据写入文件,B再去读取,我们知道,在Windows上,一个文件如果被加了排斥锁将会导致其他线程无法对其访问,甚至两个线程同时进度写的操作也是不允许的,尽管这可能出问题,通过文件交换数据很好使用,除了可以交换一些文本信息外,我们还可以序列化一个对象到文件里,引用的时候再恢复,下面就来展示下这种使用方法。
还是本章的例子,在onResume序列化一个对象到sd卡,第二个Activity去恢复,关键代码如下:
MainActivity.java
//保存对象到文件
private void persistToFile() {
new Thread(new Runnable() {
@Override
public void run() {
User user = new User("1", "hello world", false);
File dir = new File(PATH);
if (!dir.exists()) {
dir.mkdir();
}
File cachedFile = new File(PATH);
ObjectOutputStream objectOutputStream = null;
try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream(cachedFile));
objectOutputStream.writeObject(user);
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
}
SecondActivity.java
//从文件恢复对象
private void recoverFromFile() {
new Thread(new Runnable() {
@Override
public void run() {
User user = null;
File cachedFile = new File(MainActivity.PATH);
if(cachedFile.exists()){
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream(cachedFile));
user = (User) objectInputStream.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}).start();
}
当然,SharedPreferences是个特例,众所周知,SharedPreferences是Android中提供的轻量级存储方案,它通过键值对的方式来存储数据,在底层实现上它采用XML文件来存储键值对,每个应用的SharedPreferences文件都可以在当前包所在的data目录下查看到。一般来说,它的目录位于/data/data/package
name/shared_prefs目录下,其中package
name表示的是当前应用的包名。从本质上来说,SharedPreferences也属于文件的一种,但是由于系统对它的读/写有一定的缓存策略,即在内存中会有一份SharedPreferences文件的缓存,因此在多进程模式下,系统对它的读/写就变得不可靠,当面对高并发的读/写访问Sharedpreferences有很大几率会丢失数据,因此,不建议在进程间通信中使SharedPreferences。
3、使用Messenger(使用的不多)
Messenger可以翻译为信使,顾名思义,通过它可以在不同进程中传递Message对象,在Message中放入我们需要传递的数据,就可以轻松地实现数据的进程间传递了。Messenger是一种轻量级的IPC方案,它的底层实现是AIDL,为什么这么说呢,我们大致看一下Messenger这个类的构造方法就明白了。下面是Messenger的两个构造方法,从构造方法的实现上我们可以明显看出AIDL的痕迹,不管是IMessenger还是Stub.asInterface,这种使用方法都表明它的底层是AIDL。
2个构造方法
public Messenger(Handler target) {
mTarget = target.getIMessenger();//从Handler中拿到Messenger对象,是一个Binder
}
public Messenger(IBinder target){
mTarget = IMessenger.Stud.asInterface(target);//将target转化成Binder对象
}
Messenger的使用方法很简单,它对AIDL做了封装,使得我们可以更简便地进行进程间通信。同时,由于它一次处理一个请求,因此在服务端我们不用考虑线程同步的问题,这是因为服务端中不存在并发执行的情形。实现一个Messenger有如下几个步骤,分为服务端和客户端。
a、服务端进程
首先,我们需要在服务端创建一个Service来处理客户端的连接请求,同时创建一个Handler并通过它来创建一个Messenger对象,然后在Service的onBind中返回这个Messenger对象底层的Binder即可。
看服务端的代码,这是服务端的典型代码,可以看到MessengerHandler用来处理客户端发送的消息,并从消息中取出客户端发来的文本信息,而mMessenger是一个Mwsswnger对象,他和MessengerHandler相关联,并在onBind方法中返回他里面的IBind对象
public class MessengerService extends Service {
public static final String TAG = "MessengerService";
//定义一个静态内部类,处理消息;
private static class MessengerHandler extends Handler{
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_FROM_CLIENT:
Log.i(TAG,"receive msg from Client:" + msg.getData().getString("msg"));
break;
default:
super.handleMessage(msg);
}
}
}
//定义一个Messenger对象,将处理消息的Handler带上,客户端拿到Messenget对象也就可以将消息发送到这个handler处理了。
private final Messenger mMessenger = new Messenger(new MessengerHandler());
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();//返回Messenger里面的Binder对象
}
}
然后注册下这个Service,让其在独立进程中运行
<service android:name=".MessengerService"
android:process=":remote"/>
b、客户端进程
客户端进程中,首先要绑定服务端的Service,绑定成功后用服务端返回的IBinder对象创建一个Messenger,通过这个Messenger就可以向服务端发送消息了,发消息类型为
Message对象。如果需要服务端能够回应客户端,就和服务端一样,我们还需要创建一个Handler并创建一个新的Messenger,并把这个Messenger对象通过Message的replyTo参数传递给服务端,服务端通过这个replyTo参数就可以回应客户端。这听起来可能还是有点抽象,不过看了下面的两个例子,读者肯定就都明白了。首先,我们来看一个简单点的例子, 这个例子中服务端无法回应客户端。
接下来我们看看客户端,客户端比较简单
public class MessengerActivity extends AppCompatActivity {
public static final String TAG = "MessengerActivity";
private Messenger mService;//定义一个客户端的Messenger对象
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//步骤2:绑定成功后,根据服务端返回的binder对象创建Messenger对象。
mService = new Messenger(service);
Message msg = Message.obtain(null,MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("msg","hell this is client");
msg.setData(data);
try {
mService.send(msg);//步骤3:使用Messenger发送一个文本消息。
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onCreate( Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_messenger);
//步骤1:绑定服务
Intent intent = new Intent(this,MessengerService.class);
bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
super.onDestroy();
//步骤4:解绑服务
unbindService(mConnection);
}
}
下面演示如何在服务器端回一个消息给客户端
上面的例子演示了如何在服务端接收客户端中发送的消息,但是有时候我们还需要能回应客户端,下面就介绍如何实现这种效果。还是采用上面的例子,但是稍微做一下修改,每当客户端发来一条消息,服务端就会自动回复一条“嗯,你的消息我已经收到,稍后回复你。”,这很类似邮箱的自动回复功能。
服务端修改:
服务端只需要修改MessengerHandler,当收到消息后,会立即回复一条消息给客户端。
private static class MessengerHandler extends Handler{
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_FROM_CLIENT:
Log.i(TAG,"receive msg from Client:" + msg.getData().getString("msg"));
//下面是增加的修改的内容,从客户端msg的replyTo中拿到客户端的Messenger
Messenger messenger = msg.replyTo;
Message reply = Message.obtain(null,MSG_FROM_SERVER);
Bundle bundle = new Bundle();
bundle.putString("reply","收到你的消息,等下回复");
try {
messenger.send(reply);//回应客户端
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
}
客户端修改1:
接着我们来看看客户端的修改,为了接受服务端的恢复,客户端也需要准备一个接收消息的Messenger和handler,如下所示:
//客户端需要定义一个接受消息的Messenger和Handler
private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
private static class MessengerHandler extends Handler{
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MSG_FROM_SERVER:
Log.i(TAG,"receive msg from Server:" + msg.getData().getString("reply"));
break;
default:
super.handleMessage(msg);
}
}
}
客户端修改2:
除了上述的修改,还有关键的一点,当客户端发送消息的时候,需要把接收服务端回复的Messenger通过Message的replyTo参数传递给服务端,如下:
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = new android.os.Messenger(service);
Message msg = Message.obtain(null,MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("msg","hell this is client");
//注意这句话
msg.replyTo = mGetReplyMessenger;
msg.setData(data);
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
通过上述的修改,我们再次运行,就达到了自动回复的效果了;
到这里,我们采用Messenger进程通讯的例子就说完了,我们画一张工作原理图,这样更加便于理解: