android基于Messenger的进程间通信

Messenger可以翻译为信使，顾名思义，通过它可以在不同进程中传递Message对象，在Messenger中放入我们需要传递的数据，就可以轻松地实现数据的进程间传递。Messenger是一种轻量级的IPC方案，它的底层实现是AIDL。 

Messenger的使用方法很简单，它对AIDL做了封装，使得我们可以更简便地进行进程间通信。同时，由于它一次处理一个请求，因此在服务端我们不用考虑线程同步问题，这是因为服务端中不存在并发执行的情形。实现一个Messenger有如下几个步骤，分为服务端和客户端。 

1.服务端进程 

首先，我们需要在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler并通过它来创建一个Messenger对象，然后在Service的onBind中返回这个Messenger对象底层的Binder即可。  

2.客户端进程  

客户端进程中，首先要绑定服务端的Service,绑定成功后用服务端返回的IBinder对象创建一个Messenger,通过这个Messenger就可以向服务端发送消息了，发送消息类型为Message对象。如果需要服务端能够回应客户端，就和服务端一样，我们还需要创建一个Handler并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务端，服务端通过这个replyTo参数就可以回应客户端。  

首先看服务端代码，这是服务端的典型代码，可以看到MessengerHandler用来处理客户端发送请求消息，并从消息中取出客户端发来的文本信息。而mMessenger是一个Messenger对象，它和MessengerHandler相关联，并在onBind方法中返回它里面的Binder对象，可以看出，这里Messenger的作用是将客户端发送的消息传递给MessengerHandler处理。

public class MessengerService extends Service {
    public MessengerService() {
    }

    private static final String TAG = "MessengerService" ;

    private  static  class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MyContants.MSG_FROM_CLIENT:
                    Log.i(TAG , "receive msg from Client:"+msg.getData().getString("msg"));
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }

        }
    }
    private Messenger messenger = new Messenger(new MessengerHandler());
    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
//        throw new UnsupportedOperationException("Not yet implemented");
        return messenger.getBinder();
    }
}

然后注册service .让其运行在单独的进程中。

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

如何指定service运行在单独进程中，本章节先不做叙述。接下来看客户端的实现，客户端的实现别加简单，首先需要绑定远程进程的MessengerService ,绑定成功后，根据服务端返回的binder 对象创建Messenger对象并使用此对象向服务端发送消息。下面的代码在Bundle 中向服务端发送了一句话，在上面的服务端代码中会打印出这句话。

public class MainActivity extends AppCompatActivity {

    private static final String  Tag = "MessengerActivity";

    private Messenger mService ;

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mService  = new Messenger(iBinder);
            Message msg  = Message.obtain(null , MyContants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg" , "hello , this is client");
            msg.setData(data);
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent   = new Intent(this , MessengerService.class);
        bindService(intent , mConnection , Context.BIND_AUTO_CREATE);

    }

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

最后，我们运行程序，看一下log，很显然，服务端成功收到了客户端所发出的问候语句“hello , this is client”

上面的例子演示了如何在服务器接收客户端中发送的消息，但是有时候我们还需要回应客户端，下面介绍如何实现这种效果。

首先看服务端的修改，服务端只需要修改MessengerHandler，当收到消息后，会立即回复一条消息给客户端。

private  static  class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MyContants.MSG_FROM_CLIENT:
                    Log.i(TAG , "receive msg from Client:"+msg.getData().getString("msg"));
                    Messenger client = msg.replyTo;
                    Message relpyMessage = Message.obtain(null , MyContants.MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply","恩，你的消息我已经收到");
                    relpyMessage.setData(bundle);
                    try {
                        client.send(relpyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }

        }
    }

接着再看客户端的修改，为了接收服务端的回复，客户端也需要准备一个接收消息的Messenger和Handler,如下所示。

mService  = new Messenger(iBinder);
            Message msg  = Message.obtain(null , MyContants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg" , "hello , this is client");
            msg.setData(data);
            //注意这句
            **msg.replyTo = mGetReplyMessenger;**
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

        }

到这里，我们已经把采用Messenger进行进程间通信的方法都介绍完了。