Messenger的使用和理解

Messenger
Messenger就是基于Message的进程间通信,也就是我们可以向在线程间利用Handler.send(Message)一样，所以用起来是非常简单的。
Messenger的使用
Service服务端
首先，我们写一个服务端Service：

public class MyService extends Service {
    public final static String TAG = "MyService";

    public final static int SERVICEID = 0x0001;
    private Messenger messenger = new Messenger(new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (msg.arg1 == SERVICEID) {
              //接受从客户端传来的消息
                Log.d(TAG, "客服端传来的消息===>>>>>>");
                String str = (String) msg.getData().get("content");
                Log.d(TAG, str);

                //发送数据给客户端
                Message msgTo = Message.obtain();
                msgTo.arg1 = 0X0002;
                Bundle bundle = new Bundle();
                bundle.putString("content", "我是从服务器来的字符串");
                msgTo.setData(bundle);
                try {
                    //注意，这里把数据从服务器发出了
                    msg.replyTo.send(msgTo);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    });

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreat");
    }

    @Override
    public IBinder onBind(Intent intent) {
        return messenger.getBinder();
    }
}

看看我们的Service服务端，可谓是真的很简单，我们首先创建了一个Messenger，在Messenger的构造函数中传入了一个Handler对象。然后在onBind方法中返回了一个messenger.getBinder()。
我们注意到在Handler中我们接受到消息后又给客户端发送了一条消息msg.replyTo(msgTo)。Messnger是可以相互发送消息的。当然，这也就要求在客户端和服务端都有自己的Messnger。
最后，我们要么就直接安装运行Service，要么就注册Service的时候加上Process属性，因为我们要测试的是跨进程通信了。

public class MainActivity extends AppCompatActivity {

public final static int ACTIVITYID = 0X0002;
 //客户端的Messnger
 private Messenger aMessenger = new Messenger(new Handler() {
     @Override
     public void handleMessage(Message msg) {
         super.handleMessage(msg);
         if (msg.arg1 == ACTIVITYID) {
          //客户端接受服务端传来的消息
             Log.d(TAG, "服务端传来了消息=====>>>>>>>");
             String str = (String) msg.getData().get("content");
             Log.d(TAG, str);
         }
     }
 });

//服务端传来的Messenger
 Messenger sMessenger;

 ServiceConnection serviceConnection = new ServiceConnection() {
     @Override
     public void onServiceConnected(ComponentName name, IBinder service) {
         sMessenger = new Messenger(service);

         Message message = Message.obtain();
         message.arg1 = 0x0001;
         //注意这里，把`Activity`的`Messenger`赋值给了`message`中，当然可能你已经发现这个就是`Service`中我们调用的`msg.replyTo`了。
         message.replyTo = aMessenger;

         Bundle bundle = new Bundle();
         bundle.putString("content", "我就是Activity传过来的字符串");
         message.setData(bundle);

         try {
           //消息从客户端发出
             sMessenger.send(message);
         } catch (RemoteException e) {
             e.printStackTrace();
         }
     }

     @Override
     public void onServiceDisconnected(ComponentName name) {
         Log.e(TAG, "连接Service失败");
     }
 };

 @Override
 protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
     startAndBindService();
 }

 private void startAndBindService() {
     Intent service = new Intent(MainActivity.this, MyService.class);
     startService(service);
     bindService(service, serviceConnection, Context.BIND_AUTO_CREATE);
 }
}

在这里我们把serviceConnection成功返回的IBinder转换成的是Messnger，接着就调用而messenger.send(message);,就这样，我们的消息就发送出了，和同一线程里面的消息发送几乎一样，只是这里的handmessage(Message message)是在不同的进程。
当然，为了接受从服务端发来的消息，我们在Activity中定义了一个Messenger,并且在客户端发给服务端的消息（Message）中把客户端的Messenger给赋值进Message中。

就这样，最简单的Messenger就完成了。

这种情况在我们的项目中也是经常可见的，例如，你下载一个很大的东西时，就直接开一个进程去下，下载完成后再将文件路径给发送给客户端......当然，这个demo中我们什么都没有去处理就直接返回了，在服务端是会有逻辑的，这里就没有过多的演示了。

Messenger的理解

首先，我们还是从Service中看起,还记得我们在Service中new了一个Messenger并且传入了一个Handler吧，然后在onBind()方法中就返回了一个messenger.getBinder()：

public IBinder getBinder() {
    return mTarget.asBinder();
}

一看，里面返回的就是mTarget.asBinder(),然后我们就找找mTarget：

public Messenger(Handler target) {
      mTarget = target.getIMessenger();
  }

结果在Messenger的构造函数中发现了target.getIMessenger(),继续，我们看看Handler中的这个方法：

final IMessenger getIMessenger() {
      synchronized (mQueue) {
          if (mMessenger != null) {
              return mMessenger;
          }
          mMessenger = new MessengerImpl();
          return mMessenger;
      }
  }

  private final class MessengerImpl extends IMessenger.Stub {
      public void send(Message msg) {
          msg.sendingUid = Binder.getCallingUid();
          Handler.this.sendMessage(msg);
      }
  }

由源码我们发现MessengerImpl就是Hnadler的一个内部类，然后继承于IMessenger.Stub。看到这里，或许就已经发现了，这和aidl中生成的类不是一样的吗？的确，这里就是实现的一个aidl文件。在这个类中，实现了以一个send方法，这个方法中调用了Handler.sendMessage()方法，这也就是为什么，我们的消息来得时候会出现在handlerMessage()中。这里，我们在理一下，客户端在调用send方法的时候，由于在不同的进程，传送的数据先回被序列化，然后进行跨进程传送，最后到了服务端进行解析，对应调用send方法执行。

不知道是否还记得，我们在用aidl通信的时候，我们在Service中首先要生成一个XXXX.Stub的实现类，然后再在onBind()中返回一个XXXX.Stub的引用。
现在我们在回首看一下，我们在Service中返回的mTarget.asBinder()其实就是MessengerImpl,当然asBinder()返回的就是自己本身。

当然，还有个问题我们得注意，就是服务端给客户端发送的消息。从demo中我们知道，我们在Serivice中使用msg.replyTo.send(msgTo);进行向客户端发送消息。而msg的replyTo这个属性在客户端中就是由客户端生成的Messenger。其实这里也是好理解的，首先，我们这里的跨进程主要就是通过Binder的，即我们在客户端和服务端传递Binder来进行通信。而这里的Messnger也就是一个包装了的Binder。

aidl实现双向通信

看了Messenger的实现方式，我们想一下用aidl来实现客户端与服务端的双向通信也是很容易的。
1.我们在服务端aidl定义一个方法，接受一个Binder。
2.在客户端中我们也通过aidl生成一个Binder,然后当我们通过ServicConnection获取到服务端的Binder后，再调用接受Bindler的那个方法，并把客户端中生成的Binder给传进去。
3.服务端相应客户端请求的方法时，在调用客户端Binder发送消息即可。

作者：MathiasLuo
链接：https://www.jianshu.com/p/af8991c83fcb
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。