第二章 IPC机制详解(2)

本文为Android开发艺术探索的笔记，仅供学习

4 IPC的使用方法

前面我们也讲解了IPC的三个基本概念，Serializable 、Parcelable两种序列化和Binder的机制，这些都是可以实现跨进程的通信，此外我们还可以通过ContentProvider去实现，还可以通过Socket，下面我们会一一讲解给大家听。

4.1 使用Bundle

我们都知道四大组件中的三大组件（Activity Service BroadcastReceiver）都支持Intent中传递Bundle数据，并且Bundle支持传递Serializable Parcelable的序列化的对象，所以我们可以在跨进程的Activity的跳转中，通过Bundle传递实现序列化接口的数据。这也是最简单的一种进程通信方式。

但是有一种特殊的适用场景，如我们需要将A进程中计算的结果传递给B进程，但是结果不支持序列化，那么我就如法将值传给B进程，但是我们可以在B进程中开一个Service 去计算，再将计算好的值传递给B进程（Service在B进程中），那么我们就可以解决这个问题。

4.2共享文件的使用

在windows上，一个文件如果被加了排斥锁，会导致其他线程无法访问，包括读和写。但是在Linux里，不存在对文件的限制，所以可以读和写，那么我们就可以值得两个进程对同一个文件进行读和写的操作。所以可能会出点问题。
下面我们就对其进行演示。

//MainActivity序列化的过程

               String CHAPTER_2_PATH = Environment.getExternalStorageDirectory().getPath()
            + "/singwhatiwanna/chapter_2/";
               String CACHE_FILE_PATH = CHAPTER_2_PATH + "usercache";
                User user = new User(1, "hello world", false);
                File dir = new File(MyConstants.CHAPTER_2_PATH);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                File cachedFile = new File(MyConstants.CACHE_FILE_PATH);
                ObjectOutputStream objectOutputStream = null;
                try {
                    objectOutputStream = new ObjectOutputStream(
                            new FileOutputStream(cachedFile));
                    objectOutputStream.writeObject(user);
                    Log.d(TAG, "persist user:" + user);
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    MyUtils.close(objectOutputStream);
                }
//SecondActivity 反序列化过程
  String CHAPTER_2_PATH = Environment.getExternalStorageDirectory().getPath()
            + "/singwhatiwanna/chapter_2/";
               String CACHE_FILE_PATH = CHAPTER_2_PATH + "usercache";
                User user = null;
                File cachedFile = new File(MyConstants.CACHE_FILE_PATH);
                if (cachedFile.exists()) {
                    ObjectInputStream objectInputStream = null;
                    try {
                        objectInputStream = new ObjectInputStream(
                                new FileInputStream(cachedFile));
                        user = (User) objectInputStream.readObject();
                        Log.d(TAG, "recover user:" + user);
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    } finally {
                        MyUtils.close(objectInputStream);
                    }
                }

该方式也是有一定的弊端，比如同步的读，我们可能读取到的数据并不是最新的，如果是并发的写就更严重了，所以我们要尽量避免并发的写，或者是通过线程同步来限制多线程的写操作。

当然SharePerference是一个特例，它是android提供的轻量级的储存方案，它是通过键值对的方式储存，在底层上它实际是采用XML文件夹来存储，每一个应用的SharePerference都会被储存在 /data/data/package name/shared_prefs的文件夹下。从本质上来说SharePerference也是文件的一种，但是由于系统对他的读写采用缓存的策略，导致内存中会存在缓存文件，因此在多线程的模式下，系统对他的读写就不是很靠谱，面对高并发的读写会导致内容的丢失，所以不建议在进程通信中使用。

4.3使用Messenger

我们可以先看下Messenger的两个构造方法，

    public Messenger(Handler target) {
        mTarget = target.getIMessenger();
    }
    public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }

我们可以看出AIDL的痕迹，不管是Imessenger还是Stub.asInterface ，他们的底层都是AIDL
要如何实现Messenger其实很简单
1.首先我们在服务端创建一个Service，是同创建一个Handler，通过他去创建Messenger对象，然后再Service的onBind中返回Messenger的Binder对象即可。
2.在客户端进程中，首先要绑带Service，通过返回的IBinder对象去创建Messenger，通过这个Messenger去发消息给服务端，消息类型是Message。如果需要客户端也能发送消息给服务端，我们也需要去创建Handler，通过他去创建Messenger对象，并让这个Messenger对象通过Message的replyTo的参数传给服务端，服务端通过这个replTo参数回应客户端。下面是代码

首先是MainActivity
public class MessengerActivity extends Activity {
    private static final String TAG = "MessengerActivity";
    private Messenger mService;
   // private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
    //private static class MessengerHandler extends Handler {
       // @Override
       // public void handleMessage(Message msg) {
           // switch (msg.what) {
         //   case MyConstants.MSG_FROM_SERVICE:
          //      Log.i(TAG, "receive msg from Service:" + msg.getData().getString("reply"));
               // break;
         //   default:
             //   super.handleMessage(msg);
          //  }
      //  }
 //   }
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            mService = new Messenger(service);
            Log.d(TAG, "bind service");
            Message msg = Message.obtain(null, MyConstants.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();
            }
        }
        public void onServiceDisconnected(ComponentName className) {
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Intent intent = new Intent("com.ryg.MessengerService.launch");
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }
    @Override
    protected void onDestroy() {
        unbindService(mConnection);
        super.onDestroy();
    }
}

我们先来看看没被注释的代码，我们只需要通过服务端返回的IBinder对象去创建一个Messenger对象，将数据放置Message中，再通过 mService.send(msg)即可完成跨进程通信，对应的Service的部分也是没被注释的部分。这样我们就完成了客户端向服务端发送数据，在服务端里显示这些数据。但是，如果说再复杂点，服务端接收客户端发来的数据并向客户端做出响应，客户端接收服务端发来的消息并且显示，那我们需要怎么做呢？

很简单那么我们来看看注释部分的代码，我们先来看看客户端的我们需要创建一个接收服务端发来消息的Messenger对象mGetReplyMessenger，在通过Handler来接收服务端传来的Message对象并且进行解析。这么做大致流程是对的但是还少了一句非常关键的一句话， msg.replyTo = mGetReplyMessenger; 其实msg的replyTo就是Messenger对象。

这里就要问为什么要向服务端传递接收信息的Messenger对象呢？
为什么前面简单的请求的时候不需要发送呢？

因为前面做简单的请求的时候，客户端进程和服务端进程是通过服务端返回的IBinder来连接的，也就是说通过IBinder创建的Messenger已经具备跨客户端服务端进程的能力。但是后者(注释的部分)在客户端中负责接收服务端发来的消息的Messenger不是通过IBinder，虽然Messenger能进行跨进程，但是它无法来连接客户端和服务端，所以我们需要通过msg.replyTo = mGetReplyMessenger来告诉服务端你要向mGetReplyMessenger发送消息，在服务端中通过客户端传来的Message的replyTo来找到需要被接收的Messenger，从而完成跨进程通信。

再举个例子小王（客户端）和小明（服务端）是对象，小明向给巩固两人的关系，于是买了一对情侣戒指，送个小王一个（返回的IBinder），一天小王和小明吵架了，身为小王好友的小丽决定帮忙，于是像小王要来小明的号码（msg.replyTo = mGetReplyMessenger），这样小王可以通过小丽来了解小明的想法（客户端接收服务端发来的消息）

//下面是Service
public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MyConstants.MSG_FROM_CLIENT:
                Log.i(TAG, "receive msg from Client:" + msg.getData().getString("msg"));
              //  Messenger client = msg.replyTo;
           //     Message relpyMessage = Message.obtain(null, MyConstants.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);
         //   }
     //   }
    }
    private final Messenger mMessenger = new Messenger(new MessengerHandler());
    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
    @Override
    public void onCreate() {
        super.onCreate();
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
}

注释部分就是创建Messenger并指向客户端传来的Messenger对象，向想客户端传来的Messenger对象传递消息。示意图如下

第二章 IPC机制详解(2)

4 IPC的使用方法

4.1 使用Bundle

4.2共享文件的使用

4.3使用Messenger

你可能感兴趣的:(第二章 IPC机制详解(2))