美文网首页
学习笔记| (二)IPC机制

学习笔记| (二)IPC机制

作者: yanerly | 来源:发表于2018-10-25 00:06 被阅读18次

    一.多进程

    1.创建多进程:
    • 在android 中通过 android:process为四大组件创建新的进程
    • 在特殊情况下也可以通过JNI去native层fork一个新的进程,但是一般不会这么做
    • android:process = ":remote" 是私有进程(其他应用的组件不会和他跑在同一个进程中)
    • android:process = "com.test.remote"是全局进程(其他应用通过ShareUID和它跑在同一个进程中)
    2.Share UID:
    • android 系统会为每一个应用都分配一个UID(钥匙)
    • 只有UID相同的才能共享数据(房间)
    • 注意:要想在同一个进程中运行,除了UID要一样,签名也得一样;这种情况下的两个应用,不光能访问私有数据(比如data目录),还能共享内存数据
    3.多进程的运行机制
    • 系统会为每个应用分配一个虚拟机,或者说,会为每一个进程分配一个虚拟机
    • 同一个应用内不同进程直接就像是复制品一样,每个进程内的东西是完全一样的,一个进程内变量或其他东西的改变,不影响其他进程,他们都有自己的内存空间
    4.多进程的影响:
    • 静态成员变量和单例模式无效(原因就是3中所说的,每一个进程都有自己的内存空间了)
    • SharePreference无效(SharePreference不允许多个进程同时进行读写操作)
    • 线程同步机制无效(因为不同进程锁的都不是同一个对象)
    • 会创建多个Application(创建一个新的进程,就要创建一个新的虚拟机,就相当于打开了一个新的应用,会重新创建一个application。可以这么理解,在同一个进程中的应用,用同一个虚拟机和同一个Application)

    二.IPC机制

    1.Serizable接口
    • 使用:
      • 写一个类实现Serializable接口
      • 自己写一个serialVersionUID或者是系统自动生成,自己写的话可以保证序列化和反序列化正确
    • 不参与序列化的有:
      • 对于静态的成员变量
      • transient关键字标记的不参与
    String fname = Environment.getExternalStorageDirectory() + "/test.txt";
    
            //序列化
            User user = new User(1,"lili",true);
            try {
                ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(fname));
                outputStream.writeObject(user);
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
                Log.e("user","存入失败:"+e.getMessage());
            }
    
            //反序列化
            try {
                ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fname));
                User user = (User) inputStream.readObject();
                Log.e("user","读取结果:"+user.toString());
                inputStream.close();
                textEdit.setText(user.toString());
            } catch (IOException e) {
                e.printStackTrace();
                Log.e("user","读取失败:"+e.getMessage());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
                Log.e("user","读取失败222:"+e.getMessage());
            }
    
    2.Parceable接口
    Parcelable方法.png
    • 写一个类实现Parcelable接口
    • parceable方法说明.png
    • 在序列化对象中有一个是实现了Parcelable的类,序列化时需要:
        //序列化
        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeParcelable(book,0);
        }
    
        //反序列化 
        protected User(Parcel in) {
           //需要上传当前上下文的线程
            book = in.readParcelable(Thread.currentThread().getContextClassLoader());
        }
    
    3.这两个接口的区别
    区别 Serializable Parcelable
    平台 java的序列化接口 android的序列化接口
    原理 将一个对象转成可存储或可传输的状态 将一个对象分解成若干个支持传输的类型
    使用场景 将序列化对象存储到设备上或者是用于网络传输(推荐) 内存序列化
    优缺点 用到了大量的I/O操作(ObjectOutputStream/ObjectInoutStream),使用简单,但是消耗过大 高效,但是使用复杂
    4.Binder
    4.1 理解
    • Binder是android的一个类,实现了IBinder接口
    • 从IPC角度:是Android中一种跨进程通信方式,可以理解为一种虚拟的物理设备,它的驱动是/dev/binder
    • 从Framework层,是ServiceManager连接各种Manager和相应ManagerService的桥梁
    • 从应用层,是连接客户端和服务端的桥梁,bindService的时候,服务端会返回一个服务端的Binder对象给客户端,客户端可以通过这个Binder可以获取服务端提供的服务和数据
    4.2 创建aidl

    ①创建Book.java实现Parceable接口
    ②创建Book.aidl(先取别的名字,之后再重命名)

    // Book.aidl
    package ly.com.artres.aidl;
    parcelable Book;
    

    ③创建IBookManager.aidl

    // IBookManager.aidl
    package ly.com.artres.aidl;
    //手动导包
    import ly.com.artres.aidl.Book;
    
    // Declare any non-default types here with import statements
    
    interface IBookManager {
        //获取所有图书列表
        List<Book> getBookList();
    
        //添加图书:AIDL中除了基本数据类型,其他类型的参数必须标上方向:in、out、inout,in表示输入型参数,
        //out输出型参数,inout表示输入输出型参数,AIDL中只支持方法,不支持声明静态常量,是不同于一般接口的
        void addBook(in Book book);
    }
    

    ④Build-->Make project之后在

    build/generate/source/aidl中可以看到编译后的IBookManager .java
    
    4.3 手写aidl

    所有通过Binder传输的接口都要继承IInterface接口

    aidl内部实现.png
    binder机制.png
    /**
     * 手写aidl实现
     * 所有通过Binder传输的接口都要继承IInterface接口
     */
    public interface BookManager extends IInterface{
        //1.1创建文件描述类
        static final String DESCRIPTION = "ly.com.artres.aidl.BookManager";
    
        //1.2创建两个方法的标识
        static final int TRANSACT_GETBOOKLIST = IBinder.FIRST_CALL_TRANSACTION + 0;
        static final int TRANSACT_ADDBOOK = IBinder.FIRST_CALL_TRANSACTION + 1;
    
    
        //1.3创建客户端要调用的几个方法
        List<Book> getBookList() throws RemoteException;
        void addBook(Book book) throws RemoteException;
    
        //1.4创建内部类Stub,实现外部接口,实际上是一个Binder
        public class BookManageImpl extends Binder implements BookManager{
    
            //2.1要有一个构造函数和外部接口进行绑定
            public BookManageImpl(){
                this.attachInterface(this,DESCRIPTION);
            }
    
            //2.2 将服务端的Binder转化为客户端需要的接口(BookManager)
            public static BookManager asInterface(Binder binder){
                if (binder == null){
                    //客户端与服务端连接失败
                    return null;
                }
    
                //根据描述,取出当前进程的接口
                IInterface iin = binder.queryLocalInterface(DESCRIPTION);
                if (iin != null && iin instanceof BookManager){
                    //相同进程,取出的接口和客户端的接口相同,则返回服务端binder
                    return (BookManager) binder;
                }
    
                //不同进程
                return new BookManageImpl.Proxy(binder);
            }
    
            //2.3 返回当前的binder对象
            @Override
            public IBinder asBinder() {
                return this;
            }
    
            /**
             * 2.4 客户端发起RPC(远程过程调用)请求--->运行在服务端的Binder线程池中,所以所有的Binder请求都要是同步的
             * @param code : 请求的方法标识
             * @param data : 请求参数
             * @param reply : 请求的返回结果
             * @param flags : 参数flags只有0和FLAG_ONEWAY两种,默认的跨进程操作是同步的,所以transact()方法的执行会阻塞,
             *              调用以同步的形式传递到远程的transact(),等待远端的transact()返回后继续执行——最好理解的方式就是把
             *              两端的transact()看作一个方法,Binder机制的目标也就是这样。指定FLAG_ONEWAY时,表示Client的transact()
             *              是单向调用,执行后立即返回,无需等待Server端transact()返回
             * @return 返回false,则客户端请求失败
             * @throws RemoteException
             */
            @Override
            public boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
                //判断请求的哪个方法
                switch (code){
                    case TRANSACT_GETBOOKLIST:
                        //获取图书列表
                        //有请求参数,读取请求参数(没有)
                        data.enforceInterface(DESCRIPTION);
    
                        //调用请求方法
                        List<Book> list = this.getBookList();
    
                        //请求完成后,需要返回值,则写到reply中
                        reply.writeNoException();
                        reply.writeTypedList(list);
    
                        return true;
    
                    case TRANSACT_ADDBOOK:
                        //添加图书
                        //有请求参数,读取请求参数(有)
                        data.enforceInterface(DESCRIPTION);
    
                        Book _arg0;
                        if (0 != data.readInt()){
                            //将之前我们所存入的数据按照顺序进行获取,反序列化
                            _arg0 = Book.CREATOR.createFromParcel(data);
                        }else {
                            _arg0 = null;
                        }
    
                        //调用方法
                        this.addBook(_arg0);
    
                        //请求完成后,需要返回值,则写到reply中(没有返回值)
                        reply.writeNoException();
    
                        return true;
    
                    case INTERFACE_TRANSACTION:
                        reply.writeString(DESCRIPTION);
                        return true;
    
                    default:
                        break;
                }
    
                return super.onTransact(code, data, reply, flags);
            }
    
            //2.4创建代理类
            private static class Proxy implements BookManager{
                IBinder mRemote;
    
                /**
                 * 服务端的binder
                 * @param binder
                 */
                Proxy(IBinder binder){
                    this.mRemote = binder;
                }
    
                /**
                 * 运行在客户端
                 * @return
                 * @throws RemoteException
                 */
                @Override
                public List<Book> getBookList() throws RemoteException {
                    Parcel _data = Parcel.obtain();//创建输入型对象
                    Parcel _reply = Parcel.obtain();//创建输出型对象
                    List<Book> _result = null;//创建结果对象
    
                    try {
                        //写入请求参数(为空)
                        _data.writeInterfaceToken(DESCRIPTION);
    
                        //发起RPC请求
                        mRemote.transact(TRANSACT_GETBOOKLIST,_data,_reply,0);
    
                        //返回结果(list)
                        _reply.readException();
                        _result = _reply.createTypedArrayList(Book.CREATOR);
                    }catch (Exception e){
                        e.getMessage();
                    }finally {
                        //回收
                        _reply.recycle();
                        _data.recycle();
                    }
                    return _result;
                }
    
                /**
                 * 运行在客户端
                 * @param book
                 * @throws RemoteException
                 */
                @Override
                public void addBook(Book book) throws RemoteException {
                    Parcel _data = Parcel.obtain();//创建输入型对象
                    Parcel _reply = Parcel.obtain();//创建输出型对象
    
                    try {
                        //写入请求参数
                        _data.writeInterfaceToken(DESCRIPTION);
                        if (book != null){
                            //序列化
                            _data.writeInt(1);
                            book.writeToParcel(_data,0);
                        }else {
                            _data.writeInt(0);
                        }
    
                        //发起RPC请求
                        mRemote.transact(TRANSACT_ADDBOOK,_data,_reply,0);
    
                        //返回结果(为空)
                        _reply.readException();
                    }catch (Exception e){
                        e.getMessage();
                    }finally {
                        //回收
                        _reply.recycle();
                        _data.recycle();
                    }
                }
    
                @Override
                public IBinder asBinder() {
                    return mRemote;
                }
    
                public String getInterfaceDescription(){
                    return DESCRIPTION;
                }
            }
    
            @Override
            public List<Book> getBookList() throws RemoteException {
                return null;
            }
    
            @Override
            public void addBook(Book book) throws RemoteException {
    
            }
        }
    
    }
    
    
    4.4 两个重要方法
    • unlinkToDeath()
    private IBinder.DeathRecipient mRecipient = new IBinder.DeathRecipient() {
            @Override
            public void binderDied() {
                if (mManage == null){
                    //断开之前的连接
                    mManage.asBinder().unlinkToDeath(mRecipient,0);
                    mManage = null;
                }
            }
        };
    
    • linkToDeath():
    binder.linkToDeath(mRecipient,0);
    

    三、Android中的IPC方式:

    • Bundle
    • ContentProvider
    • AIDL
    • Messenger
    • 文件共享
    • Socket
    3.1 Bundle
    • Bundle实现了Parcelable接口,可以通过Intent传递
    • Bundle可以放基本数据类型,实现了Parcelale或Serializable接口的类,还有特殊数据类型
           Intent intent = new Intent(this,BActivity.class);
            Bundle bundle = new Bundle();
            bundle.putString("key1","你在干啥");
            intent.putExtra("intentkey",bundle);
            startActivity(intent);
    
    • 特殊使用场景:
      进程A中的计算结果要在进程B中展示,且这个计算结果不支持Bundle传输,可以通过Intent启动B的一个Service组件,然后B在后台进行计算,计算完成后在B中显示
    3.2 Messenger(信使)
    • 是一种轻量级的ipc方案
    • 底层是AIDL
    • 串行的方式处理消息,客户端发一个消息,服务端处理一个,当客户端发了大量的消息的时候,服务端也只能一个一个处理,效率低,不适合用Messenger处理。
    • Messenger主要是用来传递消息,当要调用服务端的方法时就不适用了。
      messenger流程图.jpg

    原理分析:
    ①client和server绑定后
    ②client在onServiceConnected中通过IBinder生成一个Messenger发送Message消息
    ③server接收到client发来的消息后,会在Handler中进行处理
    ④server回复消息给client,也是通过Messenger,他发送的消息需要客户端处理,所以这个Messenger得是client的,怎么创建客户端的Messenger呢?只需要在②中,发送消息的时候,通过msg.replyTo = xx,就可以把client的messenger传过来了

    • 注意:
      在跨进程中不能传递自定义的Parceable对象
    3.3 AIDL
    • (1)支持的数据类型:

      aidl支持的数据类型.png
      自定义的Parcelable对象和AIDL都要手动import
    • (2)解注册跨进程的接口时:

    @Override
        protected void onDestroy() {
            if (mRemoteManager != null && mRemoteManager.asBinder().isBinderAlive()){
                //注销
                Log.e("testaidl","onDestroy unregister listener:"+mNewBookListener);
                try {
                    mRemoteManager.unregisterListener(mNewBookListener);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
    
            unbindService(mConnection);
            super.onDestroy();
        }
    

    这样写的时候会解注册失败,因为这时候的manager和service端的都不是同一个了,aidl不能传输对象,这里的manager相当于两个新对象。
    要删除这个跨进程的接口,要用到RemoteCallBackListener;
    使用方法:

     //用于删除跨进程的接口
    private RemoteCallbackList<IOnNewBookArrivedLisneer> mListennerist = new RemoteCallbackList<>();
    
    @Override
    public void registerListener(IOnNewBookArrivedLisneer listener) throws RemoteException { 
                mListennerist.register(listener);
            }
    
    @Override
    public void unregisterListener(IOnNewBookArrivedLisneer listener) throws RemoteException {
                mListennerist.unregister(listener);
            }
    

    注意:
    在使用RemoteCallbackList时要注意:

          //获取元素个数
           int N = mListennerist.beginBroadcast();
            for (int i=0;i<N;i++){
                IOnNewBookArrivedLisneer lisneer = mListennerist.getBroadcastItem(i);
                if (lisneer != null){
                    try {
                        lisneer.onNewBookArrived(book);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
    
            //要和beginBroadcast配套使用
            mListennerist.finishBroadcast();
    

    (3)在UI线程中调用远程端的耗时方法(互调):

    • 服务端中的方法都运行在Binder线程池中,客户端调用服务端中的耗时方法时,会造成ANR,所以要在客户端开启一个子线程才能调用服务端的方法;
    • 服务端的调用客户端Binder线程池中的某一个耗时方法时,也要开始一个线程才行;

    (4)Binder意外死亡的时候:

    • 可以在onServiceDisconnected中重新连接
    • 可以在DeathRecipient 中断开之前的连接,再重新绑定
    IBinder.DeathRecipient recipient = new IBinder.DeathRecipient() {
            @Override
            public void binderDied() {
            }
        };
    
    • 他们二者的区别:
      onServiceDisconnected是运行在UI线程中,而DeathRecipient 是运行在客户端的Binder线程池中的

    (5)权限验证:
    声明权限

    <!--权限验证,验证通过才能连接服务器-->
    <permission android:name="ly.com.artres.aidl.ACCESS_BOOK_SERVICE" android:protectionLevel="normal"/>
    

    使用权限:

    <uses-permission android:name="ly.com.artres.aidl.ACCESS_BOOK_SERVICE"/>
    
    • 可以在onBinder()中验证权限
    @Override
        public IBinder onBind(Intent intent) {
            //权限验证
            int permission = checkCallingOrSelfPermission("ly.com.artres.aidl.ACCESS_BOOK_SERVICE");
            if (permission == PackageManager.PERMISSION_DENIED){
                return null;
            }
            return mBinder;
        }
    
    • 可以在onTransact()中通过权限验证或者Uid,Pid进行验证

    • 总结:创建一个service和AIDL接口,创建一个类实现AIDL接口中的Stub类并实现里面的抽象方法,在service的onBind()中返回这个类的对象,然后在客户端就可以绑定服务端Service,继而访问远程接口

    3.4 ContentProvider
    • 底层是Binder
    • 写一个类继承ContentProvider
      要实现6个方法:
      ①boolen onCreate():创建,做初始化工作,运行在UI线程中;
      ②String getType(Uri uri):根据uri获取对应的MIME(媒体)类型:文字/图片/视频,在主线程;
      ③Uri insert(@NonNull Uri uri, @Nullable ContentValues values):插入数据,在binder线程池中运行;
      ④int delete(@NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs):删除数据,在binder线程池中运行;
      ⑤int update(@NonNull Uri uri, @Nullable ContentValues values, @Nullable String selection, @Nullable String[] selectionArgs):更新数据,在binder线程池中运行;
      ⑥Cursor query(...):查询数据,在binder线程池中运行;

    实现步骤:

    • 在manifest中定义这个provider
    <provider
                android:name=".contentproviderdemo.BookProvider"
                android:authorities="ly.com.artres.provider"//唯一标识
                android:permission="ly.com.PROVIDER"//权限
                android:process=":process" />//这个可以不写
    
    • 根据Uri-->得到UriCode--->再判断是哪一张表
    • 将uri和uricode进行绑定
       //创建Uri和UriCode
        private static String AUTHORITY = "ly.com.artres.provider";
        private static Uri BOOK_URI = Uri.parse("content://"+AUTHORITY+"/book");
        private static Uri USER_URI = Uri.parse("content://"+AUTHORITY+"/user");
        public static final int BOOK_CODE = 0;
        private static final int USER_CODE = 1;
    
       //创建urimatch
        private static UriMatcher uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        static {
            uriMatcher.addURI(AUTHORITY,"book",BOOK_CODE);
            uriMatcher.addURI(AUTHORITY,"user",USER_CODE);
        }
    
         /**
         * 根据Uri得到Uricode,再判断是哪一张表
         * @param uri
         * @return
         */
        private String getTableName(Uri uri){
            String tableName = null;
            switch (uriMatcher.match(uri)){
                case BOOK_CODE:
                    tableName = DBOpenHelper.BOOK_TABLE_NAME;
                    break;
                case USER_CODE:
                    tableName = DBOpenHelper.USER_TABLE_NAME;
                    break;
                default:
                    break;
            }
            return tableName;
        }
    
    
       @Nullable
        @Override
        public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
            Log.e("testcp","insert():"+Thread.currentThread().getName());
    
            String tableName = getTableName(uri);
            if (tableName == null){
                throw new IllegalArgumentException("insert unsupport uri:"+uri);
            }
    
            mDb.insert(tableName,null,values);
            mContext.getContentResolver().notifyChange(uri,null);
            return null;
        }
    

    SQLite数据库:

    • 底部实现了线程同步,如果provider不使用sqlite数据库,要注意在CRUD中使用线程同步;
    • 自定义一个类继承SQLiteOpenHelper,必须要有一个构造方法;
    • SQLiteOpenHelper用于创建升级数据库;
    public class DBOpenHelper extends SQLiteOpenHelper {
        public static final String DB_NAME = "book.db";
        public static final String BOOK_TABLE_NAME = "booktb";
        public static final String USER_TABLE_NAME = "usertb";
        public static final int DB_VERSION = 1;
    
        private String CREATE_BOOK = "create table if not exists "+BOOK_TABLE_NAME+"(_id integer primary key,name text)";
        private String CREATE_USER = "create table if not exists "+USER_TABLE_NAME+"(_id integer primary key,name text)";
    
    
        /**
         * 必须要有一个构造函数
         * @param context
         */
        public DBOpenHelper(Context context) {
            super(context,DB_NAME,null,DB_VERSION);
        }
    
    
        @Override
        public void onCreate(SQLiteDatabase db) {
           //创建表
            db.execSQL(CREATE_BOOK);
            db.execSQL(CREATE_USER);
        }
    
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    
        }
    }
    

    根据sqliteopenhelprt可以创建sqlitedatabase,然后在contentprovider的CRUD方法中调用sqlitedatabase的增删改查的方法;

    SQLiteDatabase mDb = new DBOpenHelper(mContext).getWritableDatabase();
    

    在Activity中往provider中插入数据时:

            Uri uri = Uri.parse("content://ly.com.artres.provider/book");
            ContentValues values = new ContentValues();
            values.put("_id",4);
            values.put("name","语文");
            getContentResolver().insert(uri,values);
    

    在Activity中从provider中查询数据时:

            Uri uri = Uri.parse("content://ly.com.artres.provider/book");
            Cursor bookCursor = getContentResolver().query(uri,new String[]{"_id","name"},null,null,null);
            while (bookCursor.moveToNext()){
                int id = bookCursor.getInt(0);
                String name = bookCursor.getString(1);
                Log.e("testcp","query book结果:"+id+",name:"+name+"\n");
            }
    
            bookCursor.close();
    
    3.5 文件共享
    • 实现Serializable接口
    • 通过ObjectOutputStream()和ObjectInputStream()实现
    3.6 Socket(套接字)

    1.分为两种:

    • 流式套接字-->对应TCP(面向连接,提供稳定的双方通信功能,要建立三次握手,本身具有超时重连机制)
    • 用户数据报套接字-->对应UDP(也能实现双方通信功能,性能会更高,但是数据不一定能传输成功,)

    2.可以传输任意字节流

    3.使用:

    • 要有权限(不能在主线程访问网络
        <!-- socket要的权限 -->
        <uses-permission android:name="android.permission.INTERNET" />
        <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    
    • 步骤:
      服务端:
    ①服务端创建Socket
    ServerSocket serverSocket = new ServerSocket(8688);
    
    ②接收客户端请求:
    final Socket client = serverSocket.accept();
    
    ③接收客户端请求
    BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
    String str = in.readLine();
    
    ④向客户端发送消息
    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())),true);
    out.println("欢迎来到聊天室");
    
    

    客户端:

    ①连接服务端
    Socket socket = new Socket("localhost",8688);
    
    ②向服务端发送请求:
    PrintWriter mPrintWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);
    mPrintWriter.println(“hello”);
    
    ③接收服务端的消息:
     BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    String msg = in.readLine();
    

    四、Binder连接池:

    五、选择合适的IPC方式:

    选择ipc方式.png

    相关文章

      网友评论

          本文标题:学习笔记| (二)IPC机制

          本文链接:https://www.haomeiwen.com/subject/osjtoftx.html