滴滴开源库Booster:架构运作及源码分析

增量：
  -> onPreTransform() 
    -> doIncrementalTransform() 
    -> onPostTransform()
非增量：
  -> 清理构建目录、输出目录 
    -> onPreTransfrom() 
    -> doFullTransform() 
    -> onPostTransform()

// 使用SPI机制，读取Transformer接口的实现列表
private val transformers: List<Transformer!> 
  = ServiceLoader.load(Transformer::class.java, 
                       javaClass.classLoader).toList()

public interface TransformInput {
    /** Returns a collection of {@link JarInput}. */
    @NonNull
    Collection<JarInput> getJarInputs();
    /** Returns a collection of {@link DirectoryInput}. */
    @NonNull
    Collection<DirectoryInput> getDirectoryInputs();
}

/**
 * The file changed status for incremental execution.
 */
public enum Status {
    /** 相对上次构建，没有变化.*/
    NOTCHANGED,
    /** 相对上次构建，属于新增文件.*/
    ADDED,
    /** 相对上次构建，有被修改. */
    CHANGED,
    /** 相对上次构建，被删除. */
    REMOVED;
}

when (status) {
  REMOVED -> 本次编译不需要该文件/文件夹，删除
    ADDED, CHANGED -> 该文件/文件夹，需要被编译处理
    NOT_CHANGED -> 不需要处理，因为已经有上次构建的.class文件
}

fun File.transform(output: File, transformer: (ByteArray) -> ByteArray = { it -> it }) {
    when {
        isDirectory -> {
            val base = this.toURI()
            this.search().forEach {
                it.transform(File(output, base.relativize(it.toURI()).path), transformer)
            }
        }
        isFile -> {
            when (output.extension.toLowerCase()) {
                "jar" -> {
                    JarOutputStream(output.touch().outputStream()).use { dest ->
                        JarFile(this).use { jar ->
                            jar.entries().asSequence().forEach { entry ->
                                dest.putNextEntry(JarEntry(entry.name))
                                if (!entry.isDirectory) {
                                    when (entry.name.substringAfterLast('.', "")) {
                                        "class" -> jar.getInputStream(entry).use { src ->
                                            logger.info("Transforming ${this.absolutePath}!/${entry.name}")
                                            src.transform(transformer).redirect(dest)
                                        }
                                        else -> jar.getInputStream(entry).use { src ->
                                            src.copyTo(dest)
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                "class" -> inputStream().use {
                    logger.info("Transforming ${this.absolutePath}")
                    it.transform(transformer).redirect(output)
                }
                else -> this.copyTo(output, true)
            }
        }
        else -> TODO("Unexpected file: ${this.absolutePath}")
    }
}

/* 语义理解：把当前File对象通过transform方法处理输出到output文件 */
Check Point 1 : (output, file) {
    -> 检查file是文件目录Directory: 把子File一个个拿出排好队，
           到「Check Point 2」 接受检查
      -> 检查file是文件File: 到「Check Point 2」 接受检查
}
Check Point 2 : (output, file) {
      -> 是'.jar'文件：装饰一下变成JarFile，把entry一个个掏出，
           后缀是'class'，拿去「Check Point 3」检查
      -> 是'.class'文件：拿去「Check Point 3」检查
}
Check Point 3 : (output, classFile) {
    -> classFile 转 InputStream，调用InputStream.transform()
}

// booster-transform-util模块的transform.kt中分别定义transform 和 readBytes方法扩展

fun InputStream.transform( transformer:(ByteArray)->ByteArray): ByteArray {
  transformer(readBytes())
}

private fun InputStream.readBytes(estimatedSize: Int = DEFAULT_BUFFER_SIZE): ByteArray {
    val buffer = ByteArrayOutputStream(Math.max(estimatedSize, this.available()))
    copyTo(buffer)
    return buffer.toByteArray()
}

    private fun ByteArray.transform(invocation: BoosterTransformInvocation): ByteArray {
        return transformers.fold(this) { bytes, transformer ->
            transformer.transform(invocation, bytes) // 成功接受transformer的洗礼
        }
    }   

AbstractInsnNode.kt
AsmTransformer
ClassNode.kt
ClassTransformer.kt
InsnList.kt
TypeInsnNode.kt

override fun transform(context: TransformContext, bytecode: ByteArray): ByteArray {
        return ClassWriter(ClassWriter.COMPUTE_MAXS).also { writer ->
            transformers.fold(ClassNode().also { klass ->
                ClassReader(bytecode).accept(klass, 0)
            }) { klass, transformer ->
                transformer.transform(context, klass)
            }.accept(writer)
        }.toByteArray()
    }

val klass = ClassNode() // ClassNode是ASM tree API的类
// accept()方法，读取bytecode的相关.class信息赋值到klass对象的相应字段
ClassReader(bytecode).accept(klass, 0) // ClassReader是ASM core API的类
transformers.foreach { transformer ->
    // 每次transform后，class的内容变化都缓存在klass中
  // 注意此时的klass对象的内容就是bytecode的内容，只是格式不同而已
  transformer.transform(context, klass) 
}
val writer = ClassWriter(ClassWriter.COMPUTE_MAXS)// ClassWriter是ASM core API的类 
klass.accept(writer) // 接收一个writer
// writer把被洗礼后的klass，即ClassNode对象，
// 写成ByteArray返回到上层BoosterTransformInvocation
return writer.toByteArray()

/**
 * Represents class transformer
 *
 * @author johnsonlee
 */
interface ClassTransformer : TransformListener {
    /**
     * Transform the specified class node
     *
     * @param context The transform context
     * @param klass The class node to be transformed
     * @return The transformed class node
     */
    fun transform(context: TransformContext, klass: ClassNode) = klass
}

package com.didiglobal.booster.task.spi

import com.android.build.gradle.api.BaseVariant

interface VariantProcessor {

    fun process(variant: BaseVariant)
}

CaughtCallback.java // 代理Handler, 捕获handleMessage()的RuntimeException
CaughtRunnable.java // 代理Runnable, 捕获run()的RuntimeException
Constants.java // android.util.Log的TAG，全局统一使用
Reflection.java // 抽象类，提供常用的反射静态方法

results = 
    listOf(AndroidArtifacts.ArtifactType.AAR, AndroidArtifacts.ArtifactType.JAR) //指定构件类型列表为AAR和JAR
    .asSequence() // -> Sequence<AndroidArtifacts.ArtifactType>
    .map { // map转换 
        variant.variantData.scope
            .getArtifactCollection(
                AndroidArtifacts.ConsumedConfigType.RUNTIME_CLASSPATH, 
                AndroidArtifacts.ArtifactScope.ALL, 
                it) 
        
    } // -> Sequence<ArtifactCollection> 构件集合 
    .map { 
        it.artifacts // ArtifactCollection.getArtifacts()
    }  // -> Sequence<ResolvedArtifactResult> 
    .flatten() // 平铺
    .filter { it.id.componentIdentifier !is ProjectComponentIdentifier } // 过滤ResolvedArtifactResult中，构件标识类型 != ProjectComponentIdentifier
    .toList() // -> List<ResolvedArtifactResult>
    .distinctBy { it.id.componentIdentifier.displayName } // 按构件名称去重
    .sortedBy { it.id.componentIdentifier.displayName } // 按构件名称排序
    .toList() // 得到结果

class ComponentHandler : DefaultHandler() {

    val applications = mutableSetOf<String>()
    val activities = mutableSetOf<String>()
    val services = mutableSetOf<String>()
    val providers = mutableSetOf<String>()
    val receivers = mutableSetOf<String>()

    override fun startElement(uri: String, localName: String, qName: String, attributes: Attributes) {
        val name: String = attributes.getValue(ATTR_NAME) ?: return
        when (qName) {
            "application" -> applications.add(name)
            "activity" -> activities.add(name)
            "service" -> services.add(name)
            "provider" -> providers.add(name)
            "receiver" -> receivers.add(name)
        }
    }
}