美文网首页IPC
Android IPC机制详解（二）

Android IPC机制详解（二）

作者: 星星_点灯 | 来源:发表于2017-01-11 17:54 被阅读241次

本篇主要介绍内容
1、Binder连接池

先来回顾一下AIDL的大致流程
1、首先创建一个Service和AIDL接口；
2、创建一个类继承AIDL接口中的Stub类，并实现其中抽象方法；
3、在Service的onBind方法中返回这个对象；
4、客户端绑定服务端获取到这个对象就可以访问服务器的方法了；

以上就是典型的AIDL的执行流程，现在有这样一个问题：一个项目越来越庞大，现在有10个不同的业务模块都需要使用AIDL来实现，那么要怎么办呢？按照AIDL的方式一个个来实现？如果按照这种方式，那么我们就要创建10个Service。如果是100个呢？到这里应该明白，随着我们的业务不断增加，AIDL也要不断增加，这就导致了我们要无限制的增加Service；Service本身是一种资源，如果一个应用有十几个Service运行，极大的消耗内存资源，影响应用的性能；那么应该怎么办呢？有没有一种方式创建一个Service就能解决这个问题呢？答案是肯定的，就是我们今天要介绍的主角：Binder连接池；

什么是Binder连接池
按照上面我们提的需求，服务端有10个不同的业务模块，每个模块我们都创建相应的AIDL接口和实现，然后这些不同业务模块的Binder对象统一由Binder连接池来管理，客户端可以根据不同编码或唯一标识来获取相应模块的Binder对象；Binder连接池主要用来管理和查询相应的Binder对象，具体流程如下图所示：

Paste_Image.png

接下来我们用一个实例来实现Binder连接池，场景是这样的，我们在服务端定义了两个aidl接口，分别是做加法和乘法的计算（当然可以增加更多接口），客户端通过Binder连接池来调用服务器的方法；

首先是服务端：
定义两个aidl的接口

// IMyAdd.aidl
package test.jiao.com.aidl;

interface IMyAdd {

    int add(int first,int second);
}

// IMyRide.aidl
package test.jiao.com.aidl;

interface IMyRide {

    int ride(int first, int second);
}

然后实现这两个aidl接口：

package test.jiao.com.aidl;

import android.os.RemoteException;

/**
 * date ：2016/12/30
 * author ：SuperJiao
 * Description
 */
public class MyAddImpl extends IMyAdd.Stub {

    @Override
    public int add(int first, int second) throws RemoteException {
        return first + second;
    }
}

package test.jiao.com.aidl;

import android.os.RemoteException;

/**
 * date ：2016/12/30
 * author ：SuperJiao
 * Description
 */
public class MyRideImpl extends IMyRide.Stub {

    @Override
    public int ride(int first, int second) throws RemoteException {
        return first * second;
    }
}

接下来实现我们的Binder连接池，首先定义Binder连接池的aidl接口

// IBinderPool.aidl
package test.jiao.com.aidl;

interface IBinderPool {
  
    IBinder getIBinder(int binderCode);
}

我是根据code来判断用户查询哪个接口，并返回相应的服务的，你也可以用其他方式来查询，这个可以根据需求灵活变换；
接下来我们来实现这个aidl接口

package test.jiao.com.aidl;

import android.os.IBinder;
import android.os.RemoteException;

/**
 * date ：2016/12/30
 * author ：SuperJiao
 * Description
 */
public class BinderPoolImpl extends IBinderPool.Stub {
    @Override
    public IBinder getIBinder(int binderCode) throws RemoteException {
        IBinder mBinder = null;
        switch (binderCode) {
            case ContentPool.POOL_ADD:

                mBinder = new MyAddImpl();
                break;
            case ContentPool.POOL_RIDE:

                mBinder = new MyRideImpl();
                break;
        }
        return mBinder;
    }
}

可以看出来，服务端所有aidl的接口的实现，都是在连接池中创建出来的，客户端只需要根据code来获取相应的方法即可；
接下来我们只需要创建一个服务在onbind中将该连接池的Binder对象返回即可；

package test.jiao.com.aidl;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;

public class BinderPoolService extends Service {
    private Binder mBinderPool = new BinderPoolImpl();

    @Override
    public IBinder onBind(Intent intent) {
        return mBinderPool;
    }
}

然后是客户端，客户端的核心代码主要是连接池的具体实现；
首先客户端要和服务端一致创建一样的aidl接口，可以看上方服务端的代码；
客户端的aidl接口如下

Paste_Image.png

接下来就是客户端的核心连接池的实现：

package test.jiao.com.aidl;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;

import java.util.concurrent.CountDownLatch;

/**
 * date ：2016/12/30
 * author ：SuperJiao
 * Description
 */
public class BinderPool {

    private Context mContext;
    private static volatile BinderPool sInstance;
    private IBinderPool mBinderPool;

    private BinderPool(Context context) {
        mContext = context;

    }

    public static BinderPool getInstance(Context context) {
        if (sInstance == null) {
            synchronized (BinderPool.class) {
                if (sInstance == null) {
                    sInstance = new BinderPool(context);
                }
            }
        }
        return sInstance;
    }


    //绑定服务
    public synchronized void connectBinderPoolService() {
        Intent intent = new Intent();
        intent.setAction("com.jiao.myaidl.action.BINDERPOOL_SERVICE");
        mContext.bindService(intent, mBinderPoolConnection, Context.BIND_AUTO_CREATE);

    }

    //解绑服务
    public void disConnectBinderPoolService() {
        mContext.unbindService(mBinderPoolConnection);
    }

    private ServiceConnection mBinderPoolConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mBinderPool = IBinderPool.Stub.asInterface(service);
            try {
                mBinderPool.asBinder().linkToDeath(mBinderPoolDeathRecipient, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    //服务死亡监听
    private IBinder.DeathRecipient mBinderPoolDeathRecipient = new IBinder.DeathRecipient() {

        @Override
        public void binderDied() {
            mBinderPool.asBinder().unlinkToDeath(mBinderPoolDeathRecipient, 0);
            mBinderPool = null;
            connectBinderPoolService();
        }
    };


    //根据code获取相应的Binder对象
    public IBinder getBinder(int code) {
        IBinder binder = null;
        switch (code) {
            case ContentPool.POOL_ADD://加法
                try {
                    binder = mBinderPool.getIBinder(ContentPool.POOL_ADD);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case ContentPool.POOL_RIDE://乘法
                try {
                    binder = mBinderPool.getIBinder(ContentPool.POOL_RIDE);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
        }

        return binder;
    }

}

可以看出来，客户端的连接池类，主要用来绑定服务端的服务，然后获取到服务端返回的连接池Binder对象，通过这个对象就可以连接服务器获取服务端的其他aidl接口的binder对象，通过这个Binder对象就可以调取服务端相应的方法；

接下来我们来验证一下，我们创建一个Activity，有两个按钮，一个是乘法计算一个是加法计算；点击相应的按钮得到相应的计算结果，代码如下：

package test.jiao.com.aidl;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity implements View.OnClickListener {

    private Button bt_aidl_add;
    private Button bt_aidl_ride;
    private BinderPool binderPool;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        start();
    }


    private void start() {
        bt_aidl_ride = (Button) findViewById(R.id.bt_aidl_ride);
        bt_aidl_add = (Button) findViewById(R.id.bt_aidl_add);
        bt_aidl_add.setOnClickListener(this);
        bt_aidl_ride.setOnClickListener(this);
        binderPool();
    }

    private void binderPool() {
        binderPool = BinderPool.getInstance(this);
        binderPool.connectBinderPoolService();
    }


    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.bt_aidl_ride:

                IMyRide iMyRide = IMyRide.Stub.asInterface(binderPool.getBinder(ContentPool.POOL_RIDE));
                try {
                    Toast.makeText(this, iMyRide.ride(5, 5) + "", Toast.LENGTH_SHORT).show();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case R.id.bt_aidl_add:

                IMyAdd iMyAdd = IMyAdd.Stub.asInterface(binderPool.getBinder(ContentPool.POOL_ADD));
                try {
                    Toast.makeText(this, iMyAdd.add(5, 5) + "", Toast.LENGTH_SHORT).show();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }

                break;
        }
    }


    @Override
    protected void onDestroy() {
        binderPool.disConnectBinderPoolService();
        super.onDestroy();
    }
}

运行结果如下：

Paste_Image.png

这样，无论服务端有多少个aidl接口，我们只需要扩展连接池就可以了，避免了创建更多的Service，大大的提升了程序的效率；

最后我们再来总结一下：在Android中的IPC机制最主要的方式有AIDL、Messenger、ContentProvider、Socket等；无论哪种方式，底层都是用Binder来实现的；本篇取其中最基本、通用的一种方式AIDL来讲解主要是要大家弄明白Android中的进程间通信的原理和具体实现，到这里，相信大家对Android的IPC机制和AIDL的实现已经有了进一步的了解；关于其他的方式，有兴趣的小伙伴可以自己探究一下；

相关文章

网友评论

    本文标题：Android IPC机制详解（二）

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

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    IPC

    关于我们|服务条款|联系我们|Android IPC机制详解（二）|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！