进程间通信---Messenger

Messenger

         概念

                 可以翻译为信使，通过它可以在不同进程中传递消息（Message）对象，在Message中放入需要传递的数据，就可以实现数据的进程间传递。Messenger是一种轻量级的IPC(进程间通信)方案，它的底层实现是AIDL,看一下Messenger的构造方法，能明显看到有AIDL的痕迹。如下： 

 public Messenger(Handler target) {
        throw new RuntimeException("Stub!");
    }

    public Messenger(IBinder target) {
        throw new RuntimeException("Stub!");
    }

          作用

                 实现进程间的通信。

           用法   

客户端：

public class MainActivity extends Activity {
    private static final String TAG="MainActivity";
    private Messenger mService;//（服务端信使）
    //用于接受服务端消息的信使（客户端信使）
    private Messenger mGetReplayMessenger= new Messenger(new MessengerHandler());
    private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case Constants.MSG_FROM_SERVICE:
                    Log.d(TAG,"客户端收到来自服务端的消息=== "+msg.getData().getString("replay"));
                    break;
                default:
                    break;
            }
            super.handleMessage(msg);
        }
    }
    private ServiceConnection conn=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //实例化服务端信使
            mService=new Messenger(service);
            Log.d(TAG,"bind service");
            //第二个参数what，可以表明是来自客户端
            Message msg = Message.obtain(null, Constants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg","客户端：你好，服务端，最近忙吗");
            msg.setData(data);
            //说明来自客户端
            //注意这里，把`Activity`的`Messenger`赋值给了`message`中，当然可能你已经发现这个就是`Service`中我们调用的`msg.replyTo`了。
            msg.replyTo=mGetReplayMessenger;
            try {
                //服务短信使发送
                mService.send(msg);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };
/*
*
* 服务一旦绑定成功，客户端先发送一个消息，服务端回复一个消息
* */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent("com.ljt.messenger.messengerservice");
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
    }
    @Override
    protected void onDestroy() {
        //传conn对象 实质是只是与服务解绑，服务并没有销毁。
        unbindService(conn);
        super.onDestroy();
    }
}

  服务端：

public class MessengerService extends Service {
    private static String TAG="MessengerService";
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
               case Constants.MSG_FROM_CLIENT:
                   Log.d(TAG, "服务端收到来自客户端的消息=== " + msg.getData().getString("msg"));
                    //声明一个客户端信使
                   Messenger client=msg.replyTo;
                   Message replayMessage = Message.obtain(null, Constants.MSG_FROM_SERVICE);
                   Bundle bundle = new Bundle();
                   bundle.putString("replay","服务端：最近很忙，一直在处理消息");
                   replayMessage.setData(bundle);
                   try {
                       //用客户端信使传消息
                       client.send(replayMessage);
                   }catch (RemoteException e){
                       e.printStackTrace();
                   }
                   break;
               default:
                   super.handleMessage(msg);
           }
        }
    }

常量：

public class Constants {
    public static final int MSG_FROM_CLIENT = 0;
    public static final int MSG_FROM_SERVICE = 1;
}

        运行结果

                       

  代码链接:

https://github.com/HotBloodMan/MessengerDemo