【gradle源码系列3】Project用法示例方法总结源码分析

最新推荐文章于 2024-05-24 18:28:36 发布

BigDataMLApplication

最新推荐文章于 2024-05-24 18:28:36 发布

阅读量1k

点赞数 20

分类专栏： gradle 文章标签： gradle

本文链接：https://blog.csdn.net/wang2leee/article/details/135097437

版权

gradle 专栏收录该内容

32 篇文章 3 订阅

订阅专栏

【gradle源码系列3】Project用法示例方法总结源码分析

文章目录

【gradle源码系列3】Project用法示例方法总结源码分析
概览
示例
方法总结
Project中文源码

概览

该接口是与Gradle从构建文件中交互的主要API。通过一个Project，你可以编程访问Gradle的所有功能。

生命周期

在构建初始化期间，每个参与构建的项目都会组装一个Project对象，如下所示：

创建一个Settings实例用于构建。
如果存在，对Settings对象执行DEFAULT_SETTINGS_FILE脚本进行配置。
使用配置的Settings对象创建Project实例的层次结构。
最后，通过在项目上执行DEFAULT_BUILD_FILE文件来评估每个Project（如果存在）。项目按广度优先顺序进行评估，以便在其子项目之前评估项目。可以通过调用evaluationDependsOnChildren()或使用evaluationDependsOn(String)添加显式评估依赖项来重写此顺序。

任务

项目本质上是一组Task对象。每个任务执行一些基本工作，例如编译类，运行单元测试或压缩WAR文件。您可以使用TaskContainer上的create()方法之一将任务添加到项目中，例如TaskContainer.create(String)。您可以使用TaskContainer上的某个查找方法定位现有任务，例如org.gradle.api.tasks.TaskCollection.getByName(String)。

依赖关系

项目通常具有完成工作所需的多个依赖项。此外，项目通常会生成多个构件，其他项目可以使用这些构件。这些依赖项分组为配置，并可以从存储库中检索和上传。您可以使用getConfigurations()方法返回的org.gradle.api.artifacts.ConfigurationContainer管理配置，使用getDependencies()方法返回的org.gradle.api.artifacts.dsl.DependencyHandler管理依赖项，使用getArtifacts()方法返回的org.gradle.api.artifacts.dsl.ArtifactHandler管理构件，以及使用getRepositories()方法返回的org.gradle.api.artifacts.dsl.RepositoryHandler管理存储库。

多项目构建

项目按照项目层次结构进行排列。项目具有名称和完全限定路径，用于在层次结构中唯一标识它们。

插件

插件可用于模块化和重用项目配置。可以使用PluginAware.apply(java.util.Map)方法或使用org.gradle.plugin.use.PluginDependenciesSpec插件脚本块来应用插件。

动态项目属性

Gradle针对Project实例执行项目的构建文件以配置项目。脚本使用的任何属性或方法都将委托给相关联的Project对象。这意味着，您可以在脚本中直接使用Project接口上的任何方法和属性。

附加属性

所有额外属性必须通过“ext”命名空间进行定义。一旦定义了额外属性，它将直接在所属对象上（在下面的示例中为Project、Task和子项目）可用，并且可以进行读取和更新。

动态方法

项目有5种方法作用域，可以在这些作用域中搜索方法：

Project对象本身。
构建文件。项目在构建文件中搜索已声明的匹配方法。
插件添加到项目中的扩展。每个扩展都可作为接受闭包或org.gradle.api.Action参数的方法使用。
插件添加到项目中的Convention方法。插件可以通过项目的Convention对象向项目添加属性和方法。
项目的任务。为每个任务添加了一个方法，使用任务的名称作为方法名，并采用单个闭包或org.gradle.api.Action参数。该方法使用所提供的闭包调用与关联任务的Task.configure(groovy.lang.Closure)方法。

示例

// 获取项目的名称
def projectName = project.name

// 设置项目的组
project.group = 'com.example'

// 配置项目的依赖项
dependencies {
    implementation 'com.example:library:1.0'
    testImplementation 'junit:junit:4.12'
}

// 创建并配置一个任务
task myTask {
    doLast {
        println "Hello, World!"
    }
}

// 获取该项目及其子项目的集合
def allProjects = project.allprojects

// 迭代所有子项目并执行操作
allProjects.each { subProject ->
    println "子项目名称：${subProject.name}"
}

// 查找具有给定路径的项目
def foundProject = project.findProject(':subproject')

// 获取项目的根目录
def projectRootDir = project.rootDir

// 删除指定文件
delete file('temp.txt')

以上示例演示了如何使用project类的一些常见方法，包括设置项目属性、配置依赖项、创建任务、获取子项目等操作。

方法总结

Modifier and Type	Method	Description
`java.lang.String`	`absoluteProjectPath(java.lang.String path)`	将名称转换为相对于该项目的绝对项目路径
`void`	`afterEvaluate(Closure closure)`	在项目评估完成后立即调用闭包
`void`	`afterEvaluate(Action<? super Project> action)`	在项目评估完成后立即调用动作
`void`	`allprojects(Closure configureClosure)`	配置该项目及其子项目
`void`	`allprojects(Action<? super Project> action)`	配置该项目及其子项目
`AntBuilder`	`ant(Closure configureClosure)`	使用该项目的AntBuilder执行给定的闭包
`AntBuilder`	`ant(Action<? super AntBuilder> configureAction)`	使用该项目的AntBuilder执行给定的动作
`void`	`artifacts(Closure configureClosure)`	配置该项目的发布工件
`void`	`artifacts(Action<? super ArtifactHandler> configureAction)`	配置该项目的发布工件
`void`	`beforeEvaluate(Closure closure)`	在项目评估之前立即调用闭包
`void`	`beforeEvaluate(Action<? super Project> action)`	在项目评估之前立即调用动作
`void`	`buildscript(Closure configureClosure)`	配置该项目的构建脚本类路径
`void`	`components(Action<? super SoftwareComponentContainer> configuration)`	配置软件组件
`void`	`configurations(Closure configureClosure)`	配置该项目的依赖配置
`java.lang.Iterable<?>`	`configure(java.lang.Iterable<?> objects, Closure configureClosure)`	通过闭包配置对象集合
`<T> java.lang.Iterable<T>`	`configure(java.lang.Iterable<T> objects, Action<? super T> configureAction)`	通过动作配置对象集合
`java.lang.Object`	`configure(java.lang.Object object, Closure configureClosure)`	通过闭包配置对象，将闭包的委托设置为提供的对象
`<T> NamedDomainObjectContainer<T>`	`container(java.lang.Class<T> type)`	创建用于管理指定类型的命名对象的容器
`<T> NamedDomainObjectContainer<T>`	`container(java.lang.Class<T> type, Closure factoryClosure)`	创建用于管理指定类型的命名对象的容器
`<T> NamedDomainObjectContainer<T>`	`container(java.lang.Class<T> type, NamedDomainObjectFactory<T> factory)`	创建用于管理指定类型的命名对象的容器
`WorkResult`	`copy(Closure closure)`	复制指定的文件
`WorkResult`	`copy(Action<? super CopySpec> action)`	复制指定的文件
`CopySpec`	`copySpec()`	创建一个CopySpec，稍后可用于复制文件或创建存档
`CopySpec`	`copySpec(Closure closure)`	创建一个CopySpec，稍后可用于复制文件或创建存档
`CopySpec`	`copySpec(Action<? super CopySpec> action)`	创建一个CopySpec，稍后可用于复制文件或创建存档
`AntBuilder`	`createAntBuilder()`	为该项目创建一个额外的AntBuilder
`void`	`defaultTasks(java.lang.String... defaultTasks)`	设置该项目的默认任务名称
`boolean`	`delete(java.lang.Object... paths)`	删除文件和目录
`WorkResult`	`delete(Action<? super DeleteSpec> action)`	删除指定的文件
`void`	`dependencies(Closure configureClosure)`	配置该项目的依赖项
`void`	`dependencyLocking(Action<? super DependencyLockingHandler> configuration)`	配置依赖项锁定
`int`	`depthCompare(Project otherProject)`	比较此项目与多项目层次结构中的另一个项目的嵌套级别
`Project`	`evaluationDependsOn(java.lang.String path)`	声明此项目对具有给定路径的项目具有评估依赖关系
`void`	`evaluationDependsOnChildren()`	声明此项目对每个子项目都具有评估依赖关系
`ExecResult`	`exec(Closure closure)`	执行外部命令
`ExecResult`	`exec(Action<? super ExecSpec> action)`	执行外部命令
`java.io.File`	`file(java.lang.Object path)`	解析相对于该项目的项目目录的文件路径
`java.io.File`	`file(java.lang.Object path, PathValidation validation)`	解析相对于该项目的项目目录的文件路径，并使用给定的验证方案进行验证
`ConfigurableFileCollection`	`files(java.lang.Object... paths)`	返回包含给定文件的ConfigurableFileCollection
`ConfigurableFileCollection`	`files(java.lang.Object paths, Closure configureClosure)`	使用给定的路径创建一个新的ConfigurableFileCollection
`ConfigurableFileCollection`	`files(java.lang.Object paths, Action<? super ConfigurableFileCollection> configureAction)`	使用给定的路径创建一个新的ConfigurableFileCollection
`ConfigurableFileTree`	`fileTree(java.lang.Object baseDir)`	使用给定的基本目录创建一个新的ConfigurableFileTree
`ConfigurableFileTree`	`fileTree(java.lang.Object baseDir, Closure configureClosure)`	使用给定的基本目录创建一个新的ConfigurableFileTree
`ConfigurableFileTree`	`fileTree(java.lang.Object baseDir, Action<? super ConfigurableFileTree> configureAction)`	使用给定的基本目录创建一个新的ConfigurableFileTree
`ConfigurableFileTree`	`fileTree(java.util.Map<java.lang.String,?> args)`	使用提供的参数映射创建一个新的ConfigurableFileTree
`Project`	`findProject(java.lang.String path)`	通过路径查找项目
`java.lang.Object`	`findProperty(java.lang.String propertyName)`	返回给定属性的值，如果未找到则返回null
`java.util.Set<Project>`	`getAllprojects()`	返回包含该项目及其子项目的集合
`java.util.Map<Project,java.util.Set<Task>>`	`getAllTasks(boolean recursive)`	返回该项目及其子项目中包含的任务的映射
`AntBuilder`	`getAnt()`	返回该项目的AntBuilder
`ArtifactHandler`	`getArtifacts()`	返回用于将该项目生成的工件分配到配置的处理程序
`java.io.File`	`getBuildDir()`	返回该项目的构建目录（已弃用，请改用getLayout().getBuildDirectory()）
`java.io.File`	`getBuildFile()`	返回此项目的构建脚本
`ScriptHandler`	`getBuildscript()`	返回该项目的构建脚本处理程序
`java.lang.String`	`getBuildTreePath()`	返回完整构建树中的项目路径
`java.util.Map<java.lang.String,Project>`	`getChildProjects()`	返回该项目的直接子项目
`SoftwareComponentContainer`	`getComponents()`	返回该项目生成的软件组件
`ConfigurationContainer`	`getConfigurations()`	返回该项目的配置
`Convention`	`getConvention()`	已弃用
`java.util.List<java.lang.String>`	`getDefaultTasks()`	返回该项目的默认任务名称
`DependencyHandler`	`getDependencies()`	返回该项目的依赖项处理程序
`DependencyFactory`	`getDependencyFactory()`	提供访问创建各种类型的依赖项实例的方法
`DependencyLockingHandler`	`getDependencyLocking()`	提供配置依赖项锁定的访问方式
`int`	`getDepth()`	返回多项目层次结构中项目的嵌套级别
`java.lang.String`	`getDescription()`	返回此项目的描述（如果有）
`java.lang.String`	`getDisplayName()`	返回此项目的人类可消费的显示名称
`ExtensionContainer`	`getExtensions()`	允许向项目添加DSL扩展
`Gradle`	`getGradle()`	返回此项目所属的Gradle调用
`java.lang.Object`	`getGroup()`	返回此项目的组
`ProjectLayout`	`getLayout()`	提供对该项目的各个重要目录的访问
`Logger`	`getLogger()`	返回此项目的记录器
`LoggingManager`	`getLogging()`	返回LoggingManager，用于接收日志和控制此项目的构建脚本的标准输出/错误捕获
`java.lang.String`	`getName()`	返回此项目的名称
`InputNormalizationHandler`	`getNormalization()`	提供配置输入规范化的访问方式
`ObjectFactory`	`getObjects()`	提供创建各种模型对象的方法的访问方式
`Project`	`getParent()`	返回此项目的父项目（如果有）
`java.lang.String`	`getPath()`	返回此项目的路径
`Project`	`getProject()`	返回此项目
`java.io.File`	`getProjectDir()`	返回包含此项目构建文件的目录
`java.util.Map<java.lang.String,?>`	`getProperties()`	返回此项目的属性
`ProviderFactory`	`getProviders()`	提供对创建各种类型的Provider实例的方法的访问方式
`RepositoryHandler`	`getRepositories()`	返回用于检索依赖项和上传该项目生成的工件的存储库处理程序
`ResourceHandler`	`getResources()`	提供对资源特定实用方法的访问，例如创建各种资源的工厂方法
`java.io.File`	`getRootDir()`	返回此项目的根目录
`Project`	`getRootProject()`	返回该项目所属的层次结构的根项目
`ProjectState`	`getState()`	返回此项目的评估状态
`java.lang.Object`	`getStatus()`	返回此项目的状态
`java.util.Set<Project>`	`getSubprojects()`	返回包含此项目的子项目的集合
`TaskContainer`	`getTasks()`	返回此项目的任务
`java.util.Set<Task>`	`getTasksByName(java.lang.String name, boolean recursive)`	返回此项目及其子项目中具有给定名称的任务的集合
`java.lang.Object`	`getVersion()`	返回此项目的版本
`boolean`	`hasProperty(java.lang.String propertyName)`	确定此项目是否具有给定属性
`ExecResult`	`javaexec(Closure closure)`	执行Java主类
`ExecResult`	`javaexec(Action<? super JavaExecSpec> action)`	执行外部Java进程
`java.io.File`	`mkdir(java.lang.Object path)`	创建一个目录并返回指向它的文件
`void`	`normalization(Action<? super InputNormalizationHandler> configuration)`	配置输入规范化
`Project`	`project(java.lang.String path)`	通过路径查找项目
`Project`	`project(java.lang.String path, Closure configureClosure)`	通过路径查找项目，并使用给定的闭包进行配置
`Project`	`project(java.lang.String path, Action<? super Project> configureAction)`	通过路径查找项目，并使用给定的动作进行配置
`java.lang.Object`	`property(java.lang.String propertyName)`	返回给定属性的值
`<T> Provider<T>`	`provider(java.util.concurrent.Callable<? extends @Nullable T> value)`	基于提供的值创建Provider实现
`java.lang.String`	`relativePath(java.lang.Object path)`	返回从项目目录到给定路径的相对路径
`java.lang.String`	`relativeProjectPath(java.lang.String path)`	将名称转换为相对于此项目的项目路径
`void`	`repositories(Closure configureClosure)`	配置此项目的存储库
`void`	`setBuildDir(java.io.File path)`	已弃用，请改用getLayout().getBuildDirectory()和设置DirectoryProperty
`void`	`setBuildDir(java.lang.Object path)`	已弃用，请改用getLayout().getBuildDirectory()和设置DirectoryProperty
`void`	`setDefaultTasks(java.util.List<java.lang.String> defaultTasks)`	设置该项目的默认任务名称
`void`	`setDescription(java.lang.String description)`	为此项目设置描述
`void`	`setGroup(java.lang.Object group)`	设置该项目的组
`void`	`setProperty(java.lang.String name, java.lang.Object value)`	设置此项目的属性
`void`	`setStatus(java.lang.Object status)`	设置此项目的状态
`void`	`setVersion(java.lang.Object version)`	设置此项目的版本
`void`	`subprojects(Closure configureClosure)`	配置该项目的子项目
`void`	`subprojects(Action<? super Project> action)`	配置该项目的子项目
`WorkResult`	`sync(Action<? super SyncSpec> action)`	将目标目录与某些源目录和文件同步
`FileTree`	`tarTree(java.lang.Object tarPath)`	创建一个包含给定TAR文件内容的新FileTree
`Task`	`task(java.lang.String name)`	使用给定名称创建一个任务并将其添加到此项目
`Task`	`task(java.lang.String name, Closure configureClosure)`	使用给定名称创建一个任务并将其添加到此项目
`Task`	`task(java.lang.String name, Action<? super Task> configureAction)`	使用给定名称创建一个任务并将其添加到此项目
`Task`	`task(java.util.Map<java.lang.String,?> args, java.lang.String name)`	使用给定名称创建一个任务并将其添加到此项目
`Task`	`task(java.util.Map<java.lang.String,?> args, java.lang.String name, Closure configureClosure)`	使用给定名称创建一个任务并将其添加到此项目
`java.net.URI`	`uri(java.lang.Object path)`	将文件路径解析为URI，相对于此项目的项目目录
`FileTree`	`zipTree(java.lang.Object zipPath)`	创建一个新的FileTree，其中包含给定ZIP文件的内容

Project中文源码

/**
 * 该接口是与Gradle从构建文件中交互的主要API。通过一个Project，你可以编程访问Gradle的所有功能。
 *
 * 生命周期
 *
 * 在构建初始化期间，每个参与构建的项目都会组装一个Project对象，如下所示：
 *
 * 创建一个Settings实例用于构建。
 * 如果存在，对Settings对象执行DEFAULT_SETTINGS_FILE脚本进行配置。
 * 使用配置的Settings对象创建Project实例的层次结构。
 * 最后，通过在项目上执行DEFAULT_BUILD_FILE文件来评估每个Project（如果存在）。项目按广度优先顺序进行评估，以便在其子项目之前评估项目。可以通过调用evaluationDependsOnChildren()或使用evaluationDependsOn(String)添加显式评估依赖项来重写此顺序。
 *
 * 任务
 *
 * 项目本质上是一组Task对象。每个任务执行一些基本工作，例如编译类，运行单元测试或压缩WAR文件。您可以使用TaskContainer上的create()方法之一将任务添加到项目中，例如TaskContainer.create(String)。您可以使用TaskContainer上的某个查找方法定位现有任务，例如org.gradle.api.tasks.TaskCollection.getByName(String)。
 *
 * 依赖关系
 *
 * 项目通常具有完成工作所需的多个依赖项。此外，项目通常会生成多个构件，其他项目可以使用这些构件。这些依赖项分组为配置，并可以从存储库中检索和上传。您可以使用getConfigurations()方法返回的org.gradle.api.artifacts.ConfigurationContainer管理配置，使用getDependencies()方法返回的org.gradle.api.artifacts.dsl.DependencyHandler管理依赖项，使用getArtifacts()方法返回的org.gradle.api.artifacts.dsl.ArtifactHandler管理构件，以及使用getRepositories()方法返回的org.gradle.api.artifacts.dsl.RepositoryHandler管理存储库。
 *
 * 多项目构建
 *
 * 项目按照项目层次结构进行排列。项目具有名称和完全限定路径，用于在层次结构中唯一标识它们。
 *
 * 插件
 *
 * 插件可用于模块化和重用项目配置。可以使用PluginAware.apply(java.util.Map)方法或使用org.gradle.plugin.use.PluginDependenciesSpec插件脚本块来应用插件。
 *
 * 动态项目属性
 *
 * Gradle针对Project实例执行项目的构建文件以配置项目。脚本使用的任何属性或方法都将委托给相关联的Project对象。这意味着，您可以在脚本中直接使用Project接口上的任何方法和属性。例如：
 *
 * defaultTasks('some-task')  // Delegates to Project.defaultTasks()
 * reportsDir = file('reports') // Delegates to Project.file() and the Java Plugin
 * 
 * 也可以通过project属性访问Project实例。在某些情况下，这可以使脚本更清晰。例如，您可以使用project.name而不是name来访问项目的名称。
 *
 * 项目有5个属性范围，在其中搜索属性。您可以按名称在构建文件中访问这些属性，也可以通过调用项目的property(String)方法来访问这些属性。这些范围是：
 *
 * Project对象本身。此范围包括由Project实现类声明的任何属性getter和setter。例如，getRootProject()可作为rootProject属性访问。该范围的属性根据相应的getter或setter方法的存在与否可读或可写。
 * 项目的额外属性。每个项目都维护一个额外属性的映射，该映射可以包含任意名称->值对。一旦定义，此范围的属性可读且可写。有关详细信息，请参阅extra properties。
 * 插件添加到项目中的扩展。每个扩展都可以作为具有相同名称的只读属性使用。
 * 插件添加到项目中的Convention属性。插件可以通过项目的Convention对象向项目添加属性和方法。该范围的属性可能是可读或可写的，具体取决于约定对象。
 * 项目的任务。使用任务的名称作为属性名可以访问任务。此范围的属性是只读的。例如，名为compile的任务可作为compile属性访问。
 * 额外的属性和约定属性从父项目继承，递归到根项目。此范围的属性是只读的。
 *
 * 在读取属性时，项目按顺序搜索上述范围，并从找到属性的第一个范围返回值。如果未找到，则抛出异常。有关更多详细信息，请参阅property(String)。
 *
 * 在写入属性时，项目按照上述范围搜索，并在找到属性的第一个范围中设置属性。如果未找到，则抛出异常。有关更多详细信息，请参阅setProperty(String, Object)。
 *
 * 附加属性
 *
 * 所有额外属性必须通过“ext”命名空间进行定义。一旦定义了额外属性，它将直接在所属对象上（在下面的示例中为Project、Task和子项目）可用，并且可以进行读取和更新。只需通过命名空间完成初始声明即可。
 *
 * project.ext.prop1 = "foo"
 * task doStuff {
 *     ext.prop2 = "bar"
 * }
 * subprojects { ext.${prop3} = false }
 *
 * 通过“ext”或通过所属对象进行读取额外属性。
 *
 * ext.isSnapshot = version.endsWith("-SNAPSHOT")
 * if (isSnapshot) {
 *     // do snapshot stuff
 * }
 *
 * 动态方法
 *
 * 项目有5种方法作用域，可以在这些作用域中搜索方法：
 *
 * Project对象本身。
 * 构建文件。项目在构建文件中搜索已声明的匹配方法。
 * 插件添加到项目中的扩展。每个扩展都可作为接受闭包或org.gradle.api.Action参数的方法使用。
 * 插件添加到项目中的Convention方法。插件可以通过项目的Convention对象向项目添加属性和方法。
 * 项目的任务。为每个任务添加了一个方法，使用任务的名称作为方法名，并采用单个闭包或org.gradle.api.Action参数。该方法使用所提供的闭包调用与关联任务的Task.configure(groovy.lang.Closure)方法。例如，如果项目有一个名为compile的任务，则将添加具有以下签名的方法：void compile(Closure configureClosure)。
 * 父项目的方法，递归到根项目。
 * 项目的属性，其值为闭包。闭包被视为方法，并以提供的参数调用。按上述描述找到属性。
 *
 */
@HasInternalProtocol
public interface Project extends Comparable<Project>, ExtensionAware, PluginAware {
    /**
     * 默认项目构建文件名称。
     */
    String DEFAULT_BUILD_FILE = "build.gradle";

    /**
     * 项目和任务路径名称的层次结构分隔符。
     */
    String PATH_SEPARATOR = ":";

    /**
     * 默认构建目录名称。
     */
    String DEFAULT_BUILD_DIR_NAME = "build";

    String GRADLE_PROPERTIES = "gradle.properties";

    String SYSTEM_PROP_PREFIX = "systemProp";

    String DEFAULT_VERSION = "unspecified";

    String DEFAULT_STATUS = "release";

    /**
     * 返回此项目所属层次结构的根项目。
     *
     * @return 根项目。永远不返回null。
     */
    Project getRootProject();

    /**
     * 返回此项目的根目录。根目录是根项目的项目目录。
     *
     * @return 根目录。永远不返回null。
     */
    File getRootDir();

    /**
     * 返回此项目的构建目录。构建目录是生成所有构件的目录。构建目录的默认值为projectDir/build
     *
     * @return 构建目录。永远不返回null。
     */
    File getBuildDir();

    /**
     * 设置此项目的构建目录。构建目录是生成所有构件的目录。
     *
     * @param path 构建目录
     * @since 4.0
     */
    void setBuildDir(File path);

    /**
     * 设置此项目的构建目录。构建目录是生成所有构件的目录。path参数按照file(Object)的说明进行评估。这意味着您可以使用相对或绝对路径或File对象来指定构建目录。
     *
     * @param path 构建目录。按照file(Object)进行评估
     */
    void setBuildDir(Object path);

    /**
     * 此项目的构建脚本。
     * <p>
     * 如果文件存在，则在配置此项目时将其针对该项目进行评估。
     *
     * @return 此项目的构建脚本。
     */
    File getBuildFile();

    /**
     * 返回此项目的父项目（如果有）。
     *
     * @return 父项目，如果这是根项目则返回null。
     */
    @Nullable
    Project getParent();

    /**
     * 返回此项目的名称。项目的名称在项目层次结构中不一定是唯一的标识符。您应该使用getPath()方法作为项目的唯一标识符。如果根项目未命名并位于文件系统根上，则它将具有随机生成的名称。
     *
     * @return 此项目的名称。永远不返回null。
     */
    String getName();

    /**
     * 返回此项目的人类可读显示名称。
     */
    String getDisplayName();

    /**
     * 返回此项目的描述（如果有）。
     *
     * @return 描述。可能返回null。
     */
    @Nullable
    String getDescription();

    /**
     * 为此项目设置描述。
     *
     * @param description 项目的描述。可能为null。
     */
    void setDescription(@Nullable String description);

    /**
     * 返回此项目的组。Gradle始终使用组的toString()值。默认情况下，组使用路径并使用点作为分隔符。
     *
     * @return 此项目的组。永远不返回null。
     */
    Object getGroup();

    /**
     * 设置此项目的组。
     *
     * @param group 此项目的组。不能为null。
     */
    void setGroup(Object group);

    /**
     * 返回此项目的版本。Gradle始终使用版本的toString()值。版本默认为DEFAULT_VERSION。
     *
     * @return 此项目的版本。永远不返回null。
     */
    Object getVersion();

    /**
     * 设置此项目的版本。
     *
     * @param version 此项目的版本。不能为null。
     */
    void setVersion(Object version);

    /**
     * 返回此项目的状态。Gradle始终使用状态的toString()值。状态默认为DEFAULT_STATUS。
     *
     * 仅当您与模块描述符一起上传库时，才关心项目的状态。在此模块描述符中，指定的状态将是其一部分。
     *
     * @return 此项目的状态。永远不返回null。
     */
    Object getStatus();

    /**
     * 设置此项目的状态。
     *
     * @param status 状态。不能为null。
     */
    void setStatus(Object status);

    /**
     * 返回此项目的直接子项目。
     *
     * @return 子项目名称到子项目的映射。如果此项目没有任何子项目，则返回空映射。
     */
    @ForExternalUse // See ProjectInternal#getChildProjects
    Map<String, Project> getChildProjects();
}
 
    /**
     * 设置此项目的属性。此方法在以下位置搜索具有给定名称的属性，并在找到属性的第一个位置上设置属性。
     *
     * <ol>
     *
     * <li>项目对象本身。例如，rootDir项目属性。</li>
     *
     * <li>项目的Convention对象。例如，srcRootName java插件属性。</li>
     *
     * <li>项目的额外属性。</li>
     *
     * </ol>
     *
     * 如果未找到属性，则抛出MissingPropertyException。
     *
     * @param name 属性的名称
     * @param value 属性的值
     */
    void setProperty(String name, @Nullable Object value) throws MissingPropertyException;

    /**
     * 返回此项目。该方法在构建文件中非常有用，可以显式访问项目的属性和方法。例如，使用project.name可以更好地表达您的意图，而不是使用name。此方法还允许您从可能隐藏属性的范围（例如方法或闭包）访问项目属性。
     *
     * @return 此项目。永远不返回null。
     */
    Project getProject();

    /**
     * 返回包含此项目及其子项目的集合。
     *
     * @return 项目集合。
     */
    Set<Project> getAllprojects();

    /**
     * 返回包含此项目的子项目的集合。
     *
     * @return 项目集合。如果此项目没有子项目，则返回空集合。
     */
    Set<Project> getSubprojects();

    /**
     * 使用给定名称创建一个Task并将其添加到此项目。调用此方法等效于使用空选项映射调用task(java.util.Map, String)。
     *
     * 将任务添加到项目后，它将作为项目的属性可用，因此您可以在构建文件中通过名称引用该任务。有关更多详细信息，请参见这里
     *
     * 如果此项目中已存在具有给定名称的任务，则抛出异常。
     *
     * @param name 要创建的任务的名称
     * @return 新创建的任务对象
     * @throws InvalidUserDataException 如果此项目中已存在具有给定名称的任务。
     */
    Task task(String name) throws InvalidUserDataException;

    /**
     * 使用给定名称创建一个Task并将其添加到此项目。可以将创建选项的映射传递给此方法以控制如何创建任务。可用的选项如下：
     *
     * | 选项 | 描述 | 默认值 |
     * | --- | --- | --- |
     * | {@value org.gradle.api.Task#TASK_TYPE} | 要创建的任务的类。 | org.gradle.api.DefaultTask |
     * | {@value org.gradle.api.Task#TASK_OVERWRITE} | 替换现有任务？ | false |
     * | {@value org.gradle.api.Task#TASK_DEPENDS_ON} | 此任务依赖的任务名称或任务名称集合 | [] |
     * | {@value org.gradle.api.Task#TASK_ACTION} | 要添加到任务的闭包或Action。 | null |
     * | {@value org.gradle.api.Task#TASK_DESCRIPTION} | 任务的描述。 | null |
     * | {@value org.gradle.api.Task#TASK_GROUP} | 任务所属的任务组。 | null |
     *
     * 将任务添加到项目后，它将作为项目的属性可用，因此您可以在构建文件中通过名称引用该任务。有关更多详细信息，请参见这里
     *
     * 如果此项目中已存在具有给定名称的任务，并且未将override选项设置为true，则抛出异常。
     *
     * @param args 任务创建选项。
     * @param name 要创建的任务的名称
     * @return 新创建的任务对象
     * @throws InvalidUserDataException 如果此项目中已存在具有给定名称的任务。
     */
    Task task(Map<String, ?> args, String name) throws InvalidUserDataException;

    /**
     * 使用给定名称创建一个Task并将其添加到此项目。在返回任务之前，将执行给定的闭包来配置任务。可以将创建选项的映射传递给此方法以控制如何创建任务。有关可用选项，请参见task(java.util.Map, String)。
     *
     * 将任务添加到项目后，它将作为项目的属性可用，因此您可以在构建文件中通过名称引用该任务。有关更多详细信息，请参见这里
     *
     * 如果此项目中已存在具有给定名称的任务，并且未将override选项设置为true，则抛出异常。
     *
     * @param args 任务创建选项。
     * @param name 要创建的任务的名称
     * @param configureClosure 用于配置创建的任务的闭包。
     * @return 新创建的任务对象
     * @throws InvalidUserDataException 如果此项目中已存在具有给定名称的任务。
     */
    Task task(Map<String, ?> args, String name, Closure configureClosure);

    /**
     * 使用给定名称创建一个Task并将其添加到此项目。在返回任务之前，将执行给定的闭包来配置任务。
     *
     * 将任务添加到项目后，它将作为项目的属性可用，因此您可以在构建文件中通过名称引用该任务。有关更多详细信息，请参见这里
     *
     * @param name 要创建的任务的名称
     * @param configureClosure 用于配置创建的任务的闭包。
     * @return 新创建的任务对象
     * @throws InvalidUserDataException 如果此项目中已存在具有给定名称的任务。
     */
    Task task(String name, @DelegatesTo(Task.class) Closure configureClosure);

    /**
     * 使用给定名称创建一个Task并将其添加到此项目。在返回任务之前，将执行给定的操作来配置任务。
     *
     * 将任务添加到项目后，它将作为项目的属性可用，因此您可以在构建文件中通过名称引用该任务。有关更多详细信息，请参见这里
     *
     * @param name 要创建的任务的名称
     * @param configureAction 用于配置创建的任务的操作。
     * @return 新创建的任务对象
     * @throws InvalidUserDataException 如果此项目中已存在具有给定名称的任务。
     * @see TaskContainer#create(String, Action)
     * @since 4.10
     */
    Task task(String name, Action<? super Task> configureAction);

    /**
     * 返回此项目的路径。路径是项目的完全限定名称。
     *
     * @return 路径。永远不返回null。
     */
    String getPath();

    /**
     * 返回此项目的默认任务名称。当在启动构建时没有提供任务名称时，使用这些默认任务名称。
     *
     * @return 默认任务名称。如果此项目没有默认任务，则返回空列表。
     */
    List<String> getDefaultTasks();

    /**
     * 设置此项目的默认任务名称。当在启动构建时没有提供任务名称时，使用这些默认任务名称。
     *
     * @param defaultTasks 默认任务名称。
     */
    void setDefaultTasks(List<String> defaultTasks);

    /**
     * 设置此项目的默认任务名称。当在启动构建时没有提供任务名称时，使用这些默认任务名称。
     *
     * @param defaultTasks 默认任务名称。
     */
    void defaultTasks(String... defaultTasks);

    /**
     * 声明此项目对具有给定路径的项目具有评估依赖关系。
     *
     * @param path 此项目依赖的项目的路径。
     * @return 此项目所依赖的项目。
     * @throws UnknownProjectException 如果不存在具有给定路径的项目。
     */
    Project evaluationDependsOn(String path) throws UnknownProjectException;

    /**
     * 声明此项目对其每个子项目具有评估依赖关系。
     *
     */
    void evaluationDependsOnChildren();

    /**
     * 通过路径查找项目。如果路径是相对路径，则将其解释为相对于此项目。
     *
     * @param path 路径。
     * @return 具有给定路径的项目。如果不存在此类项目，则返回null。
     */
    @Nullable
    Project findProject(String path);

    /**
     * 通过路径查找项目。如果路径是相对路径，则将其解释为相对于此项目。
     *
     * @param path 路径。
     * @return 具有给定路径的项目。永远不返回null。
     * @throws UnknownProjectException 如果不存在具有给定路径的项目。
     */
    Project project(String path) throws UnknownProjectException;

    /**
     * 通过路径查找项目，并使用给定的闭包配置它。如果路径是相对路径，则将其解释为相对于此项目。目标项目作为闭包的委托对象传递给闭包。
     *
     * @param path 路径。
     * @param configureClosure 用于配置项目的闭包。
     * @return 具有给定路径的项目。永远不返回null。
     * @throws UnknownProjectException 如果不存在具有给定路径的项目。
     */
    Project project(String path, @DelegatesTo(Project.class) Closure configureClosure);

    /**
     * 通过路径查找项目，并使用给定的操作配置它。如果路径是相对路径，则将其解释为相对于此项目。
     *
     * @param path 路径。
     * @param configureAction 用于配置项目的操作。
     * @return 具有给定路径的项目。永远不返回null。
     * @throws UnknownProjectException 如果不存在具有给定路径的项目。
     *
     * @since 3.4
     */
    Project project(String path, Action<? super Project> configureAction);

    /**
     * 返回包含此项目及其子项目的任务集合，根据递归参数决定是否包含子项目。
     *
     * @param recursive 如果为true，则返回此项目及其子项目的任务。如果为false，则只返回此项目的任务。
     * @return 从项目到任务集合的映射。
     */
    Map<Project, Set<Task>> getAllTasks(boolean recursive);

    /**
     * 返回此项目及其子项目中具有给定名称的任务集合。
     *
     * 注意：这是一个开销较大的操作，因为它要求配置所有项目。
     *
     * @param name 要查找的任务的名称。
     * @param recursive 如果为true，则返回此项目及其子项目中具有给定名称的任务。如果为false，则只返回此项目中具有给定名称的任务。
     * @return 任务集合。如果在此项目中不存在此类任务，则返回空集合。
     */
    Set<Task> getTasksByName(String name, boolean recursive);

    /**
     * 项目构建文件所在的目录。
     *
     * @return 项目目录。永远不返回null。
     */
    File getProjectDir();

    /**
     * 将文件路径解析为相对于此项目的项目目录的路径。此方法根据路径的类型进行转换：
     *
     * - {@link CharSequence}，包括String或groovy.lang.GString。解释为相对于项目目录的路径。以“file:”开头的字符串将被视为文件URL。
     * - File。如果文件是绝对文件，则原样返回。否则，将相对于项目目录解释文件的路径。
     * - java.nio.file.Path。路径必须与默认提供程序关联，并且与File实例相同处理。
     * - java.net.URI或java.net.URL。将URL的路径解释为文件路径。仅支持“file:” URL。
     * - org.gradle.api.file.Directory或org.gradle.api.file.RegularFile。
     * - Provider的任何支持类型。递归解析提供程序的值。
     * - org.gradle.api.resources.TextResource。
     * - Groovy闭包或Kotlin函数，返回任何支持类型。递归解析闭包的返回值。
     * - java.util.concurrent.Callable，返回任何支持类型。递归解析可调用的返回值。
     *
     * @param path 要解析为文件的对象。
     * @return 已解析的文件。永远不返回null。
     */
    File file(Object path);
 
/**
 * <p>将路径解析为相对于此项目的项目目录，并使用给定的方案进行验证。请参阅{@link PathValidation}以获取可能的验证列表。</p>
 *
 * @param path 被解析的路径对象，其toString方法的值被解释为相对于项目目录的路径。
 * @param validation 对文件执行的验证。
 * @return 已解析的文件。永远不会返回null。
 * @throws InvalidUserDataException 当文件不满足给定的验证约束时抛出异常。
 */
File file(Object path, PathValidation validation) throws InvalidUserDataException;

/**
 * <p>将文件路径解析为URI，相对于此项目的项目目录。根据{@link #file(Object)}中描述的方式评估提供的路径对象，不仅支持'file:' URI，还支持任何URI方案。</p>
 *
 * @param path 要解析为URI的对象。
 * @return 已解析的URI。永远不会返回null。
 */
URI uri(Object path);

/**
 * <p>返回从项目目录到给定路径的相对路径。逻辑上按照{@link #file(Object)}中描述的方式解析给定的路径对象，然后计算相对路径。</p>
 *
 * @param path 要转换为相对路径的路径。
 * @return 相对路径。永远不会返回null。
 * @throws IllegalArgumentException 如果给定的路径不能与项目目录进行相对路径计算。
 */
String relativePath(Object path);

/**
 * <p>返回包含给定文件的{@link ConfigurableFileCollection}。可以将以下任何类型传递给此方法：</p>
 *
 * <ul> <li>{@link CharSequence}，包括{@link String}或{@link groovy.lang.GString}。相对于项目目录解释，如{@link #file(Object)}所述。以{@code file:}开头的字符串将被视为文件URL。</li>
 *
 * <li>{@link File}。相对于项目目录解释，如{@link #file(Object)}所述。</li>
 *
 * <li>{@link java.nio.file.Path}，如{@link #file(Object)}所述。</li>
 *
 * <li>{@link java.net.URI}或{@link java.net.URL}。URL的路径被解释为文件路径。仅支持{@code file:} URL。</li>
 *
 * <li>{@link org.gradle.api.file.Directory}或{@link org.gradle.api.file.RegularFile}。</li>
 *
 * <li>{@link java.util.Collection}，{@link Iterable}或包含任何支持类型的数组。集合的元素被递归地转换为文件。</li>
 *
 * <li>{@link org.gradle.api.file.FileCollection}。返回集合中的内容。</li>
 *
 * <li>{@link org.gradle.api.file.FileTree}或{@link org.gradle.api.file.DirectoryTree}。返回树中的内容。</li>
 *
 * <li>{@link Provider}的任何支持类型。提供者的值会被递归地转换为文件。如果提供者表示任务的输出，则如果文件集用作其他任务的输入，则执行该任务。
 *
 * <li>返回任何支持类型的{@link java.util.concurrent.Callable}。{@code call()}方法的返回值会被递归地转换为文件。{@code null}返回值被视为空集合。</li>
 *
 * <li>Groovy {@link Closure}或Kotlin函数，返回此处列出的任何类型之一。闭包的返回值会被递归地转换为文件。{@code null}返回值被视为空集合。</li>
 *
 * <li>{@link Task}。转换为任务的输出文件。如果文件集用作其他任务的输入，则执行该任务。</li>
 *
 * <li>{@link org.gradle.api.tasks.TaskOutputs}。转换为相关任务的输出文件。如果文件集用作其他任务的输入，则执行该任务。</li>
 *
 * <li>其他任何内容都被视为错误。</li>
 *
 * </ul>
 *
 * <p>返回的文件集是延迟计算的，只有在查询文件集的内容时才会计算路径。文件集也是动态的，每次查询文件集的内容时都会重新计算上述路径。</p>
 *
 * <p>返回的文件集保持提供的路径的迭代顺序。</p>
 *
 * <p>返回的文件集保留生成文件的任务的详细信息，因此如果将此文件集用作某个任务的输入，则会执行这些任务。</p>
 *
 * <p>此方法还可以用于创建空集合，稍后可以对其进行修改以添加元素。</p>
 *
 * @param paths 文件的路径。可能为空。
 * @return 文件集。永远不会返回null。
 */
ConfigurableFileCollection files(Object... paths);

/**
 * <p>使用给定路径创建一个新的{@code ConfigurableFileCollection}。根据{@link
 * #files(Object...)}计算路径。使用给定的闭包配置文件集合。将文件集合作为代理传递给闭包。示例：</p>
 * <pre>
 * files "$buildDir/classes" {
 *     builtBy 'compile'
 * }
 * </pre>
 * <p>返回的文件集是延迟计算的，只有在查询文件集的内容时才会计算路径。文件集也是动态的，每次查询文件集的内容时都会重新计算上述路径。</p>
 *
 * @param paths 文件集合的内容。根据{@link #files(Object...)}进行评估。
 * @param configureClosure 用于配置文件集合的闭包。
 * @return 配置的文件集合。永远不会返回null。
 */
ConfigurableFileCollection files(Object paths, @DelegatesTo(ConfigurableFileCollection.class) Closure configureClosure);

/**
 * <p>使用给定路径创建一个新的{@code ConfigurableFileCollection}。根据{@link
 * #files(Object...)}计算路径。使用给定的操作配置文件集合。示例：</p>
 * <pre>
 * files "$buildDir/classes" {
 *     builtBy 'compile'
 * }
 * </pre>
 * <p>返回的文件集是延迟计算的，只有在查询文件集的内容时才会计算路径。文件集也是动态的，每次查询文件集的内容时都会重新计算上述路径。</p>
 *
 * @param paths 文件集合的内容。根据{@link #files(Object...)}进行评估。
 * @param configureAction 用于配置文件集合的操作。
 * @return 配置的文件集合。永远不会返回null。
 * @since 3.5
 */
ConfigurableFileCollection files(Object paths, Action<? super ConfigurableFileCollection> configureAction);

/**
 * <p>使用给定的基目录创建一个新的{@code ConfigurableFileTree}。将给定的baseDir路径按照{@link #file(Object)}进行评估。</p>
 *
 * <p>返回的文件树是延迟计算的，只有在查询文件树的内容时才会扫描文件。文件树也是动态的，每次查询文件树的内容时都会重新扫描文件。</p>
 *
 * <pre class='autoTested'>
 * def myTree = fileTree("src")
 * myTree.include "**&#47;*.java"
 * myTree.builtBy "someTask"
 *
 * task copy(type: Copy) {
 *    from myTree
 * }
 * </pre>
 *
 * <p>{@code FileTree}中文件的顺序是不稳定的，即使在单台计算机上也是如此。
 *
 * @param baseDir 文件树的基目录。根据{@link #file(Object)}进行评估。
 * @return 文件树。永远不会返回null。
 */
ConfigurableFileTree fileTree(Object baseDir);

/**
 * <p>使用给定的基目录创建一个新的{@code ConfigurableFileTree}。将给定的baseDir路径按照{@link #file(Object)}进行评估。将使用闭包配置新的文件树。
 * 文件树作为其代理传递给闭包。示例：</p>
 *
 * <pre class='autoTested'>
 * def myTree = fileTree('src') {
 *    exclude '**&#47;.data/**'
 *    builtBy 'someTask'
 * }
 *
 * task copy(type: Copy) {
 *    from myTree
 * }
 * </pre>
 *
 * <p>返回的文件树是延迟计算的，只有在查询文件树的内容时才会扫描文件。文件树也是动态的，每次查询文件树的内容时都会重新扫描文件。</p>
 *
 * <p>{@code FileTree}中文件的顺序是不稳定的，即使在单台计算机上也是如此。
 *
 * @param baseDir 文件树的基目录。根据{@link #file(Object)}进行评估。
 * @param configureClosure 用于配置{@code ConfigurableFileTree}对象的闭包。
 * @return 配置的文件树。永远不会返回null。
 */
ConfigurableFileTree fileTree(Object baseDir, @DelegatesTo(ConfigurableFileTree.class) Closure configureClosure);

/**
 * <p>使用给定的基目录创建一个新的{@code ConfigurableFileTree}。将给定的baseDir路径按照{@link #file(Object)}进行评估。将使用操作配置新的文件树。示例：</p>
 *
 * <pre class='autoTested'>
 * def myTree = fileTree('src') {
 *    exclude '**&#47;.data/**'
 *    builtBy 'someTask'
 * }
 *
 * task copy(type: Copy) {
 *    from myTree
 * }
 * </pre>
 *
 * <p>返回的文件树是延迟计算的，只有在查询文件树的内容时才会扫描文件。文件树也是动态的，每次查询文件树的内容时都会重新扫描文件。</p>
 *
 * <p>{@code FileTree}中文件的顺序是不稳定的，即使在单台计算机上也是如此。
 *
 * @param baseDir 文件树的基目录。根据{@link #file(Object)}进行评估。
 * @param configureAction 用于配置{@code ConfigurableFileTree}对象的操作。
 * @return 配置的文件树。永远不会返回null。
 * @since 3.5
 */
ConfigurableFileTree fileTree(Object baseDir, Action<? super ConfigurableFileTree> configureAction);

/**
 * <p>使用提供的参数映射创建一个新的{@code ConfigurableFileTree}。该映射将应用于新文件树上的属性。示例：</p>
 *
 * <pre class='autoTested'>
 * def myTree = fileTree(dir:'src', excludes:['**&#47;ignore/**', '**&#47;.data/**'])
 *
 * task copy(type: Copy) {
 *     from myTree
 * }
 * </pre>
 *
 * <p>返回的文件树是延迟计算的，只有在查询文件树的内容时才会扫描文件。文件树也是动态的，每次查询文件树的内容时都会重新扫描文件。</p>
 *
 * <p>{@code FileTree}中文件的顺序是不稳定的，即使在单台计算机上也是如此。
 *
 * @param args 用于{@code ConfigurableFileTree}对象的属性赋值的映射
 * @return 配置的文件树。永远不会返回null。
 */
ConfigurableFileTree fileTree(Map<String, ?> args);

/**
 * <p>创建一个包含给定ZIP文件内容的新{@code FileTree}。给定的zipPath路径按照{@link #file(Object)}进行评估。可以将此方法与{@link #copy(Action)}方法结合使用来解压缩ZIP文件。</p>
 *
 * <p>返回的文件树是延迟计算的，只有在查询文件树的内容时才会扫描文件。文件树也是动态的，每次查询文件树的内容时都会重新扫描文件。</p>
 *
 * @param zipPath ZIP文件。按照{@link #file(Object)}进行评估。
 * @return 文件树。永远不会返回null。
 */
FileTree zipTree(Object zipPath);

/**
 * 创建一个包含给定TAR文件内容的新{@code FileTree}。给定的tarPath路径可以是：
 * <ul>
 *   <li>{@link org.gradle.api.resources.Resource}的实例</li>
 *   <li>任何其他对象按照{@link #file(Object)}进行评估</li>
 * </ul>
 *
 * 返回的文件树是延迟计算的，只有在查询文件树的内容时才会扫描文件。文件树也是动态的，每次查询文件树的内容时都会重新扫描文件。
 * <p>
 * 除非提供资源的自定义实现，否则tar树将根据文件扩展名猜测压缩方式。
 * <p>
 * 您可以将此方法与{@link #copy(Action)}方法结合使用来解压缩TAR文件：
 *
 * <pre class='autoTested'>
 * task untar(type: Copy) {
 *   from tarTree('someCompressedTar.gzip')
 *
 *   //tar树根据文件扩展名猜测压缩方式
 *   //但是，如果必须明确指定压缩方式，可以：
 *   from tarTree(resources.gzip('someTar.ext'))
 *
 *   //如果使用非常规的压缩tar
 *   //您可以提供自己的可读资源实现：
 *   //from tarTree(yourOwnResource as ReadableResource)
 *
 *   into 'dest'
 * }
 * </pre>
 *
 * @param tarPath TAR文件或{@link org.gradle.api.resources.Resource}的实例。
 * @return 文件树。永远不会返回null。
 */
FileTree tarTree(Object tarPath);

/**
 * 根据提供的值创建一个基于{@link Provider}的实现。
 *
 * 提供者是动态的，每次查询其值时都会调用{@link Callable}。{@link Callable}可能返回{@code null}，在这种情况下，将认为提供者没有值。
 *
 * @param value 用于计算值的{@link Callable}。
 * @return 提供者。永远不会返回null。
 * @see org.gradle.api.provider.ProviderFactory#provider(Callable)
 * @since 4.0
 */
<T> Provider<T> provider(Callable<? extends @org.jetbrains.annotations.Nullable T> value);

/**
 * 提供访问创建各种类型的{@link Provider}实例的方法。
 *
 * @since 4.0
 */
ProviderFactory getProviders();

/**
 * 提供访问创建各种模型对象的方法。
 *
 * @since 4.0
 */
ObjectFactory getObjects();

/**
 * 提供对此项目的各个重要目录的访问。
 *
 * @since 4.1
 */
ProjectLayout getLayout();

/**
 * 创建一个目录并返回指向该目录的文件。
 *
 * @param path 要创建的目录的路径。按照{@link #file(Object)}进行评估。
 * @return 创建的目录
 * @throws org.gradle.api.InvalidUserDataException 如果路径指向现有文件。
 */
File mkdir(Object path);

/**
 * 删除文件和目录。
 * <p>
 * 这不会遵循符号链接。如果需要遵循符号链接，请使用{@link #delete(Action)}。
 *
 * @param paths 由{@link org.gradle.api.Project#files(Object...)}接受的任何类型的对象
 * @return 如果删除了任何内容，则返回true；否则返回false。
 */
boolean delete(Object... paths);
 
/**
 * 删除指定的文件。给定的操作用于配置{@link DeleteSpec}，然后用于删除文件。
 *
 * @param action 用于配置DeleteSpec的操作
 * @return 可用于检查删除是否有任何工作的{@link WorkResult}
 */
WorkResult delete(Action<? super DeleteSpec> action);

/**
 * 执行Java主类。闭包配置一个{@link org.gradle.process.JavaExecSpec}。
 *
 * @param closure 用于配置执行的闭包。
 * @return 执行结果
 */
ExecResult javaexec(@DelegatesTo(JavaExecSpec.class) Closure closure);

/**
 * 执行外部Java进程。
 *
 * 给定的操作配置一个{@link org.gradle.process.JavaExecSpec}，用于启动进程。
 * 该方法会阻塞，直到进程终止，并返回其结果。
 *
 * @param action 用于配置执行的操作。
 * @return 执行结果
 */
ExecResult javaexec(Action<? super JavaExecSpec> action);

/**
 * 执行外部命令。闭包配置一个{@link org.gradle.process.ExecSpec}。
 *
 * @param closure 用于配置执行的闭包。
 * @return 执行结果
 */
ExecResult exec(@DelegatesTo(ExecSpec.class) Closure closure);

/**
 * 执行外部命令。
 *
 * 给定的操作配置一个{@link org.gradle.process.ExecSpec}，用于启动进程。
 * 该方法会阻塞，直到进程终止，并返回其结果。
 *
 * @param action 用于配置执行的操作。
 * @return 执行结果
 */
ExecResult exec(Action<? super ExecSpec> action);

/**
 * 将名称转换为相对于此项目的绝对项目路径。
 *
 * @param path 要转换的路径。
 * @return 绝对路径。
 */
String absoluteProjectPath(String path);

/**
 * 将名称转换为相对于此项目的项目路径。
 *
 * @param path 要转换的路径。
 * @return 相对路径。
 */
String relativeProjectPath(String path);

/**
 * 返回此项目的<code>AntBuilder</code>。您可以在构建文件中使用它来执行ant任务。参见下面的示例。
 *
 * @return 此项目的<code>AntBuilder</code>。永远不会返回null。
 */
AntBuilder getAnt();

/**
 * 为此项目创建一个额外的<code>AntBuilder</code>。您可以在构建文件中使用它来执行ant任务。
 *
 * @return 为此项目创建的<code>AntBuilder</code>。永远不会返回null。
 * @see #getAnt()
 */
AntBuilder createAntBuilder();

/**
 * 执行指定的闭包，该闭包在此项目评估之前调用<code>AntBuilder</code>。将<code>AntBuilder</code>作为闭包的委托传递。
 *
 * @param configureClosure 要执行的闭包。
 * @return <code>AntBuilder</code>。永远不会返回null。
 */
AntBuilder ant(@DelegatesTo(AntBuilder.class) Closure configureClosure);

/**
 * 执行指定的操作，该操作在此项目评估之前调用<code>AntBuilder</code>。参见下面的示例。
 *
 * @param configureAction 要执行的操作。
 * @return <code>AntBuilder</code>。永远不会返回null。
 * @since 3.5
 */
AntBuilder ant(Action<? super AntBuilder> configureAction);

/**
 * 返回此项目的配置。
 *
 * @return 此项目的配置。
 */
ConfigurationContainer getConfigurations();

/**
 * 配置此项目的依赖配置。
 *
 * 此方法对此项目的{@link ConfigurationContainer}执行给定的闭包。将{@link ConfigurationContainer}作为闭包的委托传递。
 *
 * @param configureClosure 用于配置依赖配置的闭包。
 */
void configurations(Closure configureClosure);

/**
 * 返回此项目的ArtifactHandler，用于将项目产生的构件分配给配置。
 */
ArtifactHandler getArtifacts();

/**
 * 配置此项目的已发布构件。
 *
 * 此方法对此项目的{@link ArtifactHandler}执行给定的闭包。将{@link ArtifactHandler}作为闭包的委托传递。
 *
 * @param configureClosure 用于配置已发布构件的闭包。
 */
void artifacts(@DelegatesTo(ArtifactHandler.class) Closure configureClosure);

/**
 * 配置此项目的已发布构件。
 *
 * 此方法对此项目的{@link ArtifactHandler}执行给定的操作。
 *
 * @param configureAction 用于配置已发布构件的操作。
 * @since 3.5
 */
void artifacts(Action<? super ArtifactHandler> configureAction);

/**
 * 返回此项目的Convention。您可以在构建文件中使用该属性来访问它，如<code>convention</code>所示。
 *
 * @return 该项目的Convention。永远不会返回null。
 * @deprecated 弃用了conventions概念。尽量使用extensions。
 * @see ExtensionAware#getExtensions()
 */
@Deprecated
Convention getConvention();

/**
 * 比较此项目与多项目层次结构中的另一个项目的嵌套级别。
 *
 * @param otherProject 要比较嵌套级别的项目。
 * @return 如果此项目的嵌套级别小于、等于或大于指定对象，则为负整数、零或正整数。
 * @see #getDepth()
 */
int depthCompare(Project otherProject);

/**
 * 返回项目在多项目层次结构中的嵌套级别。
 * 对于单项目构建，始终返回0。对于多项目层次结构，根项目返回0。
 */
int getDepth();

/**
 * 返回此项目的任务。
 *
 * @return 此项目的任务。
 */
TaskContainer getTasks();

/**
 * 配置此项目的子项目。
 *
 * 此方法对此项目的子项目执行给定的{@link Action}。
 *
 * @param action 要执行的操作。
 */
void subprojects(Action<? super Project> action);

/**
 * 配置此项目的子项目。
 *
 * 此方法对此项目的每个子项目执行给定的闭包。将目标{@link Project}作为闭包的委托传递。
 *
 * @param configureClosure 要执行的闭包。
 */
void subprojects(@DelegatesTo(Project.class) Closure configureClosure);

/**
 * 配置此项目及其子项目。
 *
 * 此方法对此项目及其子项目执行给定的{@link Action}。
 *
 * @param action 要执行的操作。
 */
void allprojects(Action<? super Project> action);

/**
 * 配置此项目及其子项目。
 *
 * 此方法对此项目及其子项目执行给定的闭包。将目标{@link Project}作为闭包的委托传递。
 *
 * @param configureClosure 要执行的闭包。
 */
void allprojects(@DelegatesTo(Project.class) Closure configureClosure);

/**
 * 将一个动作添加到在此项目评估之前立即调用的动作列表中。
 *
 * 将该项目作为参数传递给动作。
 * 通过此方法添加的动作按照它们被添加的顺序执行。
 *
 * 如果项目已经评估，动作将不会执行。
 * 如果在<code>beforeEvaluate</code>动作中调用此方法，则传递的动作将不会执行。
 *
 * @param action 要执行的动作。
 */
void beforeEvaluate(Action<? super Project> action);

/**
 * 将一个动作添加到在此项目评估之后立即调用的动作列表中。
 *
 * 将该项目作为参数传递给动作。
 * 通过此方法添加的动作按照它们被添加的顺序执行。
 * 父项目可以向其子项目添加动作以进一步根据子项目的构建文件运行后基于其状态配置这些项目。
 *
 * 如果项目已经评估，此方法将失败。
 * 如果在<code>afterEvaluate</code>动作中调用此方法，则传递的动作将在所有先前添加的<code>afterEvaluate</code>动作执行完成后执行。
 *
 * @param action 要执行的动作。
 */
void afterEvaluate(Action<? super Project> action);

/**
 * 将一个闭包添加到在此项目评估之前立即调用的闭包列表中。
 *
 * @see Project#beforeEvaluate(Action)
 *
 * @param closure 要调用的闭包。
 */
void beforeEvaluate(Closure closure);

/**
 * 将一个闭包添加到在此项目评估之后立即调用的闭包列表中。
 *
 * @see Project#afterEvaluate(Action)
 *
 * @param closure 要调用的闭包。
 */
void afterEvaluate(@DelegatesTo(Project.class) Closure closure);

/**
 * 确定此项目是否具有给定属性。有关项目可用属性的详细信息，请参见<a href="#properties">这里</a>。
 *
 * @param propertyName 要查找的属性的名称。
 * @return 如果此项目具有给定属性，则为true；否则为false。
 */
boolean hasProperty(String propertyName);

/**
 * 返回此项目的属性。有关项目可用属性的详细信息，请参见<a href="#properties">这里</a>。
 *
 * @return 从属性名称到值的映射。
 */
Map<String, ?> getProperties();

/**
 * 返回给定属性的值。此方法按以下方式定位属性：
 *
 * <ol>
 *
 * <li>如果此项目对象具有给定名称的属性，则返回属性的值。</li>
 *
 * <li>如果此项目具有给定名称的扩展，则返回该扩展。</li>
 *
 * <li>如果此项目的convention对象具有给定名称的属性，则返回属性的值。</li>
 *
 * <li>如果此项目具有给定名称的附加属性，则返回属性的值。</li>
 *
 * <li>如果此项目具有给定名称的任务，则返回该任务。</li>
 *
 * <li>在此项目的祖先项目中向上搜索具有给定名称的约定属性或附加属性。</li>
 *
 * <li>如果找不到，则抛出{@link MissingPropertyException}。</li>
 *
 * </ol>
 *
 * @param propertyName 属性的名称。
 * @return 属性的值，可能为null。
 * @throws MissingPropertyException 当给定的属性未知时抛出异常。
 * @see Project#findProperty(String)
 */
@Nullable
Object property(String propertyName) throws MissingPropertyException;
 /**
 * 返回给定属性的值，如果未找到则返回null。
 * 此方法按照以下方式定位属性：
 * 1. 如果此项目对象具有给定名称的属性，则返回属性的值。
 * 2. 如果此项目具有给定名称的扩展，则返回该扩展。
 * 3. 如果此项目的convention对象具有给定名称的属性，则返回属性的值。
 * 4. 如果此项目具有给定名称的附加属性，则返回属性的值。
 * 5. 如果此项目具有给定名称的任务，则返回该任务。
 * 6. 在此项目的祖先项目中向上搜索具有给定名称的约定属性或附加属性。
 * 7. 如果找不到，则返回null值。
 *
 * @param propertyName 属性的名称。
 * @since 2.13
 * @return 属性的值，可能为null或null值如果未找到。
 * @see Project#property(String)
 */
@Nullable
Object findProperty(String propertyName);

/**
 * 返回此项目的日志记录器。您可以在构建文件中使用它来写日志消息。
 *
 * @return 日志记录器。永远不会返回null。
 */
Logger getLogger();

/**
 * 返回此项目所属的{@link org.gradle.api.invocation.Gradle}调用。
 *
 * @return Gradle对象。永远不会返回null。
 */
Gradle getGradle();

/**
 * 返回用于接收日志记录和控制此项目构建脚本的标准输出/错误捕获的{@link org.gradle.api.logging.LoggingManager}。
 * 默认情况下，System.out被重定向到QUIET日志级别的Gradle日志系统，System.err被重定向到ERROR日志级别。
 *
 * @return LoggingManager。永远不会返回null。
 */
LoggingManager getLogging();

/**
 * 通过闭包配置一个对象，将闭包的委托设置为提供的对象。这样你就不必多次指定配置语句的上下文。
 * 例如:
 * MyType myType = new MyType()
 * myType.doThis()
 * myType.doThat()
 * 可以改成:
 * MyType myType = configure(new MyType()) {
 *     doThis()
 *     doThat()
 * }
 * 被配置的对象也作为参数传递给闭包，因此如果需要可以显式访问它：
 * configure(someObj) { obj -> obj.doThis() }
 *
 * @param object 要配置的对象
 * @param configureClosure 用于配置对象的闭包
 * @return 配置后的对象
 */
Object configure(Object object, Closure configureClosure);

/**
 * 通过闭包配置一组对象。这相当于为每个给定对象调用{@link #configure(Object, groovy.lang.Closure)}。
 *
 * @param objects 要配置的对象
 * @param configureClosure 用于配置对象的闭包
 * @return 配置后的对象。
 */
Iterable<?> configure(Iterable<?> objects, Closure configureClosure);

/**
 * 通过操作配置一组对象。
 *
 * @param objects 要配置的对象
 * @param configureAction 应用于每个对象的操作
 * @return 配置后的对象。
 */
<T> Iterable<T> configure(Iterable<T> objects, Action<? super T> configureAction);

/**
 * 返回用于创建用于检索依赖项和上传项目生成的构件的存储库的处理器。
 *
 * @return 存储库处理器。永远不会返回null。
 */
RepositoryHandler getRepositories();

/**
 * 配置此项目的存储库。
 *
 * 对此项目的{@link RepositoryHandler}执行给定的闭包。将{@link RepositoryHandler}作为闭包的委托传递。
 *
 * @param configureClosure 用于配置存储库的闭包。
 */
void repositories(Closure configureClosure);

/**
 * 返回此项目的依赖处理器。返回的依赖处理器实例可用于添加新的依赖项。对于访问已声明的依赖项，可以使用配置。
 *
 * @return 依赖处理器。永远不会返回null。
 * @see #getConfigurations()
 */
DependencyHandler getDependencies();

/**
 * 配置此项目的依赖项。
 *
 * 对此项目的{@link DependencyHandler}执行给定的闭包。将{@link DependencyHandler}作为闭包的委托传递。
 *
 * @param configureClosure 用于配置依赖项的闭包。
 */
void dependencies(Closure configureClosure);

/**
 * 提供访问各种类型的{@link org.gradle.api.artifacts.Dependency Dependency}实例的方法。
 *
 * @return 依赖工厂。永远不会返回null。
 * @since 7.6
 */
@Incubating
DependencyFactory getDependencyFactory();

/**
 * 返回此项目的构建脚本处理器。您可以使用此处理器查询有关此项目的构建脚本的详细信息，并管理用于编译和执行项目的构建脚本的类路径。
 *
 * @return 类路径处理器。永远不会返回null。
 */
ScriptHandler getBuildscript();

/**
 * 配置此项目的构建脚本类路径。
 *
 * 对此项目的{@link ScriptHandler}执行给定的闭包。将{@link ScriptHandler}作为闭包的委托传递。
 *
 * @param configureClosure 用于配置构建脚本类路径的闭包。
 */
void buildscript(Closure configureClosure);

/**
 * 复制指定的文件。使用给定的闭包配置一个{@link CopySpec}，然后使用该{@link CopySpec}来复制文件。
 *
 * @param closure 用于配置CopySpec的闭包。
 * @return 可用于检查复制是否有任何工作的{@link WorkResult}。
 */
WorkResult copy(@DelegatesTo(CopySpec.class) Closure closure);

/**
 * 复制指定的文件。使用给定的操作配置一个{@link CopySpec}，然后使用该{@link CopySpec}来复制文件。
 *
 * @see #copy(Closure)
 *
 * @param action 用于配置CopySpec的操作。
 * @return 可用于检查复制是否有任何工作的{@link WorkResult}。
 */
WorkResult copy(Action<? super CopySpec> action);

/**
 * 创建一个{@link CopySpec}，稍后可用于复制文件或创建存档。使用给定的闭包配置{@link CopySpec}，然后返回。
 *
 * @param closure 用于配置CopySpec的闭包。
 * @return CopySpec
 */
CopySpec copySpec(@DelegatesTo(CopySpec.class) Closure closure);

/**
 * 创建一个{@link CopySpec}，稍后可用于复制文件或创建存档。使用给定的操作配置{@link CopySpec}，然后返回。
 *
 * @see #copySpec(Closure)
 *
 * @param action 用于配置CopySpec的操作。
 * @return CopySpec
 */
CopySpec copySpec(Action<? super CopySpec> action);

/**
 * 创建一个{@link CopySpec}，稍后可用于复制文件或创建存档。
 *
 * @return 新创建的CopySpec
 */
CopySpec copySpec();

/**
 * 使用给定的操作配置一个{@link SyncSpec}，然后使用该{@link SyncSpec}来将目标目录与一些源目录和文件同步。
 *
 * <p>
 * 这个方法类似于{@link #copy(Action)}任务，但是目标目录只包含复制的文件。
 * 在复制文件之前，目标目录中存在的所有文件都将被删除，除非指定了保留选项。
 *
 * <p>
 * 示例:
 *
 * <pre>
 * project.sync {
 *    from 'my/shared/dependencyDir'
 *    into 'build/deps/compile'
 * }
 * </pre>
 * 注意，您可以保留已经存在于目标目录中的输出:
 * <pre>
 * project.sync {
 *     from 'source'
 *     into 'dest'
 *     preserve {
 *         include 'extraDir/**'
 *         include 'dir1/**'
 *         exclude 'dir1/extra.txt'
 *     }
 * }
 * </pre>
 *
 * @param action 用于配置SyncSpec的操作。
 * @since 4.0
 * @return 可用于检查同步是否有任何工作的{@link WorkResult}。
 */
WorkResult sync(Action<? super SyncSpec> action);

/**
 * 返回此项目的评估状态。您可以使用它来访问有关此项目的评估的信息，例如是否失败等。
 *
 * @return 项目状态。永远不会返回null。
 */
ProjectState getState();

/**
 * 创建一个容器来管理指定类型的命名对象。指定的类型必须具有以String参数命名的公共构造函数。
 *
 * 所有对象都必须将其名称公开为名为“name”的bean属性。名称在对象的生命周期内必须保持恒定。
 *
 * @param type 容器要包含的对象的类型。
 * @param <T> 容器要包含的对象的类型。
 * @return 容器。
 */
<T> NamedDomainObjectContainer<T> container(Class<T> type);

/**
 * 创建一个容器来管理指定类型的命名对象。给定的工厂用于创建对象实例。
 *
 * 所有对象都必须将其名称公开为名为“name”的bean属性。名称在对象的生命周期内必须保持恒定。
 *
 * @param type 容器要包含的对象的类型。
 * @param factory 用于创建对象实例的工厂。
 * @param <T> 容器要包含的对象的类型。
 * @return 容器。
 */
<T> NamedDomainObjectContainer<T> container(Class<T> type, NamedDomainObjectFactory<T> factory);

/**
 * 创建一个容器来管理指定类型的命名对象。给定的闭包用于创建对象实例。将要创建的实例的名称作为参数传递给闭包。
 *
 * 所有对象都必须将其名称公开为名为“name”的bean属性。名称在对象的生命周期内必须保持恒定。
 *
 * @param type 容器要包含的对象的类型。
 * @param factoryClosure 用于创建对象实例的闭包。
 * @param <T> 容器要包含的对象的类型。
 * @return 容器。
 */
<T> NamedDomainObjectContainer<T> container(Class<T> type, Closure factoryClosure);

/**
 * 允许向项目添加DSL扩展。对插件作者很有用。
 *
 * @return 返回的实例允许向项目添加DSL扩展
 */
@Override
ExtensionContainer getExtensions();

/**
 * 提供访问特定资源的实用方法，例如创建各种资源的工厂方法。
 *
 * @return 返回的实例包含各种特定资源的实用方法。
 */
ResourceHandler getResources();

/**
 * 返回此项目生成的软件组件。
 *
 * @return 此项目的组件。
 */
SoftwareComponentContainer getComponents();

/**
 * 配置软件组件。
 *
 * @param configuration 用于配置软件组件的操作。
 *
 * @since 8.1
 */
@Incubating
void components(Action<? super SoftwareComponentContainer> configuration);

/**
 * 提供访问配置输入规范化的方法。
 *
 * @since 4.0
 */
InputNormalizationHandler getNormalization();

/**
 * 配置输入规范化。
 *
 * @since 4.0
 */
void normalization(Action<? super InputNormalizationHandler> configuration);

/**
 * 配置依赖关系锁定
 *
 * @since 4.8
 */
void dependencyLocking(Action<? super DependencyLockingHandler> configuration);

/**
 * 提供访问配置依赖关系锁定的方法
 *
 * @since 4.8
 */
DependencyLockingHandler getDependencyLocking();