前言：
我们知道Android使用Android studio开发越来越方便,特别是Gradle的配置让我们省去了很多依赖第三方的工作。今天就针对这块来讲一个可能很多人没有遇到，但是遇到后不知如何处理的问题。
比如有这样一个需求：
我有一个基线app module,现在要接入不同的功能：IM、直播、人脸识别。很自然的我们会把这三块功能分别抽成三个不同的module。但是客户要求需要三个版本分别需要一个、两个、三个功能，很多人可能就一股脑的依赖三个module，但是这时候客户提出，不需要的功能不能编译进apk以达到减小apk体积的效果。
三个功能分别抽出初始化资源（init）、启动功能（start）、结束释放资源（release）方法，每个module分别有 IMControl、LiveControl、FaceControl工具类作为控制。
那么问题来了，比如APP的module有一个总的管理类MainControl，分别控制三个功能的init、start、release 。那么在动态依赖module的过程中就会发现，例如我只依赖IM module，那么无论如何我无法调用LiveControl和FaceControl。那么有没有一种方式去动态依赖module，且可以同时调用每个module的 三个方法呢？
答案是肯定的：
动态依赖可以通过配置gradle同时配合不同的渠道包配置，动态调用未存在类的方法又该怎么做呢？既然这个类未存在那么是不是可以把他们都看成是同一个BaseImpl接口？ 然后这个接口存在这三个方法呢？只要MainControl实现了接口中的方法就可以同时调用每个Control中对应的方法呢？
自然而然我们可能就想到了动态代理的方式，只要代理类调用了init方法则module也执行init方法。
说了这么多，下面通过代码的方式首先解决动态依赖问题
首先看下项目结构
分别包含了三个功能module和一个公共module
假设我们有三个客户：beijing、shanghai、xiamen
创建三个变量用于控制依赖
ext {
isBeijing = false
isShanghai = true
isXiamen = false
}
然后根据变量添加module的依赖
dependencies {
if (rootProject.ext.isBeijing) {
implementation project(path: ':libim')
implementation project(path: ':liblive')
}
if (rootProject.ext.isShanghai) {
implementation project(path: ':libim')
}
if (rootProject.ext.isXiamen) {
implementation project(path: ':libim')
implementation project(path: ':liblive')
implementation project(path: ':libdetect')
}
}
同时添加多渠道的方式区分使用哪些功能点
flavorDimensions "device"
productFlavors {
beijing {
dimension "device"
buildConfigField("String", "packageNames", '"com.wzw.libim,com.wzw.liblive"')
}
shanghai {
dimension "device"
buildConfigField("String", "packageNames", '"com.wzw.libim"')
}
xiamen {
dimension "device"
buildConfigField("String", "packageNames", '"com.wzw.libim,com.wzw.liblive,com.wzw.libdetect"')
}
}
可以看到每个渠道号都添加了一个PackageNames字段，这个后续会讲到
这样就完成了动态依赖的功能，问题的重点来了，如果当前渠道为shanghai,那么对应的就是仅仅依赖了libim,那么总的MainControl又要怎么动态调用没有依赖的类呢？
前文说过我们可以使用动态代理的方式。为了能够清楚简便的说明，我们把每个module控制类都叫做Control.java,且每个类都封装了init()、start()、release()三个方法用于功能的初始化，启用和结束释放。
每个Control实现同样的接口
public interface Subject {
void init();
void start();
void release();
}
public class Control implements Subject {
private static final String TAG = "ControlIM";
@Override
public void init(){
Log.d(TAG, "init: "+TAG);
}
@Override
public void start() {
Log.d(TAG, "start: "+TAG);
}
@Override
public void release(){
Log.d(TAG, "release: "+TAG);
}
}
public class Control implements Subject {
private static final String TAG = "ControlDetect";
@Override
public void init(){
Log.d(TAG, "init: "+TAG);
}
@Override
public void start() {
Log.d(TAG, "start: "+TAG);
}
@Override
public void release(){
Log.d(TAG, "release: "+TAG);
}
}
public class Control implements Subject {
private static final String TAG = "ControlLive";
private static Control instance ;
@Override
public void init(){
Log.d(TAG, "init: "+TAG);
}
@Override
public void start() {
Log.d(TAG, "start: "+TAG);
}
@Override
public void release(){
Log.d(TAG, "release: "+TAG);
}
}
创建代理类
public class ProxySubject implements InvocationHandler {
protected Subject subject;
public ProxySubject(Subject subject) {
this.subject = subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(subject, args);
}
}
App module的MainControl实现代理
首先举个简单的实现例子
public class DynamicProxyTest {
public static void main(String args[]) {
//1.创建目标对象
DynamicRealSubject realSubject = new DynamicRealSubject();
//2.创建调用处理器对象
ProxyHandler proxyHandler = new ProxyHandler(realSubject);
//3.动态生成代理对象
Subject subject = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), proxyHandler);
//4.通过代理对象调用方法
subject.register();
subject.login();
}
}
- 首先创建目标对象即要被代理的对象。
- 其次创建调用处理器对象
- 然后动态生成代理对象
- 最后调用代理方法。
以上步骤最重要的是第一步（代理类ProxySubject已经存在），要怎么生成被代理对象呢？ 实际上前文说过，每个Control都实现了Subject接口，那么就有了统一对象。那这个对象要怎么实例化到具体类呢？
前文我们买下了一个伏笔，即每个渠道中都添加了一个字段例如
buildConfigField("String", "packageNames", '"com.wzw.libim,com.wzw.liblive"'),
因为每个Control类处于不同的module的不同包中，所以在明确客户需求的前提下我们可以动态配置所要的依赖包，有了包名我们就可以通过java 反射的方式获取类。
public void config() {
String packageNames = BuildConfig.packageNames;
String[] split = packageNames.split(",");
for (int i = 0; i < split.length; i++) {
Subject clazz = null;
try {
clazz = (Subject) Class.forName(split[i] + ".Control").newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
if (clazz == null) {
Log.d("TAG", "config: null");
return;
}
ProxySubject proxy = new ProxySubject(clazz);
sub = (Subject) Proxy.newProxyInstance(clazz.getClass().getClassLoader(),
clazz.getClass().getInterfaces(), proxy);
sub.init();
sub.start();
sub.release();
}
}
当然你也可以把每个代理类通过Map<PackageName,Subject> 保存，再适当的时机取出调用。
总结
以上例子通过gradle的配置完成动态添加module的依赖，同时通过Java中的动态代理+反射的方式解决了module动态依赖所引发问题。
