组件化之如何实现模块生命周期自动管理
前言
每个应用在启动的时候都会初始化一个application类,我们可以在这个类中做一些初始化的操作,例如第三方sdk的初始化,在实施组件化工程后,不同的业务模块也需要在应用启动的时候做一些初始化的操作,这个就涉及到了模块的生命周期问题,在应用启动时候,各个模块可以拿到application,在Application内部的生命周期方法被调用的时候,各个模块也有相应的生命周期方法被调用
初步实现
1.抽取一个IModuleLifeCycle类
代码如下
public interface IModuleLifeCycle { int MAX_PRIORITY = 12; int MIN_PRIORITY = 1; int DEFAULT_PRIORITY = 6; void onCreate(Application application); void onTerminate(); /** * 返回组件的优先级,优先级范围为[1-12],12为最高,1为最低,默认优先级是1 * @return */ int getPriority(); }复制代码
2.实现IModuleLifeCycle类
各个模块内新建一个类实现IModuleLifeCycle类,我们把这个当作模块的application类,在这个类可以做一些初始化的操作,还可以获取application对象,做一些初始化全局变量的工作
3.如何管理组件的生命周期
假如现在有moduleA, moduleB, moduleC,然后这三个模块分别对应有ModuleALifeCycle,ModuleBLifeCycle,ModuleCLifeCycle实现了IModuleLifeCycle类,用于实现模块的生命周期,为了实现这三个模块的生命周期,简单的做法是在application类中获取这个三个类的实例,然后在application的onCreate方法中调用ModuleALifeCycle,ModuleBLifeCycle,ModuleCLifeCycle的onCreate方法,代码如下:
@Override public void onCreate() { super.onCreate(); IModuleLifeCycle moduleA = new ModuleALifeCycle(); IModuleLifeCycle moduleB = new ModuleBLifeCycle(); IModuleLifeCycle moduleC = new ModuleCLifeCycle(); moduleA.onCreate(this); moduleB.onCreate(this); moduleC.onCreate(this); } 复制代码
这种方式很简单,有多少个模块,就初始化多少个模块生命周期类,然后调用onCreate()即可,但是这种做法是不利于维护的,每次新加一个模块,就需要新建一个模块类,然后在application中调用这个类。而且,在模块化的开发模式下,各个模块独立运行的时候,壳工程对各个模块是没有依赖的,这就会导致上面的代码编译报错,所以是非常不可取的,因此,有两种方法可以优化:
1.在配置文件中定义各个模块生命周期类的路径, 在assets中配置一个json文件,其中定义着各个模块的生命周期类的路径,然后在application初始化的时候通过反射获取这些类,然后调用其中生命周期方法,从而完成模块的生命周期的初始化,但是这种方法还是不够灵活,因为需要维护配置文件,所以更好的方法是连配置文件都不需要维护
2.使用APT+javaPoet的方式实现,给模块生命周期类添加注解,然后使用APT扫描特定注解,然后借助javaPoet生成生命周期代理类,放在特定的目录下,这些代理类拥有模块生命周期类的实例,每次application初始化的时候,就会扫描dex下面特定路径的类,获得这些类的路径,然后通过反射获取类的实例,这些类就是javaPoet生成的代理类,我们会调用这些代理类的内部方法,从而调用到模块生命周期类的方法,完成各个模块生命周期的初始化
最终实现
使用APT+javaPoet的方式实现
1. 实现思路
在工程中新建一个类实现IModuleLifeCycle类,并且添加特定的注解,代码如下
@ModuleLifeCycle(moduleName = "main", desc = "主模块") public class MainLifeCycle implements IModuleLifeCycle { @Override public void onCreate(Application application) { //.. 初始化主工程的Application的时候会调用到这里 //.. application是整个应用的application // ..在这里完成自身module的初始化 System.out.println("====>onCreate:"+application); } @Override public void onTerminate() { //.. Application被销毁 } @Override public int getPriority() { return DEFAULT_PRIORITY; } }复制代码
APT在编译的时候会扫描这个特定的注解,然后利用javaPoet生成模块生命周期的代理类,放在特定的路径下,代理类代码如下:
public class MainLifeCycleProxy implements IModuleLifeCycle { public MainLifeCycle mModuleLifeCycle; public MainLifeCycleProxy() { mModuleLifeCycle = new MainLifeCycle(); } @Override public void onCreate(Application application) { mModuleLifeCycle.onCreate(application); } @Override public int getPriority() { return mModuleLifeCycle.getPriority(); } @Override public void onTerminate() { mModuleLifeCycle.onTerminate(); } }复制代码
application在初始化的时候可以扫描dex下特定路径下的类,获取类的路径,然后通过反射获取代理类实例, 调用 代理类的onCreate方法,从而调用到各个模块的生命周期类的onCreate方法,实现模块生命周期,扫描代码如下所示:
/** * 通过指定包名,扫描包下面包含的所有的ClassName * * @param context U know * @param packageName 包名 * @return 所有class的集合 */ public static Set<String> getFileNameByPackageName(Context context, final String packageName) throws PackageManager.NameNotFoundException, IOException, InterruptedException { final Set<String> classNames = new HashSet<>(); List<String> paths = getSourcePaths(context); final CountDownLatch parserCtl = new CountDownLatch(paths.size()); for (final String path : paths) { DefaultPoolExecutor.getInstance().execute(new Runnable() { @Override public void run() { DexFile dexfile = null; try { if (path.endsWith(EXTRACTED_SUFFIX)) { //NOT use new DexFile(path), because it will throw "permission error in /data/dalvik-cache" dexfile = DexFile.loadDex(path, path + ".tmp", 0); } else { dexfile = new DexFile(path); } Enumeration<String> dexEntries = dexfile.entries(); while (dexEntries.hasMoreElements()) { String className = dexEntries.nextElement(); if (className.startsWith(packageName)) { classNames.add(className); } } } catch (Throwable ignore) { Log.e("ARouter", "Scan map file in dex files made error.", ignore); } finally { if (null != dexfile) { try { dexfile.close(); } catch (Throwable ignore) { } } parserCtl.countDown(); } } }); } parserCtl.await(); return classNames; }复制代码
2. 实现过程
1. 定义注解
在androidStudio中新建一个Java Library module,然后新建一个注解类,命名为ModuleLifeCycle,工程结构如下所示:
ModuleLifeCycle代码如下所示,
@Retention(RetentionPolicy.CLASS) @Target(ElementType.TYPE) public @interface ModuleLifeCycle { String moduleName(); String desc(); }复制代码
2. 新建一个android module lib,命名为module-lifecycle-api,工程结构如下所示:
IModuleLifeCycle是模块生命周期的接口,代码如下:
public interface IModuleLifeCycle { int MAX_PRIORITY = 12; int MIN_PRIORITY = 1; int DEFAULT_PRIORITY = 6; void onCreate(Application application); void onTerminate(); /** * 返回组件的优先级,优先级范围为[1-10],10为最高,1为最低,默认优先级是5 * @return */ int getPriority(); }复制代码
其中getPriority()方法表示模块加载的优先级,在多模块工程中,优先级越高的模块,越先初始化生命周期, ModuleLifeCycleManager是生命周期的管理类,用于按照优先级初始化各个模块
3.新建一个 java lib module,命名为module-lifecycle-apt,代码结构如下
在这个模块中,我们将使用apt扫描注解,并且用javaPoet生成代理类,module-lifecycle-apt库的build.gradle 配置代码如下:
plugins { id 'java-library' } dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) //这是谷歌提供的一个自动服务注册框架,需要用到 annotationProcessor 'com.google.auto.service:auto-service:1.0-rc7' compileOnly 'com.google.auto.service:auto-service-annotations:1.0-rc7' implementation 'com.squareup:javapoet:1.10.0' implementation project(':module-lifeCycle-annotation') } java { sourceCompatibility = JavaVersion.VERSION_1_7 targetCompatibility = JavaVersion.VERSION_1_7 }复制代码
ModuleLifeCycleProcessor调用了apt的api来扫描特定注解,代码如下:
@AutoService(Processor.class) public class ModuleLifeCycleProcessor extends AbstractProcessor { public Filer filer; //文件相关的辅助类 public Elements elements; //元素相关的辅助类 public Messager messager; //日志相关的辅助类 private Map<String, CodeCreateFactory> codeCreateFactoryMap = new HashMap<>(); @Override public synchronized void init(ProcessingEnvironment processingEnvironment) { super.init(processingEnvironment); filer = processingEnv.getFiler(); elements = processingEnv.getElementUtils(); messager = processingEnv.getMessager(); } @Override public Set<String> getSupportedAnnotationTypes() { Set<String> set = new LinkedHashSet<>(); set.add(ModuleLifeCycle.class.getCanonicalName()); return set; } @Override public SourceVersion getSupportedSourceVersion() { return SourceVersion.latestSupported();//改成这个后process方法会进来两次,查一下去为什么 } @Override public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) { Set<? extends Element> elementSet = roundEnvironment.getElementsAnnotatedWith(ModuleLifeCycle.class); for (Element element : elementSet) { if (!element.getKind().isClass()) { throw new RuntimeException("ModuleLifeCycle注解只能用在类上"); } TypeElement typeElement = (TypeElement) element; if (codeCreateFactoryMap.containsKey(typeElement.getSimpleName().toString())) { codeCreateFactoryMap.get(typeElement.getSimpleName().toString()).generateCode(); } else { CodeCreateFactory codeCreateFactory = new CodeCreateFactory(typeElement, processingEnv); codeCreateFactoryMap.put(typeElement.getSimpleName().toString(), codeCreateFactory); codeCreateFactory.generateCode(); } } return true; } }复制代码
CodeCreateFactory调用了javaPoet的api来生成指定的代码,并且保存到特定路径下,代码如下:
public class CodeCreateFactory { TypeElement typeElement; ProcessingEnvironment processingEnv; public CodeCreateFactory(TypeElement typeElement, ProcessingEnvironment processingEnv) { this.typeElement = typeElement; this.processingEnv = processingEnv; } public void generateCode() { TypeSpec ModuleFeedLifeCycleManger = TypeSpec .classBuilder(typeElement.getSimpleName().toString() + "Proxy") .addModifiers(Modifier.PUBLIC) .addSuperinterface(ClassName.get("com.quwan.moduleLifecycleApi", "IModuleLifeCycle")) .addField(FieldSpec .builder(ClassName.get(typeElement.getQualifiedName().toString().replace("." + typeElement.getSimpleName().toString(), ""), typeElement.getSimpleName().toString()), "mModuleLifeCycle", Modifier.PUBLIC) .build()) .addMethod(MethodSpec .constructorBuilder() .addModifiers(Modifier.PUBLIC) .addStatement("mModuleLifeCycle = new $T()", ClassName.get(typeElement.getQualifiedName().toString().replace("." + typeElement.getSimpleName().toString(), ""), typeElement.getSimpleName().toString())) .build()) .addMethod(MethodSpec .methodBuilder("onCreate") .addAnnotation(ClassName.get("java.lang", "Override")) .addModifiers(Modifier.PUBLIC) .addParameter( ParameterSpec .builder(ClassName.get("android.app", "Application"), "application") .build() ) .addStatement("mModuleLifeCycle.onCreate(application)") .build()) .addMethod(MethodSpec .methodBuilder("getPriority") .returns(INT) .addAnnotation(ClassName.get("java.lang", "Override")) .addModifiers(Modifier.PUBLIC) .addStatement("return mModuleLifeCycle.getPriority()") .build()) .addMethod(MethodSpec .methodBuilder("onTerminate") .returns(VOID) .addAnnotation(ClassName.get("java.lang", "Override")) .addModifiers(Modifier.PUBLIC) .addStatement("mModuleLifeCycle.onTerminate()") .build()) .build(); JavaFile javaFile = JavaFile.builder("com.component.lifeCycle", ModuleFeedLifeCycleManger).build(); try { // 生成文件 javaFile.writeTo(processingEnv.getFiler()); } catch (IOException e) { e.printStackTrace(); } } }复制代码
以上就完成了实现过程,其实还是挺简单的
3. 如何使用
1. 在application的onCreate()方法中调用ModuleLifeCycleManager的方法,代码如下:
public class App extends Application { @Override public void onCreate() { super.onCreate(); ModuleLifeCycleManager.init(this); } @Override public void onTerminate() { super.onTerminate(); ModuleLifeCycleManager.terminate(); } }复制代码
2. 在模块中新建一个生命周期类,实现IModuleLifeCycle接口,并且添加注解,代码如下
@ModuleLifeCycle(moduleName = "main", desc = "主模块") public class MainLifeCycle implements IModuleLifeCycle { @Override public void onCreate(Application application) { //.. 初始化主工程的Application的时候会调用到这里 //.. application是整个应用的application // ..在这里完成自身module的初始化 System.out.println("====>onCreate:"+application); } @Override public void onTerminate() { //.. Application被销毁 } @Override public int getPriority() { return DEFAULT_PRIORITY; } }复制代码
3. rebuild一下工程,生成模块生命周期代理类,代码如下:
package com.component.lifeCycle; import android.app.Application; import com.quwan.moduleLifecycleApi.IModuleLifeCycle; import com.quwan.modulelifecycle.MainLifeCycle; import java.lang.Override; public class MainLifeCycleProxy implements IModuleLifeCycle { public MainLifeCycle mModuleLifeCycle; public MainLifeCycleProxy() { mModuleLifeCycle = new MainLifeCycle(); } @Override public void onCreate(Application application) { mModuleLifeCycle.onCreate(application); } @Override public int getPriority() { return mModuleLifeCycle.getPriority(); } @Override public void onTerminate() { mModuleLifeCycle.onTerminate(); } }复制代码
以上就完成了模块生命周期的初始化过程了
作者:陈平大将
链接:https://juejin.cn/post/7029216556965953543