Android进程间通信知识点

2019-08-26  本文已影响0人  dashingqi

进程间通信（IPC Inter-Process Communication）

进程和线程

IPC

IPC的情况

Android中的多进程模式

开启多进程模式
多进程会造成如下几个问题

IPC基础概念介绍

Serializable接口
private static final long serialVersionUID = 3423432423423432L;

//User implements Serializable
//序列化的过程
User user = new User("jack",0,true);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("cache.txt"));
out.writeObject(user);
out.close();
//反序列化的过程
ObjectInputStream in = new ObjectInputStream(new FileInputStream("cache.txt"));
User mUser = (User)in.readerObject();
in.close();

//user与mUser的内容一样，但不是同一个对象。

serialVersionUID是用来辅助序列化和反序列，已经序列化的的数据中serialVersionUID和当前类中的serialVersionUID一致，这样反序列化才能成功。

当序列化的时候会将当前类的serialVersionUID写进文件中，当但序列化的时候，会去检查文件中serialVersionUID的值是否和当前类中的一致，一致就认为可以正常的反序列化，不一致就说明当前类发生了变化，无法完成发序列化操作，会抛出异常。

Parcelable接口
public class User implements Parcelable {
    public int userId;
    public String userName;
    public boolean isMale;

    public User(int userId, String userName, boolean isMale) {
        this.userId = userId;
        this.userName = userName;
        this.isMale = isMale;
    }

    protected User(Parcel in) {
        userId = in.readInt();
        userName = in.readString();
        isMale = in.readInt() != 0;
    }

    /**
     * 反序列化由CREATOR来实现
     */
    public static final Creator<User> CREATOR = new Creator<User>() {
        /**
         * 从序列化的数据中创建原始对象
         * @param in
         * @return
         */
        @Override
        public User createFromParcel(Parcel in) {
            return new User(in);
        }

        /**
         * 创建指定长度的原始对象长度
         * @param size
         * @return
         */
        @Override
        public User[] newArray(int size) {
            return new User[size];
        }
    };

    /**
     * 返回当前对象的描述 几乎所有情况返回0 如果含有文件描述符 返回1
     * @return
     */
    @Override
    public int describeContents() {
        return 0;
    }

    /**
     * 序列化的过程
     *
     * @param dest  parcel对象中封装了可序列化的数据,可以在Binder中自由传输
     * @param flags
     */
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(userId);
        dest.writeString(userName);
        dest.writeInt(isMale ? 1 : 0);
    }
}
Parcelable 与Serializable接口的比较

Binder

Binder的原理通过AIDL文件来分析

IPC通信方式

Bundle
文件共享
Messenger（信使）

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

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

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


    static Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_CLIENT:
                    //获取从客户端发来的消息
                    Log.d(TAG, "handleMessage: " + msg.getData().getString("msg"));
                    break;
            }
            super.handleMessage(msg);
        }
    };


    private Messenger mMessenger = new Messenger(mHandler);
}

客户端进程

public class MainActivity extends AppCompatActivity {

    private Messenger mMMessenger;
    private Message mMMessage;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(this, MyService.class);
        //绑定服务
        bindService(intent, mServiceConnection, BIND_AUTO_CREATE);
    }

    private ServiceConnection mServiceConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //与服务成功绑定回调
            mMMessenger = new Messenger(service);
            mMMessage = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            //通过Bundle传递数据
            Bundle data = new Bundle();
            data.putString("msg", "i am from client");
            //Message携带数据
            mMMessage.setData(data);

            try {
                //发送消息
                mMMessenger.send(mMMessage);
            } catch (RemoteException e) {
                e.printStackTrace();
            }


        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };
}

AIDL

服务端
客户端
AIDL文件

AIDL中支持的数据类型

远程服务端Service的实现
public class BookManagerService extends Service {
    //装书的
    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>();

    private RemoteCallbackList<IBookArrivedListener> mListenerList = new RemoteCallbackList<>();

    private AtomicBoolean mServiceIsDestroy = new AtomicBoolean(false);

    private IBinder mBookManager = new IBookManager.Stub() {

        @Override
        public void addBook(Book book) throws RemoteException {
            mBookList.add(book);

        }

        @Override
        public List<Book> getBookList() throws RemoteException {
            return mBookList;
        }

        @Override
        public void registerListener(IBookArrivedListener listener) throws RemoteException {
            mListenerList.register(listener);

        }

        @Override
        public void unregisterListener(IBookArrivedListener listener) throws RemoteException {
            mListenerList.unregister(listener);
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
        mBookList.add(new Book("Java", 1));
        mBookList.add(new Book("Android", 2));
        new Thread(new ServiceWorker()).start();
    }

    @Override
    public IBinder onBind(Intent intent) {
        //此处返回的IBinder对象，会在ServiceConnection绑定成功的方法中返回。根据IBinder对象，
        // 可以获取到客户端需要的AIDL类型的对象，
        //可以进行跨进程的调用方法。
        return mBookManager;
    }

    @Override
    public void onDestroy() {
        mServiceIsDestroy.set(true);
        super.onDestroy();
    }

    private void onBookIsArrived(Book book) throws RemoteException {
        mBookList.add(book);
        int count = mListenerList.beginBroadcast();
        for (int i = 0; i < count; i++) {
            IBookArrivedListener broadcastItem = mListenerList.getBroadcastItem(i);
            broadcastItem.onBookIsArrived(book);
        }

        mListenerList.finishBroadcast();

    }

    private class ServiceWorker implements Runnable {

        @Override
        public void run() {
            while (!mServiceIsDestroy.get()) {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                int bookId = mBookList.size() + 1;
                Book mNewBook = new Book("new book # " + bookId, bookId);
                try {
                    onBookIsArrived(mNewBook);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
客户端的实现
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private IBookManager mRemoteBookManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(MainActivity.this, BookManagerService.class);
        bindService(intent, mServiceConnection, BIND_AUTO_CREATE);
    }

    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // asInterface 作用是将服务端的Binder对象转化成客户端所需要的AIDI类型的对象
            IBookManager mBookManager = IBookManager.Stub.asInterface(service);
            mRemoteBookManager = mBookManager;
            try {
                List<Book> bookList = mBookManager.getBookList();
                Log.d(TAG, "list category =  " + bookList.getClass().getCanonicalName());
                Log.d(TAG, "onServiceConnected: " + bookList.toString());
                Book mNewBook = new Book("Python", 4);
                mBookManager.addBook(mNewBook);
                Log.d(TAG, "onServiceConnected: " + mBookManager.getBookList());
                mBookManager.registerListener(mIBookIsArrivedListener);

            } catch (RemoteException e) {
                e.printStackTrace();
            }


        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    private IBookIsArrivedListener mIBookIsArrivedListener = new IBookIsArrivedListener.Stub() {

        @Override
        public void onNewBookArrived(Book book) throws RemoteException {
            //获取到新到的书籍  onNewBookArrived是运行客户端在Binder的线程池中的，为了方便操作UI切换到UI线程中
            mUIHandler.obtainMessage(1, book).sendToTarget();
        }
    };


    @Override
    protected void onDestroy() {
        if (mRemoteBookManager != null && mRemoteBookManager.asBinder().isBinderAlive()) {
            try {
                Log.d(TAG, "unregister listener:" + mIBookIsArrivedListener);
                //Binder会把客户端传递过来的对象转成一个新的对象，所以在服务端是不会解除事件的监听。
                //对象是不能进行跨进程传递，对象的跨进程传递本质上反序列的过程，反序列得到的内容一致，但是不是一个对象了，是一个新的对象了。
                //这个时候就得用到RemoteCallbackList 专门用来删除跨进程listener的接口。
                //多进程传递对象会在服务端会产生不同的对象，但是这不同的对象 在RemoteCallbackList中对应的key是一致的 都是底层的Binder对象。
                mRemoteBookManager.unregisterListener(mIBookIsArrivedListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        unbindService(mServiceConnection);
        super.onDestroy();
    }

    private Handler mUIHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    Log.d(TAG, "handleMessage: " + msg.obj);
                    break;
            }
            super.handleMessage(msg);
        }
    };
}
AIDL文件的实现
// My.aidl
package wanandroidqi.dashingqi.com.myaidlproject2.aidl;

// Declare any non-default types here with import statements

parcelable Book;


// IBookManager.aidl
package wanandroidqi.dashingqi.com.myaidlproject2.aidl;

// Declare any non-default types here with import statements
import wanandroidqi.dashingqi.com.myaidlproject2.aidl.Book;
import wanandroidqi.dashingqi.com.myaidlproject2.aidl.IBookArrivedListener;

interface IBookManager {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void addBook(in Book book);
    List<Book> getBookList();

    void registerListener(IBookArrivedListener listener);
    void unregisterListener(IBookArrivedListener listener);

}

// IBookArrivedListener.aidl
package wanandroidqi.dashingqi.com.myaidlproject2.aidl;

// Declare any non-default types here with import statements
import wanandroidqi.dashingqi.com.myaidlproject2.aidl.Book;

interface IBookArrivedListener {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
   void onBookIsArrived(in Book book);
}
上一篇 下一篇

猜你喜欢

热点阅读