## 前言每个应用在启动的时候都会初始化一个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. 实现思路 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; } } ``` 2. 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(); } } ``` 3. application在初始化的时候可以扫描dex下特定路径下的类，获取类的路径，然后通过反射获取代理类实例, 调用代理类的onCreate方法，从而调用到各个模块的生命周期类的onCreate方法，实现模块生命周期，扫描代码如下所示： ``` /** * 通过指定包名，扫描包下面包含的所有的ClassName * * @param context U know * @param packageName 包名 * @return 所有class的集合 */ public static Set getFileNameByPackageName(Context context, final String packageName) throws PackageManager.NameNotFoundException, IOException, InterruptedException { final Set classNames = new HashSet<>(); List 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 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，工程结构如下所示： ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/591bc464d7864126852ddd09a9ef0590~tplv-k3u1fbpfcp-watermark.image?) ModuleLifeCycle代码如下所示， ``` @Retention(RetentionPolicy.CLASS) @Target(ElementType.TYPE) public @interface ModuleLifeCycle { String moduleName(); String desc(); } ``` #### 2. 新建一个android module lib，命名为module-lifecycle-api，工程结构如下所示： ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ba9424f3a7464b37878b3e7941ff7b58~tplv-k3u1fbpfcp-watermark.image?) 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，代码结构如下 ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1d48cde64de643c4881c3cade1ecd015~tplv-k3u1fbpfcp-watermark.image?) 在这个模块中，我们将使用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 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 getSupportedAnnotationTypes() { Set set = new LinkedHashSet<>(); set.add(ModuleLifeCycle.class.getCanonicalName()); return set; } @Override public SourceVersion getSupportedSourceVersion() { return SourceVersion.latestSupported();//改成这个后process方法会进来两次，查一下去为什么 } @Override public boolean process(Set set, RoundEnvironment roundEnvironment) { Set 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(); } } ``` 以上就完成了模块生命周期的初始化过程了 ## [github链接](https://github.com/18824863285/ModuleLifeCycle)