aidl跨進程通訊封裝(仿hermes)

由於Android不同進程之前不能相互通信，所以當開發過程中遇到跨進程通信的時候,常用的方案就是AIDL(Android Interface Definition Language)通過它我們可以定義進程間的通信接口,但是當應用中出現大量跨進程通信的時候，比如你想體驗一下插件化開發或者特殊需求在單應用中需要開多個進程，那麼寫過AIDL的同學都會有痛不欲生的感覺。現在福利來了，可以試試餓了麼開源了一款進程間事件分發的庫—HermesEventBus。
在介紹HermesEventBus之前先簡單介紹一下它底層依賴的庫Hermes—-同樣是由餓了麼Android資深工程師趙立飛操刀的一套新穎巧妙易用的Android進程間通信IPC框架,開發Hermes的初衷是爲了解決插件化框架DroidPlugin的主從進程通信困難的問題,最後實現的效果是將進程間通信變的像調用本地函數一樣方便簡單，並且支持進程間函數回調和垃圾回收。
想了解更多，請移步飛神的Hermes。

一、Hermes實現核心思想

aidl
android中跨進程通訊，通常是使用aidl了,但是aidl使用起來，相對會比較麻煩，因爲每次都要自己寫一個aidl文件，然後創建service，在service中返回binder進行通訊。
動態代理
在客戶端可以提供一個接口，然後創建動態代理，每次調用方法時，獲取到方法名，然後通過aidl跨進程調用，在服務端，再通過方法名和classid反射調用對應的方法。

二、封裝使用

設置服務端MainActivity和客戶端SecondActivity在不同進程

        <activity android:name="com.hxl.hermes.MainActivity">
        </activity>

        <activity android:name="com.hxl.hermes.SecondActivity"
            android:process=":second"/>

1.創建跨進程單例

在服務端進程和客戶端進程中必須要有一個完全相同的接口。該接口主要提供給客戶端進程使用。

服務端接口類上面要加上註解 @ClassId(“實現類的全路徑”)

@ClassId("com.hxl.hermes.dao.UserManager")
public interface IUserManager {

    Person getPerson();
    void setPerson(Person person);

}

服務端進程中要有一個單例類實現該接口，實現類必須是單例的，而且獲取單例方法名必須是：*getInstance()*

``````java
public class UserManager implements IUserManager{
    private static final UserManager ourInstance = new UserManager();

    public static UserManager getInstance() {
        return ourInstance;
    }

    private UserManager() {
    }

    private Person person;

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

}

2.服務端註冊

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Hermes.getDefault().register(UserManager.class);
        Hermes.getDefault().register(FileManager.class);
    }

給單例設置要傳遞的值

 UserManager.getInstance().setPerson(new Person("hxl", "123456"));

3.客戶端連接

 Hermes.getDefault().connect(this, HermesService.class);

4.跨進程通訊，客戶端獲取服務端單例

        IUserManager iUserManager = Hermes.getDefault().getInstance(IUserManager.class);
        Person person = iUserManager.getPerson();
        Toast.makeText(this, person.toString(), Toast.LENGTH_SHORT).show();

三、核心代碼

1.服務端註冊

服務端註冊後會將單例存到緩存中

    public void register(Class<?> clazz) {
        typeCenter.register(clazz);
    }


    public void register(Class<?> clazz){
        registerClass(clazz);
        registerMethod(clazz);
    }

    //註冊類的類名
    private final ConcurrentHashMap<String, Class<?>> mAnnotatedClasses;
    //註冊的所有方法
    private final ConcurrentHashMap<Class<?>, ConcurrentHashMap<String, Method>> mRawMethods;

    private void registerMethod(Class<?> clazz){
        mRawMethods.putIfAbsent(clazz, new ConcurrentHashMap<String, Method>());
        ConcurrentHashMap<String, Method> map = mRawMethods.get(clazz);

        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            String key = TypeUtils.getMethodId(method);
            map.put(key, method);
        }
    }

    private void registerClass(Class<?> clazz){
        String className = clazz.getName();
        mAnnotatedClasses.putIfAbsent(className, clazz);
    }

2.客戶端連接

    public void connect(Context context, Class<? extends HermesService> service){
        connectApp(context, null, service);
    }

    private void connectApp(Context context, String packageName, Class<? extends HermesService> service){
        serviceConnectionManager.bind(context.getApplicationContext(), packageName, service);
    }

綁定服務端HermesService，獲取binder

    public void bind(Context context, String packageName, Class<? extends HermesService> service){
        HermesServiceConnection connection = new HermesServiceConnection(service);
        mHermesServiceConnections.put(service, connection);
        Intent intent;
        if (TextUtils.isEmpty(packageName)){
            intent = new Intent(context, service);
        }else{
            intent = new Intent();
            intent.setClassName(packageName,service.getName());
        }
        context.bindService(intent, connection, Context.BIND_AUTO_CREATE);
    }


        private class HermesServiceConnection implements ServiceConnection{

            private Class<? extends HermesService> mClass;

            public HermesServiceConnection(Class<? extends HermesService> mClass) {
                this.mClass = mClass;
            }

            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                SunService sunService = SunService.Stub.asInterface(service);//獲取binder
                mHermesServices.put(mClass, sunService);
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                mHermesServices.remove(mClass);
            }
        }

3.跨進程通訊

客戶端獲取服務端單例時通過動態代理

    IUserManager iUserManager = Hermes.getDefault().getInstance(IUserManager.class);

    public <T> T getInstance(Class<T> clazz){
        return getProxy(HermesService.class, clazz);
    }

    private <T> T getProxy(Class<? extends HermesService> service, Class clazz){
        ClassLoader classLoader = service.getClassLoader();
        return (T) Proxy.newProxyInstance(classLoader, new Class<?>[]{clazz},
                new HermesInvocationHandler(service, clazz));
    }

當客戶端通過動態代理調用單例方法時，會響應invoke方法，如下：

public class HermesInvocationHandler implements InvocationHandler {

    private Class clazz;
    private static Gson gson = new Gson();
    private Class hermesService;

    public HermesInvocationHandler(Class<? extends HermesService> service, Class clazz){
        this.clazz = clazz;
        this.hermesService = service;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Response responce= Hermes.getDefault().sendObjectRequest(hermesService, clazz, method, args); //1
        if (!TextUtils.isEmpty(responce.getData())){
            ResponseBean responceBean = gson.fromJson(responce.getData(), ResponseBean.class);
            if (responceBean.getData() != null){
                String data = gson.toJson(responceBean.getData());
                Class<?> returnType = method.getReturnType();
                return gson.fromJson(data, returnType);
            }
        }
        return null;
    }
}

代碼1會根據單例類名、調用方法名封裝成request對象，如下：

    public <T> Response sendObjectRequest(Class<? extends HermesService> hermesServiceClass, Class<T> clazz, Method method, Object[] parameters) {
        RequestBean requestBean = new RequestBean();
        //獲取class name
        ClassId classId = clazz.getAnnotation(ClassId.class);
        //是否加註解
        if (classId == null){
            requestBean.setClassName(clazz.getName());
            requestBean.setResultClassName(clazz.getName());
        }else{
            requestBean.setClassName(classId.value());
            requestBean.setResultClassName(classId.value());
        }

        //設置方法名
        if (method != null){
            requestBean.setMethodName(TypeUtils.getMethodId(method));
        }

        //設置參數信息，將參數都json化
        RequestParameter[] requestParameters = null;
        if (parameters != null && parameters.length > 0){
            requestParameters = new RequestParameter[parameters.length];
            for (int i = 0; i < parameters.length; i++) {
                Object parameter = parameters[i];
                String parameterClassName = parameter.getClass().getName();
                String parameterValue = gson.toJson(parameter);

                RequestParameter requestParameter = new RequestParameter(parameterClassName, parameterValue);
                requestParameters[i] = requestParameter;
            }
        }
        if (requestParameters != null){
            requestBean.setRequestParameters(requestParameters);
        }

        //封裝爲Request對象
        Request request = new Request(gson.toJson(requestBean), TYPE_GET);
        return serviceConnectionManager.request(hermesServiceClass, request);//1
    }
...

	//serviceConnectionManager.request
    public Response request(Class<? extends HermesService> sunHermesServiceClass, Request request){
        SunService sunService = mHermesServices.get(sunHermesServiceClass);//獲取緩存的binder
        if (sunService != null){
            try {
                return sunService.send(request);//通過binder調用服務端的send
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

服務端接收到信息後，生成響應對象

public class HermesService extends Service{

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

    private SunService.Stub mBinder = new SunService.Stub() {
        @Override
        public Response send(Request request)  {
            ResponseMake responseMake = null;
            switch (request.getType()){
                case Hermes.TYPE_GET:
                    //獲取單例
                    responseMake = new InstanceResponseMake();
                    break;
            }
            if (responseMake != null){
                return responseMake.makeResponse(request);//根據request生成response
            }
            return null;
        }
    };
}

生成response對象如下：

    public Response makeResponse(Request request){
        //1. 取出request中的requestBean消息並轉換爲requestBean。
        RequestBean requestBean = gson.fromJson(request.getData(), RequestBean.class);

        //2. 通過requestBean中設置的目標單例類的名字去加載類。
        resultClass = typeCenter.getClassType(requestBean.getResultClassName());

        //3. 通過requestBean中的設置的方法名獲取到要執行的具體方法。
        setMethod(requestBean);//1

        //4. 組裝參數，將參數進行還原組裝。
        RequestParameter[] requestParameters = requestBean.getRequestParameters();
        if (requestParameters != null && requestParameters.length > 0){
            mParameters = new Object[requestParameters.length];
            for (int i = 0; i < requestParameters.length; i++) {
                RequestParameter requestParameter = requestParameters[i];
                Class<?> clazz = typeCenter.getClassType(requestParameter.getParameterClassName());
                mParameters[i] = gson.fromJson(requestParameter.getParameterValue(), clazz);
            }
        }else{
            mParameters = new Object[0];
        }

        //5. 執行方法，並得到執行結果
        Object resultObj = invokeMethod();//2

        //6. 將執行結果封裝爲Response返回給客戶端進程
        ResponseBean responseBean = new ResponseBean(resultObj);
        return new Response(gson.toJson(responseBean));
    }

代碼1,2在InstanceResponseMake中實現，

    @Override
    protected void setMethod(RequestBean requestBean) {
        try {
            instance = objectCenter.get(requestBean.getClassName());
            if (instance == null){//爲獲取到單例對象，需要先獲取
            	//服務端單例的方法名必須爲getInstance
                Method getInstanceMethod = resultClass.getMethod("getInstance", new Class[]{});
                if (getInstanceMethod != null){
                    instance = getInstanceMethod.invoke(null);//獲取單例對象
                    objectCenter.put(instance);//緩存起來
                }
            }
			//獲取到request中的方法名
            mMethod = typeCenter.getMethod(resultClass, requestBean);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @Override
    protected Object invokeMethod() {
        Object object = null;
        try {
        	//最終通過反射，調用服務端方法
            object = mMethod.invoke(instance, mParameters);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return object;
    }

項目地址：https://github.com/hxljy/HermesTest

aidl跨進程通訊封裝(仿hermes)

一、Hermes實現核心思想

二、封裝使用

1.創建跨進程單例

2.服務端註冊

3.客戶端連接

4.跨進程通訊，客戶端獲取服務端單例

三、核心代碼

1.服務端註冊

2.客戶端連接

3.跨進程通訊

高效率使用windows

智能決策新時代：可視化大屏是否能夠超越傳統白板？

針對RecyclerView的優化整理

RecyclerView整理

ReactNative WebView onNavigationStateChange等方法不響應

ReactNative關於普通函數和箭頭函數的調用方式

Java編譯過程、c/c++編譯過程區別

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結