我们了解了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进程通讯的例子就说完了，我们画一张工作原理图，这样更加便于理解：
