组件化之如何实现模块生命周期自动管理

小涂Ss

于 2021-12-06 14:35:41 发布

阅读量410

点赞数 1

文章标签： android

本文链接：https://blog.csdn.net/Gaga246/article/details/121746466

版权

前言

每个应用在启动的时候都会初始化一个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();
  }
}

以上就完成了模块生命周期的初始化过程了。