本文主要讲述一种设计思路，组件化架构市面上已经有很多大厂成熟的方案，但是在组件化过程中，偶尔会遇到2个独立业务子模块间没有相互引用，也需要能直接调用对方的功能，因此我想到通过方法路由来解决，如果还有疑问，可以发邮件到我的邮箱ufolca@163.com或者加我微信号【the51alien】备注一下“简书”，如有不妥之处，还请指正

起源

一次跨部门合作开发APP时遇到一个问题，我们各自开发几个业务组件，A部门有个功能需要直接调用我这边的功能，如果只是打开我这边的界面，可以通过界面路由唤起，这时很容易想到了2种实现

• 把这个功能抽取到业务组件的基类base组件里

• 把这个功能代码copy一份到A部门的组件里

这2种方案一种是会让基类组件涉及到业务，另一种如果该业务功能后期有修改得把所有组件里copy这块代码的都要改一次，均不是完美的解决方案

启发

联想到页面路由方案，既然页面我可以通过url来调用，方法为什么不可以呢，那我就试试通过代理的模式来实现

项目结构图

base模块IMethodBaseProxy.java

public interface IMethodBaseProxy {
    /**
     * @param modelTag   模块别名
     * @param methodName 方法名
     * @param params     方法参数数组
     * @return true 当前代理类方法支持该方法并且执行 ；false 当前代理类里不支持该方法名和参数
     */
    boolean envoke(String modelTag, String methodName, Object[] params);


    /**
     * @return 返回代理模块名
     */
    String getTag();
}

base模块ModelProxyManager.java-用来管理和执行所有业务模块的方法代理

public class ModelProxyManager {
    private HashMap<String, IMethodBaseProxy> methodProxyMap = new HashMap<>();

    public static class ModelProxyManagerHolder {
        public static ModelProxyManager instance = new ModelProxyManager();
    }

    public static ModelProxyManager getInstance() {
        return ModelProxyManagerHolder.instance;
    }

    private ModelProxyManager() {
    }
    public void addMethodProxy(IMethodBaseProxy proxy) {
        if (methodProxyMap != null) {
            methodProxyMap.put(proxy.getTag(), proxy);
        }
    }

    /**
     * 遍历寻找对应的方法所在的代理类并且进行调用
     *
     * @param modelTag   模块别名
     * @param methodName 方法名
     * @param paras      方法参数
     * @return
     */
    public boolean envoke(String modelTag, String methodName, Object[] paras) {
        if (methodProxyMap != null && methodProxyMap.containsKey(modelTag)) {
            IMethodBaseProxy methodProxy = methodProxyMap.get(modelTag);
            if (methodProxy.envoke(modelTag, methodName, paras)) {
                return true;
            }
        }
        return false;
    }
}

a模块AMethodProxy.java-将a模块的业务功能通过方法代理暴露出来

public class AMethodProxy implements IMethodBaseProxy {
    @Override
    public boolean envoke(String modelTag, String methodName, Object[] params) {
        if ("test".equals(methodName)) {
            test();
            return true;
        } else if ("testContext".equals(methodName)) {
            if (params != null && params.length == 1) {
                try {
                    testContext((Context) params[0]);
                    return true;
                } catch (Exception e) {

                }
            }
        } else if ("testCallback".equals(methodName)) {
            if (params != null && params.length == 3) {
                try {
                    testCallback((Context) params[0], params[1].toString(), (MethoProxyCallBack) params[2]);
                    return true;
                } catch (Exception e) {

                }
            }
        }
        return false;

    }

    private void testCallback(Context ctx, String s, MethoProxyCallBack callBack) {
        if (callBack != null) {
            callBack.callBack("{\"" + s + "\":\"success\"}");
        }
    }

    private void testContext(Context ctx) {
        Toast.makeText(ctx, "moudle-a.testContext()", Toast.LENGTH_SHORT).show();
    }

    private void test() {
        Log.d("moudle-a.test()", "success");
    }

    @Override
    public String getTag() {
        return "a";
    }
}

b模块BTest.java-用来调用a模块的业务方法

public class BTest {

    public void test() {
        ModelProxyManager.getInstance().envoke("a", "test", null);
    }

    public void testContext(Context context) {
        ModelProxyManager.getInstance().envoke("a", "testContext", new Object[]{context});
    }

    public void testCallback(Context context, String s, MethoProxyCallBack callBack) {
        ModelProxyManager.getInstance().envoke("a", "testCallback", new Object[]{context, s, callBack});
    }
}

app模块MainActivity.java-用来测试跨组件方法调用

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //模块A的方法代理添加到总的方法代理中心
        ModelProxyManager.getInstance().addMethodProxy(new AMethodProxy());
        final BTest bTest = new BTest();
        findViewById(R.id.btn1).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bTest.test();
            }
        });
        findViewById(R.id.btn2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bTest.testContext(MainActivity.this);
            }
        });
        findViewById(R.id.btn3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bTest.testCallback(MainActivity.this, "bbb", new MethoProxyCallBack() {
                    @Override
                    public void callBack(String jsonStr) {
                        Toast.makeText(MainActivity.this, "moudle-a.testCallback()===para:" + jsonStr, Toast.LENGTH_SHORT).show();
                    }
                });
            }
        });
    }
}

传送门

demo地址