Android 开发艺术探索笔记（五） 之 Android 中的 IPC 方式

Android 中进行 IPC 的方式有很多，比如 在 Activity 或者广播中用 Intent 传递小数据、共享文件、Binder、ContentProvider、Socket。下面详细介绍一下各种方式。

1.使用 Bundle

Android 的 Activity 、Service 、Recriver 支持在 Intent 中传递 Bundle 数据，由于 Bundle 实现了 Parcelable 接口，所以当我们在一个进程启动另一个进程的 Activity 、Service 、Receiver 后，我们可以在 Bundle 中附加我们需要传递的数据，其中包括基本数据类型、实现了 Parcelable 或者 Serializable 接口的对象还有一些 Android 支持的特殊对象。

2.使用文件共享

两个进程通过读/写同一个文件来交换数据也可以进行 IPC 。但是注意从文件中反序列化得到的对象和原来序列化的对象不是同一个对象，他们只是内容相同而已。这种方式适合在对数据同步要求不高的进程之间进行通信，并且要妥善处理并发的读/写问题。

PS： 使用 SharePrefrences 在面对高并发的读/写访问的情况下，会有很大几率会丢失数据，因此 IPC 不建议使用 SharePrefrences 。

3.使用 Messenger

Messenger 其实是封装好的 AIDL ，而且由于它一次只处理一个请求，因此在服务端不需要考虑线程同步的问题。

下面我们来使用一下 Messenger 。

• 1）建立服务端进程

  我们在服务端创建一个 Service 来处理客户端的连接请求，并且通过创建一个 Handler 来构建服务端的 Messenger 对象，然后在 Service 的 onBind（）中返回服务端 Messenger 的 Binder 对象，可以理解成：我（服务端）将可以和我通信的工具（Binder）经过我的 Messenger 包装后，发给你（客户端），你通过这个工具包装成一个 Messenger 对象才可以发消息给我。

  如果服务端想要回复客户端消息，就要客户端在发送过来的 Message 中包含一个用于回复客户端的 Messenger 对象，服务端收到这个对象后用这个对象发送消息返回给客户端。

  服务端的源码：https://github.com/innovatorCL/IPCServer

  show my code ：

  /**
   *
   * 使用 Messenger 方式的服务端
   * Created by innovator on 2018/1/24.
   */
  
  public class MessengerService extends Service{
  
  
  private static final String TAG = "TAG";
  
  private static class MessengerHandler extends Handler {
      @Override
      public void handleMessage(Message msg) {
          switch (msg.what){
              case MyConstants.MSG_FROM_CLIENT:
                  Log.i(TAG,"服务端收到客户端发来的消息："+msg.getData().getString("msg"));
  
                  //接收 客户端 传过来的 Messenger，用来回复 客户端
                  Messenger clientMessenger = msg.replyTo;
                  Message message = Message.obtain(null,MyConstants.MSG_REPLY_TO_CLIENT);
                  Bundle data = new Bundle();
                  data.putString("msg","你好，我是服务器，很高兴能和你对话");
                  message.setData(data);
  
                  try{
                      clientMessenger.send(message);
                  }catch (RemoteException e){
                      Log.i(TAG,"服务端回应客户端异常："+e.getMessage());
                  }
                  break;
  
              default:
                  break;
          }
          super.handleMessage(msg);
      }
  }
  
  //构造服务器的 Messenger
  private final Messenger messenger = new Messenger(new MessengerHandler());
  
  
  //连接客户端的时候返回服务器的Binder对象给客户端
  @Nullable
  @Override
  public IBinder onBind(Intent intent) {
      return messenger.getBinder();
  }
  }
  

• 2）建立客户端进程

  我们在客户端中首先要绑定服务端的 Service，绑定成功后，通过服务端返回的 Binder 对象构造客户端的 Messenger， 这样就可以通过这个 Messenger 来给服务端发送消息了，发送的消息类型是 Message 对象。可以看到，用 Messenger 方式进行 IPC 的灵魂人物是 Binder，这个其实就是 Messenger 和 AIDL 底层的东西。

  上面只是客户端发送消息给服务端需要做的事，如果服务端需要回应客户端，就要在客户端创建一个新的 Handler，然后通过这个 Handler 来创建一个新的 Messenger对象，然后将这个新的 Messenger 对象放在上面客户端给服务端发送的 Message 里面(将这个新的 Messenger 作为 Message 的 replyTo（）方法的参数就可以了)。 当服务端拿到这个客户端传过来的 Messenger 对象，就可以给客户端发送消息了。

  客户端的源码：https://github.com/innovatorCL/IPCClient

show my code

public class MessengerActivity extends AppCompatActivity {

  private static final String TAG = "MessengerActivity";

  //将从服务器获取到的 Binder 对象包装成自己的 Messenger 对象，从而给服务端发送消息
  private Messenger mMessenger = null;
  private static final int SAY_HELLO = 0;
  private boolean mBound = false;

  private ServiceConnection connection = new ServiceConnection() {
      @Override
      public void onServiceConnected(ComponentName name, IBinder service) {
          Log.i("TAG","通过 Messenger 连接服务器成功");
          mBound = true;
          //根据服务器返回的 Binder 对象创建 Messenger 对象，并使用这个对象向服务器发送数据
          mMessenger = new Messenger(service);
      }

      @Override
      public void onServiceDisconnected(ComponentName name) {
          Log.i("TAG","断开与服务器的连接");
          mBound = false;
      }
  };

  //构造用于服务器回复客户端的Handler
  private static class ReplyMessengerHandler extends Handler{
      @Override
      public void handleMessage(Message msg) {
          switch (msg.what){
              case MSG_REPLY_TO_CLIENT:
                  Log.i("TAG","客户端接收到了服务端通过 Messenger 发送过来的消息："+msg.getData().getString("msg"));
                  break;
              default:
                  super.handleMessage(msg);
                  break;
          }
      }
  };

  //构造用于服务器回复客户端的 Messeenger
  private Messenger mReplyMessenger = new Messenger(new ReplyMessengerHandler());

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_messenger);
      attempToBind();

  }

  @Override
  protected void onStart() {
      super.onStart();
      attempToBind();
  }

  @Override
  protected void onDestroy() {
      unbindService(connection);
      super.onDestroy();
  }

  private void attempToBind(){
      if(!mBound){
          Intent i = new Intent();
          i.setAction("com.innovator.messenger");
          i.setPackage("com.innovator.ipcserver");
          bindService(i,connection, Context.BIND_AUTO_CREATE);
      }
  }

  public void sayHello(View v){
      if(mMessenger == null){
          attempToBind();
          return;
      }

      if(mMessenger != null){
          Message message = Message.obtain(null,SAY_HELLO);
          Bundle data = new Bundle();
          data.putString("msg","你好，这是在客户端发送给你的消息");
          message.setData(data);

          //将可以回复自身（客户端）的工具 mReplyMessenger 传给 服务端
          message.replyTo = mReplyMessenger;

          try {
              mMessenger.send(message);
          }catch (RemoteException e){
              Log.i("TAG","客户端发送信息异常："+e.getMessage());
          }
      }
  }
}

• 调试的结果：

1.当客户端连接到服务端的 Service ，然后给服务端发送消息时，服务端打印的 Log ：

服务端 Log

2.客户端打印的 Log ：

客户端 Log

• 总结一下

Messenger 方式是以串行的方式处理客户端发送的消息的，如果有大量消息同时发送到服务端，服务端仍然只能一个一个处理，所以当有大量的并发请求，使用 Messenger 就不太合适了。同时，Messenger 只能用来传递消息，不能跨进程调用服务端的方法，这种情况也不适合使用 Messenger。

4.使用 ContentProvider

本次讲的内容已经比较多了，相信看到这里的同学应该已经疲劳了，ContentProvider 和 Socket 的内容比较多，我们放在下一节来看吧。