第四章 架构演化 - 得到 App

• 提到了组件生命周期、服务注册的实现
• 提到了公共层定义组件服务、base层定义通用资源
• 提到了 implementation 与 runtimeOnly 的代码 / 资源隔离效果；
• 提到了 JIMU 插件的调试切换、智能配置功能；
• 提到了 2 种调用组件声明周期的方法： javassist 和反射；
• 提到了有序初始化组件的解决方案：StartUp、DAU

• app是主项目，负责集成众多组件，控制组件的生命周期
• reader和share是我们拆分的两个组件
• componentservice中定义了所有的组件提供的服务
• basicres定义了全局通用的theme和color等公共资源
• basiclib中是公共的基础库，一些第三方的库（okhttp等）也统一交给basiclib来引入

if(isRunAlone.toBoolean()){
  apply plugin: 'com.android.application'
}else{
  apply plugin: 'com.android.library'
}

public interface ReadBookService {
  Fragment getReadBookFragment();
}

public class ReadBookServiceImpl implements ReadBookService {
    @Override
    public Fragment getReadBookFragment() {
        return new ReaderFragment();
    }
}

public class ReaderAppLike implements IApplicationLike {
    Router router = Router.getInstance();
    @Override
    public void onCreate() {
        router.addService(ReadBookService.class.getSimpleName(), new ReadBookServiceImpl());
    }
    @Override
    public void onStop() {
        router.removeService(ReadBookService.class.getSimpleName());
    }
}

Router router = Router.getInstance();
if (router.getService(ReadBookService.class.getSimpleName()) != null) {
    ReadBookService service = (ReadBookService)
    router.getService(ReadBookService.class.getSimpleName());
    fragment = service.getReadBookFragment();
    ft = getSupportFragmentManager().beginTransaction();
    ft.add(R.id.tab_content, fragment).commitAllowingStateLoss();
}

debugComponent=readercomponent,com.mrzhang.share:sharecomponent
compileComponent=readercomponent,sharecomponent

• assembleRelease → app
• app:assembleRelease或者 :app:assembleRelease → app
• sharecomponent:assembleRelease 或者:sharecomponent:assembleRelease→ sharecomponent

/**
 * 自动添加依赖，只在运行assemble任务的才会添加依赖，因此在开发期间组件之间是完全感知不到的，这是做到完全隔离
 * 的关键
 * 支持两种语法：module或者modulePackage:module,前者之间引用module工程，后者使用componentrelease中已
 * 经发布的aar
 *
 * @param assembleTask
 * @param project
 */
private void compileComponents(AssembleTask assembleTask, Project project) {
    String components;
    if (assembleTask.isDebug) {
        components = (String) project.properties.get("debugComponent")
    } else {
        components = (String) project.properties.get("compileComponent")
    }
    if (components == null || components.length() == 0) {
        return;
    }
    String[] compileComponents = components.split(",")
    if (compileComponents == null || compileComponents.length == 0) {
        return;
    }
    for (String str : compileComponents) {
        if (str.contains(":")) {
            File file = project.file("../componentrelease/" + str.split(":")[1] + "-
                    release.aar")
            if (file.exists()) {
                project.dependencies.add("compile", str + "-release@aar")
            } else {
                throw new RuntimeException(str + " not found ! maybe you should generate a
                new one ")
            }
        } else {
            project.dependencies.add("compile", project.project(':' + str))
        }
    }
}

combuild {
  applicationName = 'com.mrzhang.component.application.AppApplication'
  isRegisterCompoAuto = true
}

组件A依赖lib1，既A implementation lib1
组件B依赖组件A，既B api A

注：即使你没有使用上面提到的得到组件化方案（DDComponentForAndroid）或者我们后续维护的JIMU，也不影响本篇文章的理解。

interface IComponent {
  fun onCreate()
  fun onDestroy()
}

class A : IComponent {
    override fun onCreate() {
    // A初始化逻辑
    }
    override fun onDestroy() {
    }
}
class B : IComponent {
    override fun onCreate() {
    // B初始化逻辑
    }
    override fun onDestroy() {
    }
}

class H :Application {
    override fun onCreate() {
        A().onCreate()
        B().onCreate()
    }
}

XXX.loadComponent("Bpackage.B") //"Bpackage.B"为B的类路径
XXX.loadComponent("Apackage.A")

• 案例2： 此时A组件依赖于B，必须等B组件初始化成功并得到结果后才能初始化。
• 思路1：先加载和初始化B，利用代码同步的特性，再初始化A
• 思路2：先加载和初始化B，修改组件模型，增加callback作为入参，异步初始化A

• 显式API调用，需要Application实例
• 内部提供一个ContentProvider，并在其中获取Application实例。因为其特性，会在应用启动时被自动加载，而不再需要使用者显式的API调用

• StartUp中使用异步和其排序加载之间存在“矛盾”
• StartUp不提供依赖有向无环图校验

• 任务： 初始化工作的最小单元，清晰的知道自己的所依赖的任务，只有依赖的任务都执行完毕后才能执行，我们以 Task=Name[dependency1,dependency2,...] 来表示任务，例如 B[] ==> 无前置依赖的任务B, A[B] ==> 任务A、依赖任务B
• 任务集：所有任务的集合，可分析任务的所有前置依赖并判断是否存在循环依赖，对任务进行排序,记为 TaskGroup={Task1,Task2,...}
• 任务调度器：从任务集中取出任务派发执行的调度器

fun recursive(startPoint: T, pathList: MutableList<T>) {
    if (pathList.contains(startPoint)) {
        loopbackList.add("${debugPathInfo(pathList)}->${startPoint.let(nameOf)}")
        return
    }
    pathList.add(startPoint)
    val edgesFromStartPoint = getEdgeContainsPoint(startPoint, Type.X)
    if (edgesFromStartPoint.isEmpty()) {
        val descList: ArrayList<T> = ArrayList(pathList.size)
        pathList.forEach { path -> descList.add(path) }
        deepPathList.add(descList)
    }
    edgesFromStartPoint.forEach {
        recursive(it.to, pathList)
    }
    pathList.remove(startPoint)
}

private fun DAG<JOB>.bfs(): JobChunk {
    val zeroDeque = ArrayDeque<JOB>()
    val inDegrees = HashMap<JOB, Int>().apply {
        putAll(this@bfs.inDegreeCache)
    }
    inDegrees.forEach { (v, d) ->
        if (d == 0)
            zeroDeque.offer(v)
    }
    val head = JobChunk.head()
    var currentChunk = head
    val tmpDeque = ArrayDeque<JOB>()
    while (zeroDeque.isNotEmpty() || tmpDeque.isNotEmpty()) {
        if (zeroDeque.isEmpty()) {
            currentChunk = currentChunk.append()
            zeroDeque.addAll(tmpDeque)
            tmpDeque.clear()
        }
        zeroDeque.poll()?.let { vertex ->
                currentChunk.addJob(vertex)
            this.getEdgeContainsPoint(vertex, Type.X).forEach { edge ->
                    inDegrees[edge.to] = (inDegrees[edge.to] ?: 0).minus(edge.weight).apply {
                if (this == 0)
                    tmpDeque.offer(edge.to)
            }
            }
        }
    }
    return head
}

abstract class JOB {
    abstract val uniqueKey: String
    abstract val dependsOn: List<String>
    abstract val dispatcher: CoroutineDispatcher
    internal fun runInit(maat: Maat) {
        MainScope().launch {
            flow {
                init(maat)
                emit(true)
            }
.flowOn(dispatcher)
                    .catch {
                maat.onJobFailed(this@JOB,it)
            }.flowOn(Dispatchers.Main)
                    .collect {
                maat.onJobSuccess(this@JOB)
            }
        }
    }
    abstract fun init(maat: Maat)
}

• uniqueKey 是当前任务名，需要人为确保唯一性
• dependsOn 是当前任务所依赖的任务的uniqueKey的集合，虽然使用了List，但是顺序无关。
• dispatcher 指定任务执行被分配到的线程类型
• fun init(maat: Maat) 实际初始化逻辑，注意：按需求分析初始化代码块是否需要 “同步、阻塞”，如果部分代码是“异步、基于回调”且无法更改，这个实际场景（必须要异步获取结果，且该结果被另一个组件使用）想来很少见，第一个版本中我没有考虑，下个版本我会加上

val maat = Maat.init(application = this, printChunkMax = 6,
        logger = object : Maat.Logger() {
    override val enable: Boolean = true
    override fun log(msg: String, throws: Throwable?) {
        Log.d("maat", msg, throws)
    }
}, callback = Maat.Callback(onSuccess = {}, onFailure = { maat, job, throwable ->
})
        )
        maat.append(object : JOB() {
    override val uniqueKey: String = "a"
    override val dependsOn: List<String> = emptyList()
    override val dispatcher: CoroutineDispatcher = Dispatchers.IO
    override fun init(maat: Maat) {
        Log.e(
                "maat",
                "run:" + uniqueKey + " isMain:" + (Looper.getMainLooper() == Looper.myLooper())
        )
//test exception
// throw NullPointerException("just a test")
    }
    override fun toString(): String {
        return uniqueKey
    }
}).append(object : JOB() {
    override val uniqueKey: String = "b"
    override val dependsOn: List<String> = arrayListOf("a")
    override val dispatcher: CoroutineDispatcher = Dispatchers.Main /* + Job()*/
    override fun init(maat: Maat) {
        Log.e(
                "maat",
                "run:" + uniqueKey + " isMain:" + (Looper.getMainLooper() == Looper.myLooper())
        )
    }
    override fun toString(): String {
        return uniqueKey
    }
}).append(object : JOB() {
    override val uniqueKey: String = "c"
    override val dependsOn: List<String> = arrayListOf("a")
    override val dispatcher: CoroutineDispatcher = Dispatchers.IO /* + Job()*/
    override fun init(maat: Maat) {
        Log.e(
                "maat",
                "run:" + uniqueKey + " isMain:" + (Looper.getMainLooper() == Looper.myLooper())
        )
    }
    override fun toString(): String {
        return uniqueKey
    }
}).append(object : JOB() {
    override val uniqueKey: String = "d"
    override val dependsOn: List<String> = arrayListOf("a", "b", "c")
    override val dispatcher: CoroutineDispatcher = Dispatchers.Main
    override fun init(maat: Maat) {
        Log.e(
                "maat",
                "run:" + uniqueKey + " isMain:" + (Looper.getMainLooper() == Looper.myLooper())
        )
    }
    override fun toString(): String {
        return uniqueKey
    }
}).start()

public class ShareApplike implements IApplicationLike {
    UIRouter uiRouter = UIRouter.getInstance();
    @Override
    public void onCreate() {
        uiRouter.registerUI("share");
        Log.e("share","share on create");
        Maat.Companion.getDefault().append(new JOB() {
            @NotNull
            @Override
            public String getUniqueKey() {
                return "share";
            }
            @NotNull
            @Override
            public List<String> getDependsOn() {
                return Collections.singletonList("reader");
            }
            @NotNull
            @Override
            public CoroutineDispatcher getDispatcher() {
                return Dispatchers.getMain();
            }
            @Override
            public void init(@NotNull Maat maat) {
                Log.d("share", "模拟初始化share，context：" +
                        maat.getApplication().getClass().getName());
            }
            @Override
            public String toString() {
                return getUniqueKey();
            }
        });
    }
    @Override
    public void onStop() {
        uiRouter.unregisterUI("share");
    }
}

Maat.Companion.init(this, 8, new Maat.Logger() {
    @Override
    public boolean getEnable() {
        return true;
    }
    @Override
    public void log(@NotNull String s, @Nullable Throwable throwable) {
        if (throwable != null) {
            Log.e("maat",s,throwable);
        } else {
            Log.d("maat",s);
        }
    }
}, new Maat.Callback(new Function1<Maat, Unit>() {
    @Override
    public Unit invoke(Maat maat) {
        Maat.Companion.release();
        return null;
    }
}, new Function3<Maat, JOB, Throwable, Unit>() {
    @Override
    public Unit invoke(Maat maat, JOB job, Throwable throwable) {
        return null;
    }
}));

combuild {
  useMaat = true/false
}