前言
每个应用在启动的时候都会初始化一个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，工程结构如下所示：
[图片上传失败...(image-524d0c-1636621603045)]
ModuleLifeCycle代码如下所示，
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)
public @interface ModuleLifeCycle {
String moduleName();
String desc();
}
2. 新建一个android module lib，命名为module-lifecycle-api，工程结构如下所示：
[图片上传失败...(image-1e40d4-1636621603045)]
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-ad0c2-1636621603045)]
在这个模块中，我们将使用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();
}
}
以上就完成了模块生命周期的初始化过程了
