从Android Plugin源码开始完全理解gradle构建：Task（三）
*本篇文章已受权微信公众号 guolin_blog （郭霖）独家发布
系列文章： java
从Android Plugin源码开始完全理解gradle构建：初识AndroidDSL（一）android
从Android Plugin源码开始完全理解gradle构建：Extension（二）web
1、前言回顾
首先咱们依然回顾一下basePlugin里的三个回调：
//plugin的基础设置、初始化工做
threadRecorder.record(
ExecutionType.BASE_PLUGIN_PROJECT_CONFIGURE,
project.getPath(),
null,
this::configureProject);
//EXTENSION的初始化工做
threadRecorder.record(
ExecutionType.BASE_PLUGIN_PROJECT_BASE_EXTENSION_CREATION,
project.getPath(),
null,
this::configureExtension);
//plugin的task建立
threadRecorder.record(
ExecutionType.BASE_PLUGIN_PROJECT_TASKS_CREATION,
project.getPath(),
null,
this::createTasks);
上一篇文中咱们已经详细介绍了第二步extension的用法和源码了，今天就来讲说最后一步，也是gradle里最重要内容之一的Task。api
2、task介绍
task，如其名：任务，gradle就是由一个一个任务来完成的。他其实也是一个类，有本身的属性，也能够”继承”，甚至他还有本身的生命周期。
他的定义方式有不少，下面咱们来看一个最简单的实现：微信
task myTask {
println "myTask invoked！"
}
gradle就是一个一个task组成的，咱们平时遇到莫名其妙的报错，最经常使用的就是clean（斜眼笑），其实也是一个task而已，包括咱们debug运行、打包签名等等等等，都是Android studio给咱们视图化了而已，本质也是执行task。因此咱们执行一下clean命令：gradle clean
myTask invoked！仍是被打出来了，为啥？其实上面我也提到了，task有本身的生命周期。
初始化—配置期—执行期，我从实战gradle里偷了一张图：
其实上面代码就是在配置阶段而已，配置阶段的代码只要在执行任何task都会跟着执行，若是咱们但愿不被执行的话，就只能放到执行阶段了，最直接的方法就是加到doLast、doFirst里，固然实现方式也挺多的，我就列两种吧：app
project.task('printPerson') {
group 'atom'
//定义时
doLast {
println "this is doLast1"
}
}
Task printPerson= project.tasks["printPerson"]
//后来加
printPerson.doFirst {
println "this is doFirst1"
}
printPerson.doFirst {
println "this is doFirst2"
}
printPerson.doLast {
println "this is doLast2"
}
刚开始可能很差理解这种方式，其实能够理解为task里有一个队列，队列中是task将会执行的action，当doFirst 时，就会在队列头部插入一个action，而doLast则在队列尾部添加，当执行该任务时就会从队列中取出action依次执行，就如同咱们上述代码，执行gradle printPerson时，打印结果以下：dom
> Task :app:printPerson
this is doFirst2
this is doFirst1
this is doLast1
this is doLast2
注意，此时必需要执行gradle printPerson时才会打印了，clean之流就没用了。ide
刚刚提到过，task其实也是一个类，没错，就如同object同样，task的基类是DefaultTask ，咱们也能够自定义一个task，必须继承DefaultTask，以下：svg
class MyTask extends DefaultTask {
String message = 'This is MyTask'
// @TaskAction 表示该Task要执行的动做,即在调用该Task时，hello()方法将被执行
@TaskAction
def hello(){
println "Hello gradle. $message"
}
}
其实task还有许多内容，好比输入输出文件outputFile、Input
but,对于android开发目前来讲，这就够了，可是了解一下也是颇有好处的，好比咱们构建速度就和输入输出有关，是否是被这个坑爹的构建速度郁闷到不少次~我推荐你们去看看《Android+Gradle权威指南》之类的书，目前网上资料不全不够系统，固然，官方文档仍是值得好好看的~
闲话少叙，继续主题。task还有一个比较重要的内容，就是“继承”。
没错，task之间也是能够‘继承’的，不过此继承非彼继承，而是经过dependsOn关键字实现的，咱们先来看看实现：学习
task task1 << {
println "this is task1"
}
task task2 << {
println "this is task2"
}
task task3 << {
println "this is task3"
}
task task4 << {
println "this is task4"
}
task1.dependsOn('task2')
task2.dependsOn('task3')
task1.dependsOn('task4')
‘继承’关系为：task1–>task2/task4和task2–>task3
咱们先打印出来：
> Task :app:task3
this is task3
> Task :app:task2
this is task2
> Task :app:task4
this is task4
> Task :app:task1
this is task1
能够看到，task3是最早执行的，这是由于dependsOn的逻辑就是首先执行‘最高’辈分的，最后执行‘最低’辈分的。什么意思呢，拿代码来讲就是task1‘继承’了task2，task4，而task2‘继承’了task3，意思就是task3是task1的爷爷辈，因此最早执行，这样相信你们可以理解了吧。
task基础部分大概就讲这么多了吧，接下来咱们终于能够分析源码了。
3、Android的assemble源码
assemble是一个task，用于构建、打包项目，平时咱们打包签名APK就是调用了该方法，因为咱们有不一样buildTypes，以及不一样productFlavors，因此咱们还须要生成各类不一样的assemble系列方法：assemble{productFlavor}{BuildVariant}，好比
assembleRelease:打全部的渠道Release包
assemblexiaomiRelease:打小米Release包
assemblehuaweiRelease:打华为Release包
AndroidDSL负责生成咱们在build.gradle里配置的多渠道等各类assemble系列方法。
而后assemble方法会依赖不少方法，就如同咱们上文所叙述的，依次执行assemble依赖的方法完成构建，好了，咱们仍是来看源码理解吧！
文章开头已经放出来源码，第三个注释就是Android的建立task部分，咱们直接看该方法：
private void createTasks() {
//建立一些卸载APK、检查设备等方法
threadRecorder.record(
ExecutionType.TASK_MANAGER_CREATE_TASKS,
project.getPath(),
null,
() -> taskManager.createTasksBeforeEvaluate());
//建立Android相关重要方法
project.afterEvaluate(
project ->
threadRecorder.record(
ExecutionType.BASE_PLUGIN_CREATE_ANDROID_TASKS,
project.getPath(),
null,
() -> createAndroidTasks(false)));
}
其实就是调用了createTasksBeforeEvaluate和createAndroidTasks两个方法，注释写的很明白了，createAndroidTasks才是重点，该方法中又调用了variantManager的createAndroidTasks方法，跳过与本文无关的细节，看下面重要的地方：
/** * Variant/Task creation entry point. */
public void createAndroidTasks() {
//省略部分代码...
for (final VariantScope variantScope : variantScopes) {
recorder.record(
ExecutionType.VARIANT_MANAGER_CREATE_TASKS_FOR_VARIANT,
project.getPath(),
variantScope.getFullVariantName(),
() -> createTasksForVariantData(variantScope));
}
}
循环调用createTasksForVariantData方法，该方法就是为全部的渠道建立相关方法了，而variantScopes则存放了各类渠道、buildType信息，继续查看该方法：
/** Create tasks for the specified variant. */
public void createTasksForVariantData(final VariantScope variantScope) {
//1======
final BaseVariantData variantData = variantScope.getVariantData();
final VariantType variantType = variantData.getType();
final GradleVariantConfiguration variantConfig = variantScope.getVariantConfiguration();
final BuildTypeData buildTypeData = buildTypes.get(variantConfig.getBuildType().getName());
if (buildTypeData.getAssembleTask() == null) {
//2======
buildTypeData.setAssembleTask(taskManager.createAssembleTask(buildTypeData));
}
// Add dependency of assemble task on assemble build type task.
//3======
taskManager
.getTaskFactory()
.configure(
"assemble",
task -> {
assert buildTypeData.getAssembleTask() != null;
task.dependsOn(buildTypeData.getAssembleTask().getName());
});
//4======
createAssembleTaskForVariantData(variantData);
if (variantType.isForTesting()) {
//省略测试相关代码...
} else {
//5======
taskManager.createTasksForVariantScope(variantScope);
}
}
一、解析variant渠道等信息
二、建立AssembleTask存入data里
三、给assemble添加依赖
四、建立该variant的专属AssembleTask
五、给AssembleTask添加构建项目所需task依赖（dependsOn）
看一下四、5步骤详细代码，首先是第四步，给每一个渠道和buildtype建立对应的方法：
/** Create assemble task for VariantData. */
private void createAssembleTaskForVariantData(final BaseVariantData variantData) {
final VariantScope variantScope = variantData.getScope();
if (variantData.getType().isForTesting()) {
//测试
} else {
BuildTypeData buildTypeData =
buildTypes.get(variantData.getVariantConfiguration().getBuildType().getName());
Preconditions.checkNotNull(buildTypeData.getAssembleTask());
if (productFlavors.isEmpty()) {
//若是没有设置渠道
} else {
//省略部分代码...
// assembleTask for this flavor(dimension), created on demand if needed.
if (variantConfig.getProductFlavors().size() > 1) {
//获取渠道名
final String name = StringHelper.capitalize(variantConfig.getFlavorName());
final String variantAssembleTaskName =
//组装名字
StringHelper.appendCapitalized("assemble", name);
if (!taskManager.getTaskFactory().containsKey(variantAssembleTaskName)) {
//建立相应渠道方法
Task task = taskManager.getTaskFactory().create(variantAssembleTaskName);
task.setDescription("Assembles all builds for flavor combination: " + name);
task.setGroup("Build");
//渠道方法依赖AssembleTask
task.dependsOn(variantScope.getAssembleTask().getName());
}
taskManager
.getTaskFactory()
.configure(
"assemble", task1 -> task1.dependsOn(variantAssembleTaskName));
}
}
}
}
注释已经很清晰了，最重要的就是组装名字，建立相应的渠道打包方法。这里咱们又学到一种定义task的方式：TaskFactory.create
这是AndroidDSL自定义的类，他的实现类是TaskFactoryImpl，由kotlin语言实现：
class TaskFactoryImpl(private val taskContainer: TaskContainer): TaskFactory { //.... override fun configure(name: String, configAction: Action<in Task>) { val task = taskContainer.getByName(name) configAction.execute(task) } override fun findByName(name: String): Task? { return taskContainer.findByName(name) } override fun <T : Task> create( taskName: String, taskClass: Class<T>, configAction: Action<T>): T { return taskContainer.create(taskName, taskClass, configAction) } }
省略了大部分方法，但也很简单了，使用代理模式代理了taskContainer，而这个taskContainer就是gradle的类了，查看官方文档：
<T extends Task> T create(String name,
Class<T> type,
Action<? super T> configuration)
throws InvalidUserDataException
Creates a Task with the given name and type, configures it with the given action, and adds it to this container.
After the task is added, it is made available as a property of the project, so that you can reference the task by name in your build file. See here for more details.
Specified by:
create in interface PolymorphicDomainObjectContainer<Task>
Type Parameters:
T - the type of the domain object to be created
Parameters:
name - The name of the task to be created.
type - The type of task to create.
configuration - The action to configure the task with.
Returns:
The newly created task object.
Throws:
InvalidUserDataException - If a task with the given name already exists in this project.
就是建立一个task并放入容器里
参数只有第三个比较难猜一点点，看了文档也就很清楚：给task设置一个action而已。固然，这里并无调用这个重载方法，不过我这里是为了第5步介绍，好的，让咱们回到第5步操做：
taskManager.createTasksForVariantScope(variantScope);
这里taskManager由BasePlugin的子类实现，实现类为ApplicationTaskManager，咱们看一下他的createTasksForVariantScope方法：
@Override
public void createTasksForVariantScope(@NonNull final VariantScope variantScope) {
BaseVariantData variantData = variantScope.getVariantData();
assert variantData instanceof ApplicationVariantData;
createAnchorTasks(variantScope);
createCheckManifestTask(variantScope);
handleMicroApp(variantScope);
// Create all current streams (dependencies mostly at this point)
createDependencyStreams(variantScope);
// Add a task to publish the applicationId.
createApplicationIdWriterTask(variantScope);
taskFactory.create(new MainApkListPersistence.ConfigAction(variantScope));
taskFactory.create(new BuildArtifactReportTask.ConfigAction(variantScope));
// Add a task to process the manifest(s)
recorder.record(
ExecutionType.APP_TASK_MANAGER_CREATE_MERGE_MANIFEST_TASK,
project.getPath(),
variantScope.getFullVariantName(),
() -> createMergeApkManifestsTask(variantScope));
// Add a task to create the res values
recorder.record(
ExecutionType.APP_TASK_MANAGER_CREATE_GENERATE_RES_VALUES_TASK,
project.getPath(),
variantScope.getFullVariantName(),
() -> createGenerateResValuesTask(variantScope));
// Add a task to merge the resource folders
recorder.record(
ExecutionType.APP_TASK_MANAGER_CREATE_MERGE_RESOURCES_TASK,
project.getPath(),
variantScope.getFullVariantName(),
(Recorder.VoidBlock) () -> createMergeResourcesTask(variantScope, true));
//省略相似方法
}
这个方法就是构建精髓所在，他建立了咱们构建项目所须要的大部分task，好比建立manifest文件，合并manifest文件，处理resource文件…等等task，这些task就是构建项目的基石，这里我就放出任玉刚大佬总结的主要构建方法：
具体每一个方法作了什么，就是须要你们阅读源码参透了，这里我只负责梳理大体流程，嘿嘿…
下面咱们就看看建立的第一个方法createAnchorTasks，在这个方法里面调用了createCompileAnchorTask，他的实现是：
private void createCompileAnchorTask(@NonNull final VariantScope scope) {
final BaseVariantData variantData = scope.getVariantData();
scope.setCompileTask(
taskFactory.create(
new TaskConfigAction<Task>() {
@NonNull
@Override
public String getName() {
return scope.getTaskName("compile", "Sources");
}
@NonNull
@Override
public Class<Task> getType() {
return Task.class;
}
@Override
public void execute(@NonNull Task task) {
variantData.compileTask = task;
variantData.compileTask.setGroup(BUILD_GROUP);
}
}));
scope.getAssembleTask().dependsOn(scope.getCompileTask());
}
为何我要专门说一下这个task，就是由于最后一句代码，AssembleTask依赖的该task，也就是说当咱们执行AssembleTask的时候，该task会提早执行，而构建原理也在于此，该task也会依赖其余task，就这样一层层依赖，构建时就会调用全部的相关task，这样就完成了咱们Android项目的构建。
4、结语
好了，终于梳理完成整个过程了，其实结合源码看文章，整个过程仍是比较清晰的，不像Android源码那样晦涩难懂，主要就是task的理解。 到这里相信gradle再你们眼里也不那么神秘了，也有必定本身的理解了，接下来你们能够自行阅读源码，梳理清晰构建的主要task都作了什么，完全掌握Android构建，这样就能够随心所欲了哈哈哈哈，我就再也不出相应文章了，是时候实战一波了，下一篇文章将给你们带来一篇比较实用的gradle插件实现，顺便也能够测试一下咱们的学习成果了~