Android进阶笔记04：Android进程间通讯（IPC）之Messenger

一、 Android进程间通讯之Messenger 的引入

（1）引言：

     平时一说进程间通讯，大家都会想到AIDL，其实messenger和AIDL作用一样，都可以进行进程间通讯。它是基于消息的进程间通信，就像子线程和UI线程发送消息那样，是不是很简单，还不用去写AIDL文件，是不是有点小爽。哈哈。此外，还支持记录客户端对象的Messenger，然后可以实现一对多的通信；甚至作为一个转接处，任意两个进程都能通过服务端进行通信。

（2） Messenger 与 AIDL 比较：

      当您需要执行 IPC 时，为您的接口使用 Messenger 要比使用 AIDL 实现更加简单，因为 Messenger 会将所有服务调用排入队列，而纯粹的 AIDL 接口会同时向服务发送多个请求，服务随后必须应对多线程处理。

　　Messenger 是以串行的方式处理客户端发来的消息的，这样一来，如果大量的消息同时发送到服务端，服务端仍然只能一个个处理，如果存在大量并发请求，那么使用Messenger就不太合适了。同时，Messenger的作用主要是为了传递消息，很多时候我们可能需要跨进程调用服务端的方法。这种情形用Messenger是无法做到的，但是我们可以使用AIDL来实现跨进程的方法调用。

　　Messenger的底层实现是AIDL，因此Messenger本质上也是AIDL，只不过系统为我们做了封装从而方便上层调用而已。

　　对于大多数应用，服务不需要执行多线程处理，因此使用 Messenger 可让服务一次处理一个调用。如果您的服务必须执行多线程处理，则应使用 AIDL 来定义接口。

二、  Messenger 的具体使用：

1. Messenger工作原理图：

2. 客户端发送消息给服务端（单向通信）

服务端：

　　（1）创建一个handler对象，并实现handlemessage方法，用于接收来自客户端的消息，并作处理 .

　　（2）创建一个messenger(送信人)，封装handler .

　　（3）messenger创建一个IBinder对象，通过onBind返回给客户端

客户端：

　　（1）在activity中绑定服务

　　（2）创建ServiceConnection并在其中使用 IBinder 将 Messenger实例化 

　　（3）使用Messenger向服务端发送消息

　　（4）解绑服务

　　（5）服务端中在 handleMessage() 方法中接收每个 Message

这样，客户端并没有调用服务的"方法"。而客户端传递的"消息"（Message 对象）是服务在其 Handler 中接收的。

上面实现的仅仅是单向通信，即客户端给服务端发送消息。

3. 客户端与服务端双向通信

如果我需要服务端给客户端发送消息又该怎样做呢？

其实，这也是很容易实现的，下面就让我们接着上面的步骤来实现双向通信吧：

　　（1）在客户端中创建一个Handler对象，用于处理服务端发过来的消息。

　　（2）创建一个客户端自己的messenger对象，并封装handler。

　　（3）将客户端的Messenger对象赋给待发送的Message对象的replyTo字段。

　　（4）在服务端的Handler处理Message时将客户端的Messenger解析出来，并使用客户端的Messenger对象给客户端发送消息。

这样就实现了客户端和服务端的双向通信了。

注意：

　　注：Service在声明时必须对外开放，即android:exported="true"

　　　　是不是看的头晕，忘掉吧，直接看下面。

三、代码示例：

（1）服务端service：

 public class MyService extends Service {
     private static final int CODE = 1;
     public MyService() {
     }
     @Override
     public IBinder onBind(Intent intent) {
         return mMessenger.getBinder();
     }

     //创建一个送信人，封装handler
     private Messenger mMessenger = new Messenger(new Handler() {
         @Override
         public void handleMessage(Message msg) {
             Message toClient = Message.obtain();
             switch (msg.what) {
                 case CODE:
                     //接收来自客户端的消息，并作处理
                     int arg = msg.arg1;
                     Toast.makeText(getApplicationContext(),arg+"" , Toast.LENGTH_SHORT).show();
                     toClient.arg1 = 1111111111;
                     try {
                         //回复客户端消息
                         msg.replyTo.send(toClient);
                     } catch (RemoteException e) {
                         e.printStackTrace();
                     }
             }
             super.handleMessage(msg);
         }
     });
 }

此外，还应该在AndroidManifest.xml中指定如下：

<service android:name=".MessengerService"
            android:process=":remote"></service>

（2）客户端

 package com.zixue.god.fuck;

 import android.content.ComponentName;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.Messenger;
 import android.os.RemoteException;
 import android.support.v7.app.AppCompatActivity;
 import android.util.Log;
 import android.view.View;
 import android.widget.Button;
 import android.widget.Toast;

 public class MainActivity extends AppCompatActivity {
     private boolean mBond;
     private Messenger serverMessenger;
     private MyConn conn;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         //绑定服务
         Intent intent = new Intent();
         intent.setAction("com.zixue.god.myapplication.server");
         conn = new MyConn();
         bindService(intent, conn, BIND_AUTO_CREATE);
         Button button = (Button) findViewById(R.id.bt);
         button.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                 Message clientMessage = Message.obtain();
                 clientMessage.what = 1;
                 clientMessage.arg1 = 12345;
                 try {
                     clientMessage.replyTo = mMessenger;
                     serverMessenger.send(clientMessage);
                 } catch (RemoteException e) {
                     e.printStackTrace();
                 }
             }
         });
     }

     private class MyConn implements ServiceConnection {

         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
             //连接成功
             serverMessenger = new Messenger(service);
             Log.i("Main", "服务连接成功");
             mBond = true;
         }

         @Override
         public void onServiceDisconnected(ComponentName name) {
             serverMessenger = null;
             mBond = false;
         }
     }

     // 1 为客户端实例化一个Messenger,用于处理从服务端传递过来的数据
     private Messenger mMessenger = new Messenger(new Handler(){
         @Override
         public void handleMessage(Message msg) {
             Toast.makeText(getApplicationContext(),msg.arg1+"",Toast.LENGTH_SHORT).show();
             super.handleMessage(msg);
         }
     });

     @Override
     protected void onDestroy() {
         if (mBond) {
             unbindService(conn);
         }
         super.onDestroy();
     }

 }

客户端也比较简单，在onCreate方法中，进行绑定服务（注意：这种方式前面说过了，不应该在主线程进行IPC操作，因为这是耗时的，这里为了方便才写在主线程）。然后在onServiceConnected()中，利用返回的service创建了一个Messenger，然后执行一系列的数据打包、存放、发送操作。

（3）总结：

1）传递的数据必须是Bundle所支持的数据类型，如果是新的数据类型必须实现Parcelable接口或者Serializable接口。
2）接受消息的一端必须要有一个处理消息的Handler，Handler通常作为参数用于实例化一个Messenger。
3）如果服务端需要返回数据给客户端，那么在客户端中，需要把客户端自己的Messenger传递进msg.replyTo，这样服务器才能从msg.replyTo中取出特定的Messenger，从而返回信息。
4）在一次完整的进程间通讯（包括客户端的收发和服务端的收发）中，使用了两个不同的Messenger，第一个Messenger是用服务端返回的IBinder对象进行实例化的，这个用于从客户端发送数据到服务端；第二个Messenger是Handler实例化的，这个用于从服务端发送数据到客户端。