第二章-IPC机制-Android中的各种IPC方式（Bundle、文件共享、Messenger）

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