Gradle之Gradle 源码分析（四）

Gradle 的启动
constructTaskGraph
runTasks
finishBuild
gradle 脚本如何编译和执
插件调用流程

一、Gradle 的启动

1.1 整体实现图

Gradle之Gradle 源码分析（四）-LMLPHP

1.2 具体分析

我们执行一个构建任务的时候，都是执行 ./gradlew assembleDebug 这样的命令，其中的 gradlew 脚本就是整个 gradle 构建的入口，我们先从这里看起。
前面的代码基本上就是判断环境，设置变量的，直接看最后一行：

exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

最后执行的命令基本上如下：

exec $JAVA_HOME/bin/java -classpath $APP_HOME/gradle/wrapper/gradle-wrapper.jar org.gradle.wrapper.GradleWrapperMain

基本上可以看到，就是执行了 gradle/wrapper/gradle-wrapper.jar 里的 org.gradle.wrapper.GradleWrapperMain，这样我们就知道了，gradle 的入口类是 org.gradle.wrapper.GradleWrapperMain，也就知道代码该从何开始看了。
先看 GradleWrapperMain 的 main 函数：

// GradleWrapperMain

public static void main(String[] args) throws Exception {

    // ...

    WrapperExecutor wrapperExecutor = WrapperExecutor.forWrapperPropertiesFile(propertiesFile);

    wrapperExecutor.execute(

            args,

            new Install(logger, new Download(logger, "gradlew", wrapperVersion()), new PathAssembler(gradleUserHome)),

            new BootstrapMainStarter());

}

重要的类有两个 org.gradle.wrapper.WrapperExecutor 和 org.gradle.wrapper.BootstrapMainStarter。我们继续跟进 WrapperExecutor.execute 里看一下：

// WrapperExecutor.execute

public void execute(String[] args, Install install, BootstrapMainStarter bootstrapMainStarter) throws Exception {

    File gradleHome = install.createDist(config);

    bootstrapMainStarter.start(args, gradleHome);

}

这里就做了两件事：

下载 gradle wrapper 需要的依赖以及源码。其中的 gradle wrapper 版本就是我们在 gradle/wrapper/gradle-wrapper.properties 里配置的 distributionUrl，下载位置就是在 gradle-wrapper.properties 里配置的 distributionPath 和 zipStorePath。zipStorePath 是下载的压缩包位置，distributionPath 是解压后的位置，一般默认的位置就是 HOME/.gradle/wrapper/dists/，在这里就可以找到 gradle wrapper 的内容了。
如果创建过多个项目的话，我们在 HOME/.gradle/wrapper/dists/ 里可以看到不同版本的 gradle wrapper，这也说明了我们之前最开始说的，为什么要使用 gradle wrapper 而不是直接在电脑里安装 gradle，就是因为 gradle wrapper 会根据不同的项目下载不同版本的内容，项目彼此之间互不影响。
执行 gradle 构建流程。这里就是顺着 BootstrapMainStarter.start() 往下执行了，中间过程就不看了，比较曲折，对理解整体流程也没什么太大的帮助。最终会运行到 DefaultGradleLauncher.executeTasks()，然后再往下的流程就非常清晰了。

// DefaultGradleLauncher

public GradleInternal executeTasks() {

    doBuildStages(Stage.Build);

    return gradle;

}

private void doBuildStages(Stage upTo) {

    // ...

    loadSettings();

    configureBuild();

    constructTaskGraph();

    runTasks();

    finishBuild();

}

基本上构建过程就是分五步走，下面分别看这五个流程。

二、loadSettings

2.1 整体实现图

2.2 具体分析

loadSettings 主要是加载 settings.gradle 文件，然后创建对应的 project。

// DefaultGradleLauncher.loadSettings

private void loadSettings() {

    if (stage == null) {

        buildListener.buildStarted(gradle);

        buildOperationExecutor.run(new LoadBuild());

        stage = Stage.Load;

    }

}

整体构建流程：

2.2.1 调用 BuildListener.buildStarted() 回调接口

通知构建开始。这个就是我们之前在 Gradle 基本使用里说的生命周期回调。

2.2.2 执行 init 脚本

调用链路

LoadBuild.run -> InitScriptHandler.executeScripts

之前在 Gradle 基本使用里说过 init.gradle 的作用，会在每个项目 build 之前被调用，做一些初始化的操作，就是在这里被调用的。

2.2.3 查找 settings.gradle 位置

调用链路

LoadBuild.run -> NotifyingSettingsLoader.findAndLoadSettings -> CompositeBuildSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findSettingsAndLoadIfAppropriate -> DefaultSettingsLoader.findSettings -> DefaultSettingsFinder.find -> BuildLayoutFactory.getLayoutFor

实现分析
在 getLayoutFor 里，查找 settings.gradle 文件逻辑如下：

如果参数里通过 -c xxx.gradle 指定了 settings.gradle 文件的位置，那么直接使用指定的 settings.gradle 文件
如果没有指定 settings 文件，就在当前目录下查找
如果当前目录没有，会一直往上级目录查找，以及同级的 maseter/ 目录下查找
如果都没有找到，还是默认在当前目录下

// BuildLayoutFactory

public BuildLayout getLayoutFor(BuildLayoutConfiguration configuration) {

    if (configuration.isUseEmptySettings()) {

        return new BuildLayout(configuration.getCurrentDir(), configuration.getCurrentDir(), null);

    }

    File explicitSettingsFile = configuration.getSettingsFile();

    if (explicitSettingsFile != null) {

        if (!explicitSettingsFile.isFile()) {

            throw new MissingResourceException(explicitSettingsFile.toURI(), String.format("Could not read settings file '%s' as it does not exist.", explicitSettingsFile.getAbsolutePath()));

        }

        return new BuildLayout(configuration.getCurrentDir(), configuration.getCurrentDir(), explicitSettingsFile);

    }

    File currentDir = configuration.getCurrentDir();

    boolean searchUpwards = configuration.isSearchUpwards();

    return getLayoutFor(currentDir, searchUpwards ? null : currentDir.getParentFile());

}

2.2.4 编译 buildSrc 文件夹下的内容，buildSrc 可以看作插件类似的功能

调用链路

LoadBuild.run -> NotifyingSettingsLoader.findAndLoadSettings -> CompositeBuildSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findSettingsAndLoadIfAppropriate -> BuildSourceBuilder.buildAndCreateClassLoader

在上一步找到 settings.gradle 文件以后，会以 settings.gradle 所在的同级目录下，查找 buildSrc 目录，并进行编译，这样可以保证在构建 settings.gradle 的时候可以引用到 buildSrc 目录里的内容。

2.2.5 解析 gradle.properites

调用链路

LoadBuild.run -> NotifyingSettingsLoader.findAndLoadSettings -> CompositeBuildSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findSettingsAndLoadIfAppropriate -> NotifyingSettingsProcessor.process -> PropertiesLoadingSettingsProcessor.process -> DefaultGradlePropertiesLoader.loadProperties

实现分析
这一步会读取 gradle.properties 文件里的配置，系统配置，环境变量，以及命令行传入的配置并存储。

// DefaultGradlePropertiesLoader

void loadProperties(File settingsDir, StartParameter startParameter, Map<String, String> systemProperties, Map<String, String> envProperties) {

    defaultProperties.clear();

    overrideProperties.clear();

    addGradleProperties(defaultProperties, new File(settingsDir, Project.GRADLE_PROPERTIES));

    addGradleProperties(overrideProperties, new File(startParameter.getGradleUserHomeDir(), Project.GRADLE_PROPERTIES));

    setSystemProperties(startParameter.getSystemPropertiesArgs());

    overrideProperties.putAll(getEnvProjectProperties(envProperties));

    overrideProperties.putAll(getSystemProjectProperties(systemProperties));

    overrideProperties.putAll(startParameter.getProjectProperties());

}

2.2.6 解析 settings.gradle

调用链路

LoadBuild.run -> NotifyingSettingsLoader.findAndLoadSettings -> CompositeBuildSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findSettingsAndLoadIfAppropriate -> NotifyingSettingsProcessor.process -> PropertiesLoadingSettingsProcessor.process -> ScriptEvaluatingSettingsProcessor.process -> ScriptEvaluatingSettingsProcessor.applySettingsScript -> BuildOperationScriptPlugin.apply

实现分析
在 ScriptEvaluatingSettingsProcessor 里，先创建了 SettingsInternal 实例，以及 ScriptSource 实例，代表 settings.gradle 文件在内存中的映射，之后就调用 BuildOperationScriptPlugin.apply 去执行 settings.gradle 文件了。
关于 BuildOperationScriptPlugin.apply，我们后面细说，因为在解析 build.gradle 文件的时候也会用到这个方法。
下面是对应的代码：

// ScriptEvaluatingSettingsProcessor

public SettingsInternal process(GradleInternal gradle,

                                SettingsLocation settingsLocation,

                                ClassLoaderScope buildRootClassLoaderScope,

                                StartParameter startParameter) {

    Timer settingsProcessingClock = Timers.startTimer();

    Map<String, String> properties = propertiesLoader.mergeProperties(Collections.<String, String>emptyMap());

    SettingsInternal settings = settingsFactory.createSettings(gradle, settingsLocation.getSettingsDir(),

            settingsLocation.getSettingsScriptSource(), properties, startParameter, buildRootClassLoaderScope);

    applySettingsScript(settingsLocation, settings);

    LOGGER.debug("Timing: Processing settings took: {}", settingsProcessingClock.getElapsed());

    return settings;

}

private void applySettingsScript(SettingsLocation settingsLocation, final SettingsInternal settings) {

    ScriptSource settingsScriptSource = settingsLocation.getSettingsScriptSource();

    ClassLoaderScope settingsClassLoaderScope = settings.getClassLoaderScope();

    ScriptHandler scriptHandler = scriptHandlerFactory.create(settingsScriptSource, settingsClassLoaderScope);

    ScriptPlugin configurer = configurerFactory.create(settingsScriptSource, scriptHandler, settingsClassLoaderScope, settings.getRootClassLoaderScope(), true);

    configurer.apply(settings);

}

2.2.7 创建 project 以及 subproject

调用链路

LoadBuild.run -> NotifyingSettingsLoader.findAndLoadSettings -> CompositeBuildSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findAndLoadSettings -> DefaultSettingsLoader.findSettingsAndLoadIfAppropriate -> NotifyingSettingsProcessor.process -> ProjectPropertySettingBuildLoader.load -> InstantiatingBuildLoader.load

实现分析
在解析了 settings.gradle 文件以后，就可以知道项目里有哪些 project，就可以创建 project 实例了。

// InstantiatingBuildLoader

// 这里传入的参数对应的是：rootProjectDescriptor: SettingsInternal.getRootProject() defaultProject: SettingsInternal.getDefaultProject() buildRootClassLoaderScope:SettingsInternal.getRootClassLoaderScope()

public void load(ProjectDescriptor rootProjectDescriptor, ProjectDescriptor defaultProject, GradleInternal gradle, ClassLoaderScope buildRootClassLoaderScope) {

    createProjects(rootProjectDescriptor, gradle, buildRootClassLoaderScope);

    attachDefaultProject(defaultProject, gradle);

}

private void attachDefaultProject(ProjectDescriptor defaultProject, GradleInternal gradle) {

    gradle.setDefaultProject(gradle.getRootProject().getProjectRegistry().getProject(defaultProject.getPath()));

}

private void createProjects(ProjectDescriptor rootProjectDescriptor, GradleInternal gradle, ClassLoaderScope buildRootClassLoaderScope) {

    // 创建主项目实例

    // ProjectInternal 继承自 Project，最终返回的 rootProject 是 DefaultProject 类型

    ProjectInternal rootProject = projectFactory.createProject(rootProjectDescriptor, null, gradle, buildRootClassLoaderScope.createChild("root-project"), buildRootClassLoaderScope);

    gradle.setRootProject(rootProject);

    addProjects(rootProject, rootProjectDescriptor, gradle, buildRootClassLoaderScope);

}

private void addProjects(ProjectInternal parent, ProjectDescriptor parentProjectDescriptor, GradleInternal gradle, ClassLoaderScope buildRootClassLoaderScope) {

    // 创建子项目实例

    for (ProjectDescriptor childProjectDescriptor : parentProjectDescriptor.getChildren()) {

        ProjectInternal childProject = projectFactory.createProject(childProjectDescriptor, parent, gradle, parent.getClassLoaderScope().createChild("project-" + childProjectDescriptor.getName()), buildRootClassLoaderScope);

        addProjects(childProject, childProjectDescriptor, gradle, buildRootClassLoaderScope);

    }

}

// ProjectFactory

public DefaultProject createProject(ProjectDescriptor projectDescriptor, ProjectInternal parent, GradleInternal gradle, ClassLoaderScope selfClassLoaderScope, ClassLoaderScope baseClassLoaderScope) {

    // 获取 project 对应的 build.gradle

    File buildFile = projectDescriptor.getBuildFile();

    ScriptSource source = UriScriptSource.file("build file", buildFile);

    // 创建 project 实例

    DefaultProject project = instantiator.newInstance(DefaultProject.class,

            projectDescriptor.getName(),

            parent,

            projectDescriptor.getProjectDir(),

            source,

            gradle,

            gradle.getServiceRegistryFactory(),

            selfClassLoaderScope,

            baseClassLoaderScope

    );

    // 设置 project 的层级关系

    if (parent != null) {

        parent.addChildProject(project);

    }

    // 注册 project

    projectRegistry.addProject(project);

    return project;

}

这里根据 settings.gradle 的配置，创建项目实例。创建子项目的时候，如果父项目不为空，就将自己设置成父项目的子项目，这样就可以通过 project.getChildProjects 获取项目的子项目了。
我们在写 gradle 脚本的时候，经常会用到的 project 属性，就是在这个时候创建出来了。

到此为止，就解析了 settings.gradle 文件然后创建了项目实例。

三、configureBuild

3.1 整体实现图

Gradle之Gradle 源码分析（四）-LMLPHP

3.2 具体分析

我们之前有说到，gradle 构建过程分为配置阶段和运行阶段，配置阶段主要是执行脚本的内容，运行阶段是执行 task 的内容，这里就是配置阶段的流程。要注意，之前说的配置和运行阶段，是从整体来看的两个阶段，从源码来理解，就是这篇文章介绍的几个阶段，要更细化一点。
配置阶段执行的内容比较简单，就是把 gradle 脚本编译成 class 文件，然后运行（gradle 是采用 groovy 语言编写的，groovy 是一门 jvm 语言，所以必须要编译成 class 才能运行）。

// DefaultGradleLauncher

private void configureBuild() {

    if (stage == Stage.Load) {

        buildOperationExecutor.run(new ConfigureBuild());

        stage = Stage.Configure;

    }

}

在配置项目的时候，如果指定了 configure-on-demand 参数，只会配置主项目以及执行 task 需要的项目，默认没有指定，会配置所有的项目，这里只看默认情况。

3.2.1 配置主项目及其子项目的主要链路

调用链路

ConfigureBuild.run -> DefaultBuildConfigurer.configure -> TaskPathProjectEvaluator.configureHierarchy -> TaskPathProjectEvaluator.configure -> DefaultProject.evaluate -> LifecycleProjectEvaluator.evaluate -> LifecycleProjectEvaluator.doConfigure -> ConfigureActionsProjectEvaluator.evaluate

实现分析

// TaskPathProjectEvaluator

public void configureHierarchy(ProjectInternal project) {

    configure(project);

    for (Project sub : project.getSubprojects()) {

        configure((ProjectInternal) sub);

    }

}

最终执行到了 LifecycleProjectEvaluator.doConfigure

3.2.2 回调 BuildListener.beforeEvaluate 接口

在这里回调 beforeEvaluate 接口，通知配置将要开始。我们也就知道了这个回调执行的阶段。

3.2.3 设置默认的 task 和插件

调用链路

ConfigureBuild.run -> DefaultBuildConfigurer.configure -> TaskPathProjectEvaluator.configureHierarchy -> TaskPathProjectEvaluator.configure -> DefaultProject.evaluate -> LifecycleProjectEvaluator.evaluate -> LifecycleProjectEvaluator.doConfigure -> ConfigureActionsProjectEvaluator.evaluate -> PluginsProjectConfigureActions.execute

实现分析
在 PluginsProjectConfigureActions 里，会给 project 添加两个 task：init 和 wrapper，然后添加帮助插件：org.gradle.help-tasks。

3.2.4 编译脚本并执行

调用链路

ConfigureBuild.run -> DefaultBuildConfigurer.configure -> TaskPathProjectEvaluator.configureHierarchy -> TaskPathProjectEvaluator.configure -> DefaultProject.evaluate -> LifecycleProjectEvaluator.evaluate -> LifecycleProjectEvaluator.doConfigure -> ConfigureActionsProjectEvaluator.evaluate -> BuildScriptProcessor.execute -> BuildOperationScriptPlugin.apply

实现分析
这里调用的还是 BuildOperationScriptPlugin.apply 去编译和执行 build.gradle 脚本，和前面解析 settings.gradle 是一样的，这里我们先知道这个就是编译 build.gradle 为 class。
文件并且执行，然后先往后看流程，后面再详细说脚本是如何编译和执行的。

3.2.5 回调 BuildListener.afterEvaluate

3.2.6 回调 BuildListener.projectsEvaluated

四、constructTaskGraph

4.1 整体实现图

Gradle之Gradle 源码分析（四）-LMLPHP

4.2 具体分析

这一步是构建 task 依赖图

// DefaultGradleLauncher

private void constructTaskGraph() {

    if (stage == Stage.Configure) {

        buildOperationExecutor.run(new CalculateTaskGraph());

        stage = Stage.TaskGraph;

    }

}

4.2.1 处理需要排除的 task

调用链路

CalculateTaskGraph.run -> DefaultBuildConfigurationActionExecuter.select -> ExcludedTaskFilteringBuildConfigurationAction.configure

实现分析

// ExcludedTaskFilteringBuildConfigurationAction

public void configure(BuildExecutionContext context) {

    GradleInternal gradle = context.getGradle();

    Set<String> excludedTaskNames = gradle.getStartParameter().getExcludedTaskNames();

    if (!excludedTaskNames.isEmpty()) {

        final Set<Spec<Task>> filters = new HashSet<Spec<Task>>();

        for (String taskName : excludedTaskNames) {

            filters.add(taskSelector.getFilter(taskName));

        }

        gradle.getTaskGraph().useFilter(Specs.intersect(filters));

    }

    context.proceed();

}

这一步是用来处理需要排除的 task，也就是在命令行通过 -x or --exclude-task 指定的 task，这里主要是给 TaskGraph 设置了 filter，以便在后面计算依赖的时候排除相应的 task。

4.2.2 添加默认的 task

调用链路

CalculateTaskGraph.run -> DefaultBuildConfigurationActionExecuter.select -> DefaultTasksBuildExecutionAction.configure

实现分析
这里会检查命令行里是否有传入 Task 名称进来，如果指定了要执行的 task，那么什么都不做。
如果没有指定，就看 project 是否有默认的 task，默认的 task 可以通过 defaultTasks 在 build.gradle 里进行指定。
如果也默认 task 也没有，那么就把要指定的 task 设置成 help task，也就是输出 gradle 的帮助内容。

4.2.3 计算 task 依赖图

调用链路

CalculateTaskGraph.run -> DefaultBuildConfigurationActionExecuter.select -> TaskNameResolvingBuildConfigurationAction.configure

实现分析

根据命令行的 taskname 筛选 task。如果我们的 task 指定了 project，也就是类似这样的 :app:assembleDebug，那么就直接选中了 task，如果没有指定具体 project，那么会把所有 project 下符合 taskname 的 task 都筛选出来。

CalculateTaskGraph.run -> DefaultBuildConfigurationActionExecuter.select -> TaskNameResolvingBuildConfigurationAction.configure -> CommandLineTaskParser.parseTasks

把 task 添加到 taskGraph 中，这里会处理 task 的依赖关系，包括 dependson finalizedby mustrunafter shouldrunafter，然后把信息都保存在 org.gradle.execution.taskgraph.TaskInfo 里。

CalculateTaskGraph.run -> DefaultBuildConfigurationActionExecuter.select -> TaskNameResolvingBuildConfigurationAction.configure -> DefaultTaskGraphExecuter.addTasks

4.2.4 生成 task graph

调用链路

CalculateTaskGraph.run -> TaskGraphExecuter.populate -> DefaultTaskExecutionPlan.determineExecutionPlan

实现分析
根据上一步计算的 task 及其依赖，生成 task 图

五、runTasks

5.1 整体实现图

Gradle之Gradle 源码分析（四）-LMLPHP

5.2 具体分析

task 图生成以后，就开始执行 task

5.2.1 处理 dry run

调用链路

DefaultBuildExecuter.execute -> DryRunBuildExecutionAction.execute

实现分析

如果在命令行里指定了 --dry-run，在这里就会拦截 task 的执行，直接输出 task 的名称以及执行的先后关系。

5.2.2 创建线程，执行 task

调用链路

DefaultBuildExecuter.execute -> SelectedTaskExecutionAction.execute -> DefaultTaskPlanExecutor.process

实现分析
创建 TaskExecutorWorker 去执行 task，默认是 8 个线程。

// DefaultTaskPlanExecutor

public void process(TaskExecutionPlan taskExecutionPlan, Action<? super TaskInternal> taskWorker) {

    ManagedExecutor executor = executorFactory.create("Task worker for '" + taskExecutionPlan.getDisplayName() + "'");

    try {

        WorkerLease parentWorkerLease = workerLeaseService.getCurrentWorkerLease();

        // 开线程

        startAdditionalWorkers(taskExecutionPlan, taskWorker, executor, parentWorkerLease);

        taskWorker(taskExecutionPlan, taskWorker, parentWorkerLease).run();

        taskExecutionPlan.awaitCompletion();

    } finally {

        executor.stop();

    }

}

5.2.3 task 执行前处理

调用链路

DefaultBuildExecuter.execute -> SelectedTaskExecutionAction.execute -> DefaultTaskPlanExecutor.process -> TaskExecutorWorker.run -> DefaultTaskExecutionPlan.executeWithTask -> DefaultTaskExecutionPlan.selectNextTask -> DefaultTaskExecutionPlan.processTask -> EventFiringTaskWorker.execute -> DefaultBuildOperationExecutor.run

实现分析
到这里就正式开始 task 的执行过程了。有几个步骤：

回调 TaskExecutionListener.beforeExecute
链式执行一些列对 Task 的处理，具体的处理如下：

CatchExceptionTaskExecuter.execute // 加了 try catch，防止执行过程中异常

ExecuteAtMostOnceTaskExecuter.execute  // 判断 task 是否执行过

SkipOnlyIfTaskExecuter.execute  // 判断 task 的 onlyif 条件是否满足执行

SkipTaskWithNoActionsExecuter.execute  // 跳过没有 action 的 task，没有  action 说明 task 不需要执行

ResolveTaskArtifactStateTaskExecuter.execute  // 设置 artifact 状态

SkipEmptySourceFilesTaskExecuter.execute  // 跳过设置了 source file 但是 source file 为空的 task，source file 为空说明 task 没有需要处理的资源

ValidatingTaskExecuter.execute()  // 确认 task 是否可以执行

ResolveTaskOutputCachingStateExecuter.execute // 处理 task output 缓存

SkipUpToDateTaskExecuter.execute  // 跳过 update-to-date 的 task

ExecuteActionsTaskExecuter.execute // 真正执行 task

5.2.4 task 执行

调用链路

DefaultBuildExecuter.execute -> SelectedTaskExecutionAction.execute -> DefaultTaskPlanExecutor.process -> TaskExecutorWorker.run -> DefaultTaskExecutionPlan.executeWithTask -> DefaultTaskExecutionPlan.selectNextTask -> DefaultTaskExecutionPlan.processTask -> EventFiringTaskWorker.execute -> DefaultBuildOperationExecutor.run -> ExecuteActionsTaskExecuter.execute

实现分析
经过前面一系列处理，这里开始真正执行 task 了。

回调 TaskActionListener.beforeActions
回调 OutputsGenerationListener.beforeTaskOutputsGenerated
取出 task 中的 Actions 全部执行

// ExecuteActionsTaskExecuter

private GradleException executeActions(TaskInternal task, TaskStateInternal state, TaskExecutionContext context) {

    final List<ContextAwareTaskAction> actions = new ArrayList<ContextAwareTaskAction>(task.getTaskActions());

    int actionNumber = 1;

    for (ContextAwareTaskAction action : actions) {

        // ...

        executeAction("Execute task action " + actionNumber + "/" + actions.size() + " for " + task.getPath(), task, action, context);

        // ...

        actionNumber++;

    }

    return null;

}

这里可以看到，Task 的本质，其实就是执行其中的 Actions。举个例子来说，我们一般自定义 Task 的时候，经常用下面的写法：

task {

    doLast {

        // task 具体任务

    }

}

这里的 doLast 就相当于给 Task 添加了一个 Action。
看一下 AbstractTask 的 doLast 方法

// AbstractTask

public Task doLast(final Action<? super Task> action) {

    // ...

    taskMutator.mutate("Task.doLast(Action)", new Runnable() {

        public void run() {

            getTaskActions().add(wrap(action));

        }

    });

    return this;

}

private ContextAwareTaskAction wrap(final Action<? super Task> action) {

    if (action instanceof ContextAwareTaskAction) {

        return (ContextAwareTaskAction) action;

    }

    return new TaskActionWrapper(action);

}

可以看到，我们传入的闭包，最终是包装成 TaskActionWrapper 添加到 task 的 actions 中的。

回调 TaskActionListener.afterActions
回调 TaskExecutionListener.afterExecute

六、finishBuild

6.1 整体实现图

Gradle之Gradle 源码分析（四）-LMLPHP

6.2 具体分析

private void finishBuild(BuildResult result) {

    if (stage == Stage.Finished) {

        return;

    }

    buildListener.buildFinished(result);

    if (!isNestedBuild()) {

        gradle.getServices().get(IncludedBuildControllers.class).stopTaskExecution();

    }

    stage = Stage.Finished;

}

这里逻辑不多，回调了 BuildListener.buildFinished 接口

通过上面几个步骤，我们基本上看到了 gradle 的执行流程，简单来说，步骤如下：

解析 settings.gradle 并执行，生成 Project 实例
解析 build.gradle 并执行
生成 task 依赖图
执行 task

七、gradle 脚本如何编译和执行

在前面介绍 loadSettings 和 configureBuild 阶段的时候，我们提到了 BuildOperationScriptPlugin.apply 这个方法，只是简单带过，是用来编译 gradle 脚本并执行的，这里来具体分析一下。

7.1 编译脚本

调用链路

BuildOperationScriptPlugin.apply -> DefaultScriptPluginFactory.ScriptPluginImpl.apply -> DefaultScriptCompilerFactory.ScriptCompilerImpl.compile -> BuildScopeInMemoryCachingScriptClassCompiler.compile -> CrossBuildInMemoryCachingScriptClassCache.getOrCompile -> FileCacheBackedScriptClassCompiler.compile

实现分析
这里编译过程分为两部分，首先编译脚本的 buildscript {} 部分，忽略其他部分，然后再编译脚本的其他部分并执行。所以 buildscript {} 里的内容会先于其他内容执行。

会先检查缓存，如果有缓存的话，直接使用，没有缓存再进行编译
最终会调用到 CompileToCrossBuildCacheAction.execute -> DefaultScriptCompilationHandler.compileToDir -> DefaultScriptCompilationHandler.compileScript 去执行真正的编译操作
脚本缓存路径：
/Users/zy/.gradle/caches/4.1/scripts-remapped/build_a3v29m9cbrge95ug6eejz9wuw/31f5shvfkfunwn5ullupyy7xt/cp_proj4dada6424967ba8dfea75e81c8880f7f/classes
目录下的 class 如下：
具体编译方法是通过 RemappingScriptSource.getResource().getText() 获取到脚本内容，然后通过 GroovyClassLoader.parseClass 编译的。
我们以 app/build.gradle 为例，看一下最终生成的脚本是什么样子的。
build.gradle 脚本内容

apply plugin: 'com.android.application'

apply plugin: 'myplugin'

android {

    compileSdkVersion 26

    defaultConfig {

        applicationId "com.zy.easygradle"

        minSdkVersion 19

        targetSdkVersion 26

        versionCode 1

        versionName "1.0"

    }

    buildTypes {

        release {

            minifyEnabled false

            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

        }

    }

    compileOptions {

        sourceCompatibility 1.8

        targetCompatibility 1.8

    }

    flavorDimensions "size", "color"

    productFlavors {

        big {

            dimension "size"

        }

        small {

            dimension "size"

        }

        blue {

            dimension "color"

        }

        red {

            dimension "color"

        }

    }

}

dependencies {

//    implementation gradleApi()

    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation 'com.android.support:appcompat-v7:26.1.0'

    implementation 'com.android.support.constraint:constraint-layout:1.1.3'

    implementation project(':module1')

}

gradle.addBuildListener(new BuildListener() {

    @Override

    void buildStarted(Gradle gradle) {

        // println('构建开始')

    }

    @Override

    void settingsEvaluated(Settings settings) {

        // println('settings 文件解析完成')

    }

    @Override

    void projectsLoaded(Gradle gradle) {

        // println('项目加载完成')

    }

    @Override

    void projectsEvaluated(Gradle gradle) {

        // println('项目解析完成')

    }

    @Override

    void buildFinished(BuildResult result) {

        // println('构建完成')

    }

})

gradle.addProjectEvaluationListener(new ProjectEvaluationListener() {

    @Override

    void beforeEvaluate(Project project) {

        // println("${project.name} 项目配置之前调用")

    }

    @Override

    void afterEvaluate(Project project, ProjectState state) {

        // println("${project.name} 项目配置之后调用")

    }

})

gradle.taskGraph.whenReady {

    // println("task 图构建完成")

}

gradle.taskGraph.beforeTask {

    // println("task 执行完成")

}

gradle.taskGraph.afterTask {

    // println("task 执行完成")

}

task task1 {

    doLast {

        println('task2')

    }

}

task task2 {

    doLast {

        println('task2')

    }

}

task1.finalizedBy(task2)

编译后 class 内容

package defpackage;

import groovy.lang.MetaClass;

import java.lang.ref.SoftReference;

import org.codehaus.groovy.reflection.ClassInfo;

import org.codehaus.groovy.runtime.GStringImpl;

import org.codehaus.groovy.runtime.ScriptBytecodeAdapter;

import org.codehaus.groovy.runtime.callsite.CallSite;

import org.codehaus.groovy.runtime.callsite.CallSiteArray;

import org.codehaus.groovy.runtime.typehandling.ShortTypeHandling;

import org.gradle.api.internal.project.ProjectScript;

import org.gradle.internal.scripts.ScriptOrigin;

/* compiled from: /Users/zy/workspace/note/blog/android-training/gradle/EasyGradle/app/build.gradle */

public class build_ak168fqfikdepd6py4yef8tgs extends ProjectScript implements ScriptOrigin {

    private static /* synthetic */ SoftReference $callSiteArray = null;

    private static /* synthetic */ ClassInfo $staticClassInfo = null;

    public static transient /* synthetic */ boolean __$stMC = false;

    private static final /* synthetic */ String __originalClassName = "_BuildScript_";

    private static final /* synthetic */ String __signature = "988274f32891a2a3d3b8d16074617c05";

    private static /* synthetic */ CallSiteArray $createCallSiteArray() {

        String[] strArr = new String[22];

        build_ak168fqfikdepd6py4yef8tgs.$createCallSiteArray_1(strArr);

        return new CallSiteArray(build_ak168fqfikdepd6py4yef8tgs.class, strArr);

    }

    private static /* synthetic */ void $createCallSiteArray_1(String[] strArr) {

        strArr[0] = "apply";

        strArr[1] = "apply";

        strArr[2] = "android";

        strArr[3] = "dependencies";

        strArr[4] = "addBuildListener";

        strArr[5] = "gradle";

        strArr[6] = "addProjectEvaluationListener";

        strArr[7] = "gradle";

        strArr[8] = "whenReady";

        strArr[9] = "taskGraph";

        strArr[10] = "gradle";

        strArr[11] = "beforeTask";

        strArr[12] = "taskGraph";

        strArr[13] = "gradle";

        strArr[14] = "afterTask";

        strArr[15] = "taskGraph";

        strArr[16] = "gradle";

        strArr[17] = "task";

        strArr[18] = "task";

        strArr[19] = "finalizedBy";

        strArr[20] = "task1";

        strArr[21] = "task2";

    }

    /* JADX WARNING: inconsistent code. */

    /* Code decompiled incorrectly, please refer to instructions dump. */

    private static /* synthetic */ org.codehaus.groovy.runtime.callsite.CallSite[] $getCallSiteArray() {

        /*

        r0 = $callSiteArray;

        if (r0 == 0) goto L_0x000e;

    L_0x0004:

        r0 = $callSiteArray;

        r0 = r0.get();

        r0 = (org.codehaus.groovy.runtime.callsite.CallSiteArray) r0;

        if (r0 != 0) goto L_0x0019;

    L_0x000e:

        r0 = defpackage.build_ak168fqfikdepd6py4yef8tgs.$createCallSiteArray();

        r1 = new java.lang.ref.SoftReference;

        r1.<init>(r0);

        $callSiteArray = r1;

    L_0x0019:

        r0 = r0.array;

        return r0;

        */

        throw new UnsupportedOperationException("Method not decompiled: build_ak168fqfikdepd6py4yef8tgs.$getCallSiteArray():org.codehaus.groovy.runtime.callsite.CallSite[]");

    }

    public build_ak168fqfikdepd6py4yef8tgs() {

        build_ak168fqfikdepd6py4yef8tgs.$getCallSiteArray();

    }

    protected /* synthetic */ MetaClass $getStaticMetaClass() {

        if (getClass() != build_ak168fqfikdepd6py4yef8tgs.class) {

            return ScriptBytecodeAdapter.initMetaClass(this);

        }

        ClassInfo classInfo = $staticClassInfo;

        if (classInfo == null) {

            classInfo = ClassInfo.getClassInfo(getClass());

            $staticClassInfo = classInfo;

        }

        return classInfo.getMetaClass();

    }

    public String getContentHash() {

        return __signature;

    }

    public String getOriginalClassName() {

        return __originalClassName;

    }

    public Object run() {

        CallSite[] $getCallSiteArray = build_ak168fqfikdepd6py4yef8tgs.$getCallSiteArray();

        $getCallSiteArray[0].callCurrent(this, ScriptBytecodeAdapter.createMap(new Object[]{"plugin", "com.android.application"}));

        $getCallSiteArray[1].callCurrent(this, ScriptBytecodeAdapter.createMap(new Object[]{"plugin", "myplugin"}));

        $getCallSiteArray[2].callCurrent(this, new _run_closure1(this, this));

        $getCallSiteArray[3].callCurrent(this, new _run_closure2(this, this));

        $getCallSiteArray[4].call($getCallSiteArray[5].callGroovyObjectGetProperty(this), new 1(this));

        $getCallSiteArray[6].call($getCallSiteArray[7].callGroovyObjectGetProperty(this), new 2(this));

        $getCallSiteArray[8].call($getCallSiteArray[9].callGetProperty($getCallSiteArray[10].callGroovyObjectGetProperty(this)), new _run_closure3(this, this));

        $getCallSiteArray[11].call($getCallSiteArray[12].callGetProperty($getCallSiteArray[13].callGroovyObjectGetProperty(this)), new _run_closure4(this, this));

        $getCallSiteArray[14].call($getCallSiteArray[15].callGetProperty($getCallSiteArray[16].callGroovyObjectGetProperty(this)), new _run_closure5(this, this));

        $getCallSiteArray[17].callCurrent(this, "task1", new _run_closure6(this, this));

        $getCallSiteArray[18].callCurrent(this, "task2", new _run_closure7(this, this));

        return $getCallSiteArray[19].call($getCallSiteArray[20].callGroovyObjectGetProperty(this), $getCallSiteArray[21].callGroovyObjectGetProperty(this));

    }

    public /* synthetic */ Object this$dist$get$7(String name) {

        build_ak168fqfikdepd6py4yef8tgs.$getCallSiteArray();

        return ScriptBytecodeAdapter.getGroovyObjectProperty(build_ak168fqfikdepd6py4yef8tgs.class, this, ShortTypeHandling.castToString(new GStringImpl(new Object[]{name}, new String[]{"", ""})));

    }

    public /* synthetic */ Object this$dist$invoke$7(String name, Object args) {

        build_ak168fqfikdepd6py4yef8tgs.$getCallSiteArray();

        return ScriptBytecodeAdapter.invokeMethodOnCurrentN(build_ak168fqfikdepd6py4yef8tgs.class, this, ShortTypeHandling.castToString(new GStringImpl(new Object[]{name}, new String[]{"", ""})), ScriptBytecodeAdapter.despreadList(new Object[0], new Object[]{args}, new int[]{0}));

    }

    public /* synthetic */ void this$dist$set$7(String name, Object value) {

        build_ak168fqfikdepd6py4yef8tgs.$getCallSiteArray();

        ScriptBytecodeAdapter.setGroovyObjectProperty(value, build_ak168fqfikdepd6py4yef8tgs.class, this, ShortTypeHandling.castToString(new GStringImpl(new Object[]{name}, new String[]{"", ""})));

    }

}

可以看到，脚本类继承自 ProjectScript，实现了 run 方法。

run 方法里做了些什么呢，先看第一行，

CallSite[] $getCallSiteArray = build_ak168fqfikdepd6py4yef8tgs.$getCallSiteArray();

获取到 callsiteArray，这个就是 createCallSiteArray_1() 方法中赋值的，可以看到，此处的 callsiteArray，都是脚本中的 dsl，其实也就是调用的方法名。获取到 callsiteArray 以后，执行 $getCallSiteArray[0].callCurrent() 类似的方法，这个就是在调用方法。调用的方法对应的脚本代码在下面加了注释。

public Object run() {

    CallSite[] $getCallSiteArray = build_ak168fqfikdepd6py4yef8tgs.$getCallSiteArray();

    // apply plugin "com.android.application" 依赖插件

    $getCallSiteArray[0].callCurrent(this, ScriptBytecodeAdapter.createMap(new Object[]{"plugin", "com.android.application"}));

    // apply plugin myplugin

    $getCallSiteArray[1].callCurrent(this, ScriptBytecodeAdapter.createMap(new Object[]{"plugin", "myplugin"}));

    // android {}

    $getCallSiteArray[2].callCurrent(this, new _run_closure1(this, this));

    // dependencies {}

    $getCallSiteArray[3].callCurrent(this, new _run_closure2(this, this));

    // task {}

    $getCallSiteArray[17].callCurrent(this, "task1", new _run_closure6(this, this));

    // ...

    return $getCallSiteArray[19].call($getCallSiteArray[20].callGroovyObjectGetProperty(this), $getCallSiteArray[21].callGroovyObjectGetProperty(this));

}

上面看到，task1 对应的是 _run_closure6 这个类，我们看看这个类的内容。

/* compiled from: /Users/zy/workspace/note/blog/android-training/gradle/EasyGradle/app/build.gradle */

public class build_ak168fqfikdepd6py4yef8tgs$_run_closure6 extends Closure implements GeneratedClosure, ScriptOrigin {

    private static final /* synthetic */ String __originalClassName = "_BuildScript_$_run_closure6";

    private static /* synthetic */ CallSiteArray $createCallSiteArray() {

        String[] strArr = new String[1];

        strArr[0] = "doLast";

        return new CallSiteArray(build_ak168fqfikdepd6py4yef8tgs$_run_closure6.class, strArr);

    }

    public build_ak168fqfikdepd6py4yef8tgs$_run_closure6(Object _outerInstance, Object _thisObject) {

        build_ak168fqfikdepd6py4yef8tgs$_run_closure6.$getCallSiteArray();

        super(_outerInstance, _thisObject);

    }

    public Object doCall() {

        build_ak168fqfikdepd6py4yef8tgs$_run_closure6.$getCallSiteArray();

        return doCall(null);

    }

    public Object doCall(Object it) {

        return build_ak168fqfikdepd6py4yef8tgs$_run_closure6.$getCallSiteArray()[0].callCurrent(this, new _closure17(this, getThisObject()));

    }

}

省略了一些内容，可以看到，这个闭包的类继承了 Closure，然后实现了 doCall 方法，在 doCall 方法里，调用了 doLast 方法，传入了 _closure17 实例。这个就是脚本中的 task { doLast {} } 对应的实现。
我们再看看 _closure17 的实现。

/* compiled from: /Users/zy/workspace/note/blog/android-training/gradle/EasyGradle/app/build.gradle */

public class build_ak168fqfikdepd6py4yef8tgs$_run_closure6$_closure17 extends Closure implements GeneratedClosure, ScriptOrigin {

    private static /* synthetic */ SoftReference $callSiteArray = null;

    private static /* synthetic */ ClassInfo $staticClassInfo = null;

    public static transient /* synthetic */ boolean __$stMC = false;

    private static final /* synthetic */ String __originalClassName = "_BuildScript_$_run_closure6$_closure17";

    private static final /* synthetic */ String __signature = "ab46bccc923a8e0a93329f7333d732c8";

    private static /* synthetic */ CallSiteArray $createCallSiteArray() {

        String[] strArr = new String[1];

        strArr[0] = "println";

        return new CallSiteArray(build_ak168fqfikdepd6py4yef8tgs$_run_closure6$_closure17.class, strArr);

    }

    public Object doCall() {

        build_ak168fqfikdepd6py4yef8tgs$_run_closure6$_closure17.$getCallSiteArray();

        return doCall(null);

    }

    public Object doCall(Object it) {

        return build_ak168fqfikdepd6py4yef8tgs$_run_closure6$_closure17.$getCallSiteArray()[0].callCurrent(this, "task2");

    }

}

同样也是继承了 Closure，在 doCall 方法里调用了 println，这正是我们在 task 的里执行的任务，也就是前面提到的 task 的 actions。

这里我们再理顺一下，每一个 build.gradle 脚本，对应一个继承了 ProjectScript 的类，每一个闭包，对应了一个继承自 Closure 的类

7.2 调用脚本 run 方法

接着就是执行脚本类的 run 方法，也就是我们在上面分析的 run 方法。
其中强调的一点是，run 方法里对 task 的创建，仅仅是执行了 task.doCall，这也就是为什么配置阶段不会执行 task 任务，但会执行 task 闭包里的内容。

task task1 {

    // 配置阶段会执行

    println('configure')

    doLast {

        // 运行阶段执行

        println('run')

    }

}

八、插件调用流程

之前在 Gradle的基本使用里讲到过自定义插件，使用的时候是通过 apply plugin 'xxx' 来使用的，具体的调用链路如下：

apply: "xxx" -> Script.run -> ProjectScript.apply -> DefaultObjectConfigurationAction.run -> DefaultObjectConfigurationAction.applyType(pluginId) -> DefaultPluginManager.apply -> DefaultPluginManager.AddPluginBuildOperation.run -> AddPluginBuildOperation.addPlugin -> RuleBasedPluginTarget.applyImpreative -> ImperativeOnlyPluginTarget.applyImperative -> Plugin.apply

复制代码

最后的 Plugin.apply 就调用到插件里实现的 apply() 函数了

九、总结

整体结构图

Gradle之Gradle 源码分析（四）-LMLPHP

gradle 运行流程

loadSettings

configureBuild

constructTaskGraph

runTasks

finishBuild

Task 的本质，就是一系列的 Actions
脚本编译流程获取脚本内容 -> 编译成 class 文件，继承自 ProjectScript -> 执行 ProjectScript.run 方法
脚本的 buildscript 在脚本其他内容前执行

分析