是时候弃用 buildSrc ,使用 Composing builds 加快编译速度了

本文正在参加「金石方案」

为什么要运用复合构建

依靠办理一直是一个优化痛点，从硬编码到ext，再发展到buildSrc，尽管表面上看复杂度在发展中增长了，可是关于追求更快更干净的构建来说的确进步了不少。不过buildSrc尽管给了咱们相对干净的运用方法，可是依然没有解决最核心的编译速度问题，在编译过程中 Gradle 最大的低效就是它的单线程装备阶段，这意味着每个额外的模块都会对构建发生继续的开销，因此咱们依然阅历着装备时刻的线性增长，一般大型项目编译一次，就要去喝杯咖啡。

运用 Gradle 的复合构建东西就避免了在其他构建形式时很容易观察到的装备时刻丢失，依靠不再是全量编译了。复合构建将大型项目构建分解为更小、更独立的块，这些块能够根据需求独立或一起作业，包括的构建不与复合构建或其他包括的构建共享任何装备。每个包括的构建都是独立装备和履行的。

更详细的对比，请参阅大佬的再会吧 buildSrc, 拥抱 Composing builds 提升 Android 编译速度，这儿不再赘述。由于找到的相关运用文档均已过时，所以下面就记录下来最新的创立运用方法。

根本运用

创立版本依靠插件 Module

这个步骤能够手动创立，也能够凭借 Android Studio 创立。

• 手动创立

  1. 切换到 Project 视图，创立 version-plugin 文件夹，在 version-plugin 文件夹里创立 src -> main -> java 文件

  2. 在 java 文件夹里创立你的包名文件夹，例如 com -> example -> plugin (不想要包名文件夹的话，这一步能够省略),在 plugin 文件夹里创立两个文件Dependencies.kt和VersionPlugin.kt

  3. 在 version-plugin 文件夹下创立build.gradle.kts文件，这儿运用 kotlin DSL 更便利

  4. 在build.gradle.kts里增加所需的插件

     plugins {
         `kotlin-dsl`
     }
     

  5. 在version-plugin 根目录创立settings.gradle.kts,并增加依靠仓库

     dependencyResolutionManagement {
         repositories {
             google()
             mavenCentral()
         }
     }
     rootProject.name = "version-plugin"
     include (":version-plugin")
     

  6. 在项目根目录的settings.gradle里增加includeBuild("version-plugin")引进插件

     pluginManagement {
         includeBuild("version-plugin")
         repositories {
             google()
             mavenCentral()
             gradlePluginPortal()
         }
     }
     dependencyResolutionManagement {
         repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
         repositories {
             google()
             mavenCentral()
         }
     }
     rootProject.name = "ComposeBuild"
     include ':app'
     

• AS创立

1. File -> New -> New Module ,选择 Java or kotlin Library，创立一个 Module

2. 创立Dependencies.kt文件

3. 删除 version-plugin 文件夹下的 libs 文件夹

4. 把build.gradle转化为build.gradle.kts文件

   plugins {
       `kotlin-dsl`
   }
   

5. 在 version-plugin 根目录创立settings.gradle.kts,并增加依靠仓库

   dependencyResolutionManagement {
       repositories {
           google()
           mavenCentral()
       }
   }
   rootProject.name = "version-plugin"
   include (":version-plugin")
   

6. 项目根目录settings.gradle里的include ':version-plugin'替换为includeBuild("version-plugin"),为了标准，把它注册在上面的pluginManagement里

   pluginManagement {
       includeBuild("version-plugin")
       repositories {
           google()
           mavenCentral()
           gradlePluginPortal()
       }
   }
   dependencyResolutionManagement {
       repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
       repositories {
           google()
           mavenCentral()
       }
   }
   rootProject.name = "ComposeBuild"
   include ':app'
   //include ':version-plugin'
   

   完结后的项目目录：

   

编写插件

Gradle 是一个结构，作为结构，它负责界说流程和规则。而具体的编译作业则是经过插件的方法来完结的，咱们要引进插件，而到达获取插件装备的目的。

完成插件类

在VersionPlugin.kt中完成插件

package com.example.plugin
import org.gradle.api.Plugin
import org.gradle.api.Project
class VersionPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        println("VersionPlugin")
    }
}

装备依靠

在Dependencies.kt中，把项目的依靠库复制在这儿：

object Versions {
    const val composeUi = "1.3.1"
    const val composeVersion = "1.2.0"
    const val kotlin = "1.8.0"
    const val lifecycle = "2.5.1"
    const val activityCompose = "1.5.1"
    const val composeMaterial3 = "1.0.0-alpha11"
    const val junit = "4.13.2"
    const val androidxJunit = "1.1.3"
    const val espresso = "3.4.0"
}
object Libraries {
//    依靠库
    const val coreKtx = "androidx.core:core-ktx:${Versions.kotlin}"
    const val lifecycle = "androidx.lifecycle:lifecycle-runtime-ktx:${Versions.lifecycle}"
    const val activityCompose = "androidx.activity:activity-compose:${Versions.activityCompose}"
    const val composeUi = "androidx.compose.ui:ui:${Versions.composeUi}"
    const val composePreview = "androidx.compose.ui:ui-tooling-preview:${Versions.composeVersion}"
    const val composeMaterial3 = "androidx.compose.material3:material3:${Versions.composeMaterial3}"
//    测试库
    const val junit = "junit:junit:${Versions.junit}"
    const val androidxJunit = "androidx.test.ext:junit:${Versions.androidxJunit}"
    const val espresso = "androidx.test.espresso:espresso-core:${Versions.espresso}"
    const val uiTestJunit4 = "androidx.compose.ui:ui-test-junit4:${Versions.composeVersion}"
    const val uiTooling = "androidx.compose.ui:ui-tooling:${Versions.composeVersion}"
    const val uiTestManifest = "androidx.compose.ui:ui-test-manifest:${Versions.composeVersion}"
}

注册插件

插件需求注册才干被其他 Module 引进，在插件 Module 的build.gradle.kts中，注册一个id：

plugins {
    `kotlin-dsl`
}
gradlePlugin {
    plugins.register("versionPlugin") {
        id = "version-plugin"
        implementationClass = "com.example.plugin.VersionPlugin"
    }
}

运用

在用到的 Module 里增加插件，app 目录下的build.gradle：

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    // 依靠插件
    id 'version-plugin'
}

这时候就能够引证插件 Module 里界说的依靠了：

implementation Libraries.coreKtx

扩展

依靠优化

上面一通操作，在运用的时候，并没有便利多少，仅仅到达了buildSrc的地步并没有表现复合构建的优势。为了不再一个一个的引进依靠，咱们需求写个扩展优化。为了便利操作和提示，建议运用 Kotlin 的 DSL ，首先把build.gradle转为build.gradle.kts。

转化前：

import com.example.plugin.Libraries
plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'version-plugin'
}
android {
    namespace 'com.example.composingbuilds'
    compileSdk 33
    defaultConfig {
        applicationId "com.example.composingbuilds"
        minSdk 24
        targetSdk 33
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables {
            useSupportLibrary true
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
    buildFeatures {
        compose true
    }
    composeOptions {
        kotlinCompilerExtensionVersion '1.1.1'
    }
    packagingOptions {
        resources {
            excludes += '/META-INF/{AL2.0,LGPL2.1}'
        }
    }
}
dependencies {
    implementation Libraries.coreKtx
//    implementation 'androidx.core:core-ktx:1.7.0'
    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.3.1'
    implementation 'androidx.activity:activity-compose:1.3.1'
    implementation "androidx.compose.ui:ui:$compose_version"
    implementation "androidx.compose.ui:ui-tooling-preview:$compose_version"
    implementation 'androidx.compose.material3:material3:1.0.0-alpha11'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
    androidTestImplementation "androidx.compose.ui:ui-test-junit4:$compose_version"
    debugImplementation "androidx.compose.ui:ui-tooling:$compose_version"
    debugImplementation "androidx.compose.ui:ui-test-manifest:$compose_version"
}

转化后：

import com.example.plugin.Libraries
plugins {
    id("com.android.application")
    id("kotlin-android")
    id("version-plugin")
}
android {
    namespace = "com.example.composingbuilds"
    compileSdk = 33
    defaultConfig {
        applicationId = "com.example.composingbuilds"
        minSdk = 23
        targetSdk = 33
        versionCode = 1
        versionName = "1.0"
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables {
            useSupportLibrary = true
        }
    }
    buildTypes {
        getByName("release") {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = JavaVersion.VERSION_1_8.toString()
    }
    buildFeatures {
        compose = true
    }
    composeOptions {
        kotlinCompilerExtensionVersion = "1.1.1"
    }
    packagingOptions {
        resources {
            excludes += "/META-INF/{AL2.0,LGPL2.1}"
        }
    }
}
dependencies {
    implementation(Libraries.coreKtx)
    implementation(Libraries.lifecycle)
    implementation(Libraries.activityCompose)
    implementation(Libraries.composeUi)
    implementation(Libraries.composePreview)
    implementation(Libraries.composeMaterial3)
    testImplementation(Libraries.junit)
    androidTestImplementation(Libraries.androidxJunit)
    androidTestImplementation(Libraries.espresso)
    androidTestImplementation(Libraries.uiTestJunit4)
    debugImplementation(Libraries.uiTooling)
    debugImplementation(Libraries.uiTestManifest)
}

在dependencies里仍是需求一个一个的依靠，有时候项目并不是一个 Module 而是多 Module 的状态，每个build.gradle都要写依靠，要简化这个繁琐的过程，就需求把依靠分类集中处理。

在插件 Module 里新建Extension.kt，能够把依靠库分为kotlin、android、compose、test四部分。扩展DependencyHandlerScope：

fun DependencyHandlerScope.kotlinProject() {
    "implementation"(Libraries.coreKtx)
}
fun DependencyHandlerScope.androidProject() {
    "implementation"(Libraries.lifecycle)
}
fun DependencyHandlerScope.composeProject() {
    "implementation"(Libraries.activityCompose)
    "implementation"(Libraries.composeUi)
    "implementation"(Libraries.composePreview)
    "implementation"(Libraries.composeMaterial3)
}
fun DependencyHandlerScope.androidTest() {
    "testImplementation"(Libraries.junit)
    "androidTestImplementation"(Libraries.androidxJunit)
    "androidTestImplementation"(Libraries.espresso)
    "androidTestImplementation"(Libraries.uiTestJunit4)
    "debugImplementation"(Libraries.uiTooling)
    "debugImplementation"(Libraries.uiTestManifest)
}

然后修正项目依靠,调用上面的扩展，短短几行就可完成：

dependencies {
    kotlinProject()
    androidProject()
    composeProject()
    androidTest()
//    implementation(Libraries.coreKtx)
//    implementation(Libraries.lifecycle)
//    implementation(Libraries.activityCompose)
//    implementation(Libraries.composeUi)
//    implementation(Libraries.composePreview)
//    implementation(Libraries.composeMaterial3)
//
//    testImplementation(Libraries.junit)
//    androidTestImplementation(Libraries.androidxJunit)
//    androidTestImplementation(Libraries.espresso)
//    androidTestImplementation(Libraries.uiTestJunit4)
//    debugImplementation(Libraries.uiTooling)
//    debugImplementation(Libraries.uiTestManifest)
}

插件依靠

上面只优化了dependencies这个闭包，build.gradle.kts依旧许多东西，既然写了一个插件，咱们就用插件完成整个装备。

能够看到app的build.gradle.kts一共有三个闭包：plugin、android、 dependencies，对应插件其实也是实际这三个装备，回到最开始的VersionPlugin中：

class VersionPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target){
            //装备plugin
            //装备android
            //装备dependencies
        }
    }
}

1. 首先完成装备plugin

这个闭包就是引进插件，把原 Module 用到的插件搬过来即可，这儿要去掉原先加入的自身插件：

//装备plugin
plugins.run {
    apply("com.android.application")
    apply("kotlin-android")
}

2. 然后完成装备android

装备这儿有用到两个插件依靠，先把依靠增加到插件 Module 的build.gradle.kts里：

plugins {
    `kotlin-dsl`
}
dependencies {
    implementation("com.android.tools.build:gradle:7.3.1")
    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.0")
}

然后装备android，把 Module 的build.gradle.kts里的android部分搬过来，仅有需求留意的是，插件里没有kotlinOptions，需求自己写一个扩展：

//装备android
extensions.configure<ApplicationExtension> {
    applicationId = "com.asi.composingbuild"
    compileSdk=33
    defaultConfig {
        applicationId="com.asi.composingbuild"
        minSdk = 23
        targetSdk=33
        versionCode=1
        versionName="1.0"
        testInstrumentationRunner= "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables {
            useSupportLibrary =true
        }
    }
    buildTypes {
        getByName("release") {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
    kotlinOptions{
        jvmTarget = JavaVersion.VERSION_1_8.toString()
    }
    buildFeatures {
        compose = true
    }
    composeOptions {
        kotlinCompilerExtensionVersion = "1.1.1"
    }
    packagingOptions {
        resources {
            excludes += "/META-INF/{AL2.0,LGPL2.1}"
        }
    }
}

kotlinOptions扩展：

fun CommonExtension<*, *, *, *>.kotlinOptions(block: KotlinJvmOptions.() -> Unit) {
    (this as ExtensionAware).extensions.configure("kotlinOptions", block)
}

3. 完成装备dependencies

//装备dependencies
dependencies {
    kotlinProject()
    androidProject()
    composeProject()
    androidTest()
}

4. 依靠插件

把 app Module 的build.gradle.kts里的内容都删了，只依靠下刚完结的插件：

  ```
  plugins {
      id("version-plugin")
  }
  ```

是不是很清新的感觉？

多个插件

如果是多 Module 的项目，每个 Module 的依靠会不一样，所以能够在 version-plugin 中编写多个plugin，然后注册id，在不同的 Module 里运用，修正某个依靠，只构建这个 Module 的依靠，到达隔离构建的目的。

复合构建

上面单一 Module 中单独的插件，依靠的库并没有到达隔离构建的目的，如果咱们仅仅更改了composeUi版本，整个依靠都要重新编译。要完成隔离，需求更精细化的拆分，比方把compose部分单独出来。

新建一个ComposePlugin.kt,把原来插件中的关于compose的装备复制过来：

class ComposePlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            //装备compose
            extensions.configure<ApplicationExtension> {
                buildFeatures {
                    compose = true
                }
                composeOptions {
                    kotlinCompilerExtensionVersion = Versions.kotlinCompilerExtensionVersion
                }
            }
            dependencies {
                composeProject()
            }
        }
    }
}

插件写完需求注册：

gradlePlugin {
    plugins.register("versionPlugin") {
        id = "version-plugin"
        implementationClass = "com.example.plugin.VersionPlugin"
    }
    plugins.register("ComposePlugin") {
        id = "compose-plugin"
        implementationClass = "com.example.plugin.ComposePlugin"
    }
}

这儿能够优化下写法：

gradlePlugin {
    plugins{
        register("versionPlugin") {
            id = "version-plugin"
            implementationClass = "com.example.plugin.VersionPlugin"
        }
        register("ComposePlugin") {
            id = "compose-plugin"
            implementationClass = "com.example.plugin.ComposePlugin"
        }
    }
}

在 app 模块里引进：

plugins {
    id("version-plugin")
    id("compose-plugin")
}

这样如果修正compose版本，并不会构建其他依靠。

国际惯例上源码