自己写个App 启动任务框架也不外云云！

程序员 · 2024-9-14 14:22:17

作者：王晨彦

一、前言

我们在开辟应用的时间，一样平常都会引入 SDK，而大部分 SDK 都要求我们在 Application 中初始化，当我们引入的 SDK 越来越多，就会出现 Application 越来越长，假如 SDK 的初始化任务相互依赖，还要处理处罚许多条件判断，这时，假如再来个异步初始化，信赖各人都会瓦解。
有人大概会说，我都在主线程按顺序初始化不就行了，固然行，只要老板不来找你贫苦。
「小王啊，咱们的 APP 启动时间怎么这么久？」
开个打趣，可见，一个良好的启动框架对于 APP 启动性能而言，是多么的告急！
二、为什么不消 Google 的 StartUp?

说到启动框架，就不得不提 StartUp，究竟是 Google 官方出品，现有的启动框架，或多或少都有参考 StartUp，这里不再具体先容，假如对 StartUp 还不相识，可以参考这篇文章 Jetpack系列之App Startup从入门到出家。
https://juejin.cn/post/7023643365048582174
StartUp 提供了轻巧的依赖任务初始化功能，但是对于一个复杂项目来说，StartUp 有以下不足：
1. 不支持异步任务
假如通过 ContentProvider 启动，所有任务都在主线程实验，假如通过接口启动，所有任务都在同一个线程实验。
2. 不支持组件化
通过 Class 指定依赖任务，必要引用依赖的模块。
3. 不支持多进程
无法单独设置任务必要实验的进程。
4. 不支持启动优先级
固然可以通过指定依赖来设置优先级，但是过于复杂。
三、一个合格的启动框架是怎么样的？

1. 支持异步任务
镌汰启动时间的有用手段。
2. 支持组件化
实在就是解耦，一方面是解耦任务依赖，另一方面是解耦 app 和 module 的依赖。
3. 支持任务依赖
可以简化我们的任务调理。
4. 支持优先级
在没有依赖的情况下，答应任务优先实验。
5. 支持多进程
只在必要的进程中实验初始化任务，可以减轻体系负载，侧面提拔 APP 启动速率。
四、网络任务

假如要做到完全解耦，我们可以使用 APT 网络任务。
起首界说注解，即任务的一些属性。
@Target(AnnotationTarget.CLASS)@Retention(AnnotationRetention.RUNTIME)annotation class InitTask( /**    * 任务名称，需唯一    */ val name: String, /**    * 是否在后台线程实验    */ val background: Boolean = false, /**    * 优先级，越小优先级越高    */ val priority: Int = PRIORITY_NORM, /**    * 任务实验进程，支持主进程、非主进程、所有进程、:xxx、特定进程名    */ val process: Array<String> = [PROCESS_ALL], /**    * 依赖的任务    */ val depends: Array<String> = [])name 作为任务唯一标识，范例为 String 重要是解耦任务依赖。
background 便是否后台实验。
priority 是在主线程、无依赖场景下的实验顺序。
process 指定了任务实验的进程，支持主进程、非主进程、所有进程、:xxx、特定进程名。
depends 指定依赖的任务。
任务的属性界说好，还必要一个实验任务的接口：
interface IInitTask { fun execute(application: Application)}任务必要网络的信息已经界说好了，那么看一下一个真正的任务长什么样。
@InitTask( name = "main", process = [InitTask.PROCESS_MAIN], depends = ["lib"])class MainTask : IInitTask { override fun execute(application: Application) {       SystemClock.sleep(1000)       Log.e("WCY", "main1 execute") }}照旧比较轻巧清楚的。
接下来必要通过 Annotation Processor 网络任务，然后通过 kotlin poet 写入文件。
class TaskProcessor : AbstractProcessor() { override fun process(annotations: MutableSet<out TypeElement>?, roundEnv: RoundEnvironment): Boolean {       val taskElements = roundEnv.getElementsAnnotatedWith(InitTask::class.java)       val taskType = elementUtil.getTypeElement("me.wcy.init.api.IInitTask")       /**       * Param type: MutableList<TaskInfo>       *       * There's no such type as MutableList at runtime so the library only sees the runtime type.       * If you need MutableList then you'll need to use a ClassName to create it.       * [https://github.com/square/kotlinpoet/issues/482]       */       val inputMapTypeName =          ClassName("kotlin.collections", "MutableList").parameterizedBy(TaskInfo::class.asTypeName())       /**       * Param name: taskList: MutableList<TaskInfo>       */       val groupParamSpec = ParameterSpec.builder(ProcessorUtils.PARAM_NAME, inputMapTypeName).build()       /**       * Method: override fun register(taskList: MutableList<TaskInfo>)       */       val loadTaskMethodBuilder = FunSpec.builder(ProcessorUtils.METHOD_NAME)          .addModifiers(KModifier.OVERRIDE)          .addParameter(groupParamSpec)       for (element in taskElements) {          val typeMirror = element.asType()          val task = element.getAnnotation(InitTask::class.java)          if (typeUtil.isSubtype(typeMirror, taskType.asType())) {             val taskCn = (element as TypeElement).asClassName()             /**                * Statement: taskList.add(TaskInfo(name, background, priority, process, depends, task));                */             loadTaskMethodBuilder.addStatement(                   "%N.add(%T(%S, %L, %L, %L, %L, %T()))",                   ProcessorUtils.PARAM_NAME,                   TaskInfo::class.java,                   task.name,                   task.background,                   task.priority,                   ProcessorUtils.formatArray(task.process),                   ProcessorUtils.formatArray(task.depends),                   taskCn             )          }       }       /**       * Write to file       */       FileSpec.builder(ProcessorUtils.PACKAGE_NAME, "TaskRegister\$$moduleName")          .addType(             TypeSpec.classBuilder("TaskRegister\$$moduleName")                   .addKdoc(ProcessorUtils.JAVADOC)                   .addSuperinterface(ModuleTaskRegister::class.java)                   .addFunction(loadTaskMethodBuilder.build())                   .build()          )          .build()          .writeTo(filer)       return true }}看一下天生的文件长什么样。
public class TaskRegister$sample : ModuleTaskRegister {  public override fun register(taskList: MutableList<TaskInfo>): Unit { taskList.add(TaskInfo("main2", true, 0, arrayOf("

ROCESS_ALL"), arrayOf("main1","lib1"),MainTask2())) taskList.add(TaskInfo("main3", false, -1000, arrayOf("

ROCESS_ALL"), arrayOf(), MainTask3())) taskList.add(TaskInfo("main1", false, 0, arrayOf("

ROCESS_MAIN"), arrayOf("lib1"), MainTask()))  }} sample 模块网络到了3个任务，TaskInfo 对任务信息做了聚合。
我们知道 APT 可以天生代码，但是无法修改字节码，也就是说我们在运行时想到拿到注入的任务，还必要将网络的任务注入到源码中。
这里可以借助 AutoRegister 帮我们完成注入。
https://github.com/luckybilly/AutoRegister
注入前：
internal class FinalTaskRegister { val taskList: MutableList<TaskInfo> = mutableListOf() init {       init() } private fun init() {} fun register(register: ModuleTaskRegister) {       register.register(taskList) }}将网络到的任务注入到 init 方法中，注入后的字节码：
/* compiled from: FinalTaskRegister.kt */public final class FinalTaskRegister { private final List<TaskInfo> taskList = new ArrayList(); public FinalTaskRegister() {       init(); } public final List<TaskInfo> getTaskList() {       return this.taskList; } private final void init() {       register(new TaskRegister$sample_lib());       register(new TaskRegister$sample()); } public final void register(ModuleTaskRegister register) {       Intrinsics.checkNotNullParameter(register, "register");       register.register(this.taskList); }}我们通过 APT 天生的类已经乐成的注入到代码中。
小结
至此，我们已经完成了任务的网络，通过 APT 和字节码修改是常见的类网络方案，相比反射，字节码修改没有任何性能的丧失。
厥后发现 Google 已经推出了新的注解处理处罚框架 ksp，处理处罚速率更快，于是果断实验了一把，以是有两种注解处理处罚可以选择，GitHub 上有具体先容。
五、任务调理

任务调理是启动框架的核心，各人大概听到过。

处理处罚依赖任务起首要构建一个「有向无环图」。

什么是有向无环图，看下维基百科的先容：

在图论中，假如一个有向图从恣意顶点出发无法颠末多少条边回到该点，则这个图是一个有向无环图（DAG, Directed Acyclic Graph）。

听起来好像很简朴，那么具体怎么实现呢，本日我们抛开高级概念不谈，用代码带各人实现任务的调理。
起首，必要把任务分为两类，有依赖的任务和无依赖的任务。
有依赖的起首查抄是否有环，假如有循环依赖，直接 throw，这个可以套用公式 —— 怎样判断链表是否有环。
假如没有循环依赖，则网络每个任务的被依赖任务，我们称之为子任务，用于当前任务实验完成后，继承实验子任务。
无依赖的最简朴，直接按照优先级实验即可。

不知道各人是否有疑问：有依赖的任务什么时间启动？

有依赖的任务，依赖链的叶子端点肯定是一个无依赖的任务，因此无依赖的任务实验完成后，就可以开始实验有依赖的任务。
下面用一个小例子来先容：
• A 依赖 B、C
• B 依赖 C
• C 无依赖
树形布局：
1. 分组并梳理子任务。

有依赖：

A: 无子任务
B: 子任务: [A]

无依赖：

C: 子任务: [A, B]

2. 实验无依赖的任务C。
3. 更新已完成的任务: [C]。
4. 查抄 C 的子任务是否可以实验。
A: 依赖 [B, C]，已完成任务中不包罗 B，无法启动
B: 依赖 [C]，已完成任务中包罗 C，可以实验
5. 实验任务 B。
6. 重复步调 3，直到所有任务实验完成。
下面我们就用代码来实现：
使用递归查抄循环依赖：
private fun checkCircularDependency( chain: List<String>, depends: Set<String>, taskMap: Map<String, TaskInfo>) { depends.forEach { depend ->       check(chain.contains(depend).not()) {          "Found circular dependency chain: $chain -> $depend"       }       taskMap[depend]?.let { task ->          checkCircularDependency(chain + depend, task.depends, taskMap)       } }}梳理子任务：
task.depends.forEach { val depend = taskMap[it] checkNotNull(depend) {       "Can not find task [$it] which depend by task [${task.name}]" } depend.children.add(task)}实验任务：
private fun execute(task: TaskInfo) { if (isMatchProgress(task)) {       val cost = measureTimeMillis {          kotlin.runCatching {             (task.task as IInitTask).execute(app)          }.onFailure {             Log.e(TAG, "executing task [${task.name}] error", it)          }       }       Log.d(          TAG, "Execute task [${task.name}] complete in process [$processName] " +                   "thread [${Thread.currentThread().name}], cost: ${cost}ms"       ) } else {       Log.w( TAG, "Skip task [${task.name}] cause the process [$processName] not match") } afterExecute(task.name, task.children)}假如进程不匹配直接跳过。
继承实验下一个任务：
private fun afterExecute(name: String, children: Set<TaskInfo>) { val allowTasks = synchronized(completedTasks) {       completedTasks.add(name)       children.filter { completedTasks.containsAll(it.depends) } } if (ThreadUtils.isInMainThread()) {       // 假如是主线程，先将异步任务放入队列，再实验同步任务       allowTasks.filter { it.background }.forEach {          launch(Dispatchers.Default) { execute(it) }       }       allowTasks.filter { it.background.not() }.forEach { execute(it) } } else {       allowTasks.forEach {          val dispatcher = if (it.background) Dispatchers.Default else Dispatchers.Main          launch(dispatcher) { execute(it) }       } }}假如子任务的依赖任务都已经实验完毕，就可以实验了。
末了还必要提供一个启动任务的接口，为了支持多进程，这里不能使用 ContentProvider。
小结
通过层层拆解，将复杂的依赖梳理清楚，用平常易懂的方法，实现任务调理。
源码
https://github.com/wangchenyan/init
别的，我也在 JitPack 上发布了 alpha 版本，欢迎各人实验:
kapt "com.github.wangchenyan.init:init-compiler:1-alpha.1"implementation "com.github.wangchenyan.init:init-api:1-alpha.1"具体使用请移步 GitHub。
https://github.com/wangchenyan/init
总结

本文以 StartUp 作为引子，叙述依赖任务启动框架还必要具备哪些本事，通过 APT + 字节码注入进行解耦，支持模块化，通过一个简朴的模子来表述任务调理具体的实现方式。
盼望本文能够让各人相识依赖任务启动框架的核心头脑，假如你有好的发起，欢迎批评。

自己写个App 启动任务框架也不外云云！

所属分类: 问答交流

新帖推荐: 30日

推荐作品