java（Android）跨Module调用对应类方法需求解决方案

不念不忘少年蓝@ 2022-05-21 11:43 146阅读 0赞

在开发组件化项目中，遇到一个这样的问题，两个不同的Module相互之间没有任何直接依赖关系，现在需求是需要在Module\_A中调用Module\_B中的某个类的方法，以下为解决此问题的方法；

采用的核心技术：路由、反射；

解决问题的过程，首先将需要调用的类通过路由注册，注册到路由中心，这里讲Module\_B中的类注册到了路由中心，在Module\_A中首先先通过路由中心获取到已经注册了的Module\_B的类，获取到Class后通过反射原理获取当前对象实例，然后继续通过反射调用调用当前实例对象的对应方法（支持无参方法及有参方法），至此调用方法已实现，具体示例如下：

1、路由注册工具类：

/**
     * Class类路由注册工具类
     * Created by sun.li on 2018/7/6.
     *
     * @author sun.li
     */
    
    public class RouterClassUtil implements RouterInter<Object,Class<? extends Object>>{
    
        private ConcurrentHashMap<String, Class<? extends Object>> mClassZ = new ConcurrentHashMap();
        private ConcurrentHashMap<String, Object> mClassA = new ConcurrentHashMap();
        private static RouterClassUtil mInstance;
    
        private RouterClassUtil() {
        }
    
        public static RouterClassUtil getInstance() {
            if(null == mInstance) {
                synchronized(RouterActivity.class) {
                    if(null == mInstance) {
                        mInstance = new RouterClassUtil();
                    }
                }
            }
            return mInstance;
        }
    
        @Override
        public void routerT(String key, Object obj) {
            Object cacheActivity = this.mClassA.get(key);
            if(null == cacheActivity || obj != cacheActivity) {
                this.mClassA.put(key, obj);
            }
        }
    
        @Override
        public Object invokT(String key) {
            return this.mClassA.get(key);
        }
    
        @Override
        public void routerV(String key, Class<?> aClass) {
            Class cacheClass = this.mClassZ.get(key);
            if(null == cacheClass || aClass != cacheClass) {
                this.mClassZ.put(key, aClass);
            }
        }
    
        @Override
        public Class<? extends Object> invokV(String key) {
            return this.mClassZ.get(key);
        }
    
        /** 获取Object对象*/
        public Object getObject(String key){
            Object object = invokT(key);
            if(null == object){
                try {
                    Class<? extends Object> aClass = invokV(RouterHttpClassKey.KEY_MODULE_HTTP_HTTPUTIL);
                    if(null != aClass) {
                        object = aClass.newInstance();//通过Class对象实例化当前对象
                    }
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            return object;
        }
    }

2、路由对应Class配置类（此处声明具体的Class类路径，注册时通过反射原理获取对应的Class）：

/**
     * 路由跳转Class对应key配置类
     * Created by sun.li on 2018/7/6.
     *
     * @author sun.li
     */
    
    public class RouterHttpClassKey {
    
        /**
         * HttpUtil
         */
        public static final String KEY_MODULE_HTTP_HTTPUTIL = "**.**.**.util.HttpLibUtil";
    }

3、路由注册：

RouterClassUtil.getInstance().routerV(value,correspondingClass);

4、路由调用获取当前的对象并且通过反射调用对应的方法：

4.1、无参方法调用：

/** 调用Module中的对应无参方法*/
    public void callMethodInModule(@NonNull String className,@NonNull String methodName){
        Object object = RouterClassUtil.getInstance().getObject(className);
        if (null != object) {
            Method method = getMethod(object,methodName,null);
            if(null!=method){
                try {
                    //执行对象object中通过反射获取的方法
                    method.invoke(object);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
    }

4.2、有参方法调用（发射调用多参数时因为方法限制，还未想到好的方式）：

/**
     * 公共网络请求参数对象
     * Created by sun.li on 2018/7/6.
     *
     * @author sun.li
     */
    
    public class BaseObjectParameterBean {
    
        public BaseObjectParameterBean(){
    
        }
    
        public BaseObjectParameterBean(Class parameterType, Object parameterValue){
            setParameterType(parameterType);
            setParameterValue(parameterValue);
        }
    
        /** 参数值*/
        private Object parameterValue;
    
        /** 参数类型*/
        private Class parameterType;
    
        public Object getParameterValue() {
            return parameterValue;
        }
    
        public void setParameterValue(Object parameterValue) {
            this.parameterValue = parameterValue;
        }
    
        public Class getParameterType() {
            return parameterType;
        }
    
        public void setParameterType(Class parameterType) {
            this.parameterType = parameterType;
        }
    }

/** 调用Module中的对应有参方法*/
    public void callMethodInModule(@NonNull String className, @NonNull String methodName, List<BaseObjectParameterBean> mList){
        if(null!=mList && mList.size()>0){
            /* 参数类型集合*/
            List<Class> classList = new ArrayList<>();
            /* 参数值集合*/
            List<Object> objectList = new ArrayList<>();
            for (int i = 0; i < mList.size(); i++) {
                BaseObjectParameterBean baseHttpRequestParameterBean = mList.get(i);
                if(null != baseHttpRequestParameterBean){
                    if(null != baseHttpRequestParameterBean.getParameterValue() && null != baseHttpRequestParameterBean.getParameterType()){
                        classList.add(baseHttpRequestParameterBean.getParameterType());
                        objectList.add(baseHttpRequestParameterBean.getParameterValue());
                    }
                }
            }
            if(classList.size()>0 && objectList.size()>0){
                Object object = RouterClassUtil.getInstance().getObject(className);
                if (null != object) {
                    Method method = getMethod(object,methodName,classList);
                    if(null!=method){
                        try {
                            //执行对象object中通过反射获取的方法
                            Object[] mObjectList = new Object[objectList.size()];
                            for (int i = 0; i < objectList.size(); i++) {
                                if(null != objectList.get(i)){
                                    mObjectList[i] = objectList.get(i);
                                }
                            }
                            method.invoke(object,mObjectList);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }else{
            callMethodInModule(className,methodName);
        }
    }

private Method getMethod(Object object, @NonNull String methodName, List<Class> mList){
        if(null == object || TextUtils.isEmpty(methodName)){
            return null;
        }
        Method method = null;
        try {
    
            if(null != mList && mList.size()>0){
                // 父类对象调用子类有参数的方法(反射原理)
                Class[] mClassList = new Class[mList.size()];
                for (int i = 0; i < mList.size(); i++) {
                    if(null != mList.get(i)){
                        mClassList[i] = mList.get(i);
                    }
                }
                method = object.getClass().getMethod(methodName,mClassList);
            }else{
                method = object.getClass().getMethod(methodName);// 父类对象调用子类方法(反射原理)
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return method;
    }

4.3、调用示例：

BaseObjectUtil.getInstance().callMethodInModule(RouterHttpClassKey.KEY_MODULE_HTTP_HTTPUTIL,"test");
    
    List<BaseHttpRequestParameterBean> beans = new ArrayList<>();
    beans.add(new BaseHttpRequestParameterBean(String.class,"哈哈"));
    beans.add(new BaseHttpRequestParameterBean(Integer.class,88));
    
    BaseHttpRequestParameterBean baseHttpRequestParameterBean = new BaseHttpRequestParameterBean();
    baseHttpRequestParameterBean.setParameterType(Integer.class);
    beans.add(baseHttpRequestParameterBean);
    
    BaseObjectUtil.getInstance().callMethodInModule(RouterHttpClassKey.KEY_MODULE_HTTP_HTTPUTIL,"test2",beans);

调用结果：

07-06 16:07:29.862 10329-10329/cc.\*\*.\*\* E/HttpLibUtil:: 我是HttpLib中的test方法  
07-06 16:07:29.862 10329-10329/cc.\*\*.\*\* E/HttpLibUtil:: 我是HttpLib中的test2方法,str=哈哈 i=88