原文网址：gradle—build.gradle_IT利刃出鞘的博客-CSDN博客

其他网址

gradle的build.gradle详解_霓虹深处-CSDN博客_build.gradle

Gradle 教程_w3cschool（不带子目录）

Gradle User Guide 中文版（带子目录） （英文版：Gradle User Manual）

Gradle DSL Version 6.5（Gradle英文文档）

概述

一个项目中只放置一个build.gradle，一个项目代表一个组件（jar/war包），构建启动后Gradle会根据build.gradle实例化一个org.gradle.api.Project类，提供了对一个项目的基本配置。

示例（一个完整的构建脚本）

apply plugin: 'java'
apply plugin: 'eclipse'
sourceCompatibility = 1.5
version = '1.0'
jar {
    manifest {
        attributes 'Implementation-Title': 'Gradle Quickstart', 'Implementation-Version': version
    }
}
repositories {
    mavenCentral()
}
dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}
test {
    systemProperties 'property': 'value'
}
uploadArchives {
    repositories {
       flatDir {
           dirs 'repos'
       }
    }
}

属性

属性名称	所属	说明
group	project
version	project	项目版本（全局的）
name(artifact)	project	一般写在settings.gradle
sourceCompatibility = 1.8	java插件
targetCompatibility = 1.8	java插件
compileJava.options.encoding = ‘UTF-8’
compileTestJava.options.encoding = ‘UTF-8’

方法

方法	说明
apply	应用
repositories	添加仓库
dependencies	添加依赖
buildscript
allprojects
subprojects
configurations

repositories{}

简介

repositories是project一个方法，闭包作为参数。若前边的仓库中找不到，再依次在下边的仓库中查找。

repositories {
    // 本地仓库，地址是maven本地仓库路径。不用写，默认先找本地仓库的。
    // mavenLocal()
    //maven私服，此处设置为ali的，地址是url
    maven{ url "https://maven.aliyun.com/repository/public/" }
    //远程仓库,地址是https://repo1.maven.org/maven2
    mavenCentral()
}

上边的mavenLocal对应maven的本地仓库，maven私服对应internal repository，mavenCentral()对应中央仓库，与maven一模一样，直接看这篇即可：maven系列—镜像/仓库_feiying0canglang的博客-CSDN博客

gradle的版本与http

gradle7.0及之后，url最好是安全协议，比如https，上边的http会报警告，解决方法

maven{ url "http://maven.aliyun.com/nexus/content/groups/public" allowInsecureProtocol = true}

修改仓库地址

Gradle、maven默认从中央仓库mavenCentral() 也就是 http://repo1.maven.org/maven2/下载依赖包，但是在国内下载速度巨慢，我们只能使用国内的镜像。

法1：全局配置

配置一个全局配置文件可以只配置一次。如果个别项目需要另外添加仓库地址，只需要在影响的项目下单独配置build.gradle文件增加repositories{}即可。
下边将利用 阿里云开源镜像站 替换掉网络访问困难的 maven、jcenter。

.grable/init.grable

allprojects {
    repositories {
        def ALIYUN_REPO_NEW = 'https://maven.aliyun.com/repository/public'
        def ALIYUN_REPO_OLD = 'http://maven.aliyun.com/nexus/content/groups/public/'
        all { ArtifactRepository repo ->
            if (repo instanceof MavenArtifactRepository) {
                def url = repo.url.toString()
                if (url.startsWith('https://repo.maven.apache.org/maven2/') 
                        || url.startsWith('https://repo.maven.org/maven2') 
                        || url.startsWith('https://repo1.maven.org/maven2') 
                        || url.startsWith('https://jcenter.bintray.com/')){
                    //必须用双引号，不能用单引号
                    project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_REPO_NEW."
                    remove repo
                }
            }
        }
        maven {
            url ALIYUN_REPO_NEW
            url ALIYUN_REPO_OLD
        }
    }
    buildscript {
        repositories {
               def ALIYUN_REPO_NEW = 'https://maven.aliyun.com/repository/public'
            def ALIYUN_REPO_OLD = 'http://maven.aliyun.com/nexus/content/groups/public/'
            all { ArtifactRepository repo ->
                if (repo instanceof MavenArtifactRepository) {
                    def url = repo.url.toString()
                    if (url.startsWith('https://repo.maven.apache.org/maven2/') 
                            || url.startsWith('https://repo.maven.org/maven2') 
                            || url.startsWith('https://repo1.maven.org/maven2') 
                            || url.startsWith('https://jcenter.bintray.com/')) {
                        //必须用双引号，不能用单引号
                        project.logger.lifecycle "Repository ${repo.url} replaced by $ALIYUN_REPO_NEW."
                        remove repo
                    }
                }
            }
            maven {
                url ALIYUN_REPO_NEW
                url ALIYUN_REPO_OLD
            }
        }
    }
}

法2：每个项目单独配置

每个Gradle构建的项目中，在build.gradle做如下配置

repositories {
    //本地仓库，地址是maven本地仓库路径
    mavenLocal()
    //maven私服。此处设置为ali的旧库，地址是url
    maven{ url "http://maven.aliyun.com/nexus/content/groups/public" }
    //阿里云新库
    maven { url "https://maven.aliyun.com/repository/central" }
    maven { url "https://maven.aliyun.com/repository/google" }
    maven { url "https://maven.aliyun.com/repository/gradle-plugin" }
    maven { url "https://maven.aliyun.com/repository/jcenter" }
    maven { url "https://maven.aliyun.com/repository/spring" }
    maven { url "https://maven.aliyun.com/repository/spring-plugin" }
    maven { url "https://maven.aliyun.com/repository/public" }
    maven { url "https://maven.aliyun.com/repository/releases" }
    maven { url "https://maven.aliyun.com/repository/snapshots" }
    maven { url "https://maven.aliyun.com/repository/grails-core" }
    maven { url "https://maven.aliyun.com/repository/mapr-public" }
    maven { url "https://maven.aliyun.com/repository/apache-snapshots" }
    //maven的里程碑版本。有些依赖只能在这里边找到
    maven { url "https://repo.spring.io/milestone" }
    maven { url 'https://repo.spring.io/libs-milestone' }
    //远程仓库,地址是https://repo1.maven.org/maven2
    mavenCentral()
}

不同位置repositories的作用

不同位置的代码示例	说明
build.gradle repositories { … } dependencies { … }	根级别的repositories主要是为了当前项目提供所需依赖包，比如log4j、spring-core等依赖包可从mavenCentral仓库获得。
build.gradle buildscript {     repositories {     …     }     dependencies {     …     } }	buildScript块的repositories主要是为了Gradle脚本自身的执行，可以声明的资源包括依赖项、第三方插件、maven仓库地址等。我在写的一篇博客《尝试Artifactory》中Gradle脚本需要com.jfrog.artifactory插件才能执行成功，而这个插件是从URL为https://plugins.gradle.org/m2/的Maven仓库获得。
build.gradle allprojects {     repositories {     …     }     dependencies {     …     } }	allprojects块的repositories用于多项目构建，为所有项目提供共同所需依赖包。而子项目可以配置自己的repositories以获取自己独需的依赖包。

dependencies{}

简介

dependencies是project一个方法，闭包作为参数。

依赖范围

其他网址：
gradle依赖：implementation 和compile的区别 - 简书Managing Dependencies of JVM Projects（官网文档）

项	说明
compile/testCompile    //deprecated implementation/testImplementation	compile在3.x及之后依然能用。
compileOnly/testCompileOnly	只在编译时有效，不会参与打包
compileClasspath testCompileClasspath	继承自：compile, compileOnly, implementation 继承自：testCompile, testCompileOnly, testImplementation
annotationProcessor	使能注解处理器。比如：lombok就要到。
runtime/testRuntime   //deprecated runtimeOnly/testRuntimeOnly	编译时不会参与，很少用
runtimeClasspath testRuntimeClasspath	继承自：runtimeOnly, runtime, implementation 继承自：testRuntimeOnly, testRuntime, testImplementation
archives	uploadArchives任务会用到
default	继承自：runtimeClasspath

implementation与compile区别

compile： 普通的依赖, 第三方库在 module 中依赖后其他 module 都可以使用该库
implementation：将该依赖隐藏在内部，而不对外部公开。它仅仅对当前的module提供接口。

例如我们当前项目结构如下

LibraryA 中引用了 LibraryC 的库，如果对 LibraryC 的依赖用的是 implementation 关键字。 如下：

dependencies {
    . . . . 
    implementation project（path：'：libraryC'）
}

那么LibraryC 中的接口，仅仅只能给 LibraryA 使用，而我们的 App Module 是无法访问到 LibraryC 提供的接口的，也就是将该依赖隐藏在内部，而不对外部公开。这就是implementation关键字的作用。

建议

在Google IO 相关话题的中提到了一个建议，就是依赖首先应该设置为implementation的，如果没有错，那就用implemention，如果有错，那么使用compile指令，这样会使编译速度有所增快。

那为什么要这么做呢？
答案是： 1. 加快编译速度。2. 隐藏对外不必要的接口。

为什么能加快编译速度呢？

这对于大型项目含有多个Module模块的， 以上图为例，比如我们改动 LibraryC 接口的相关代码，这时候编译只需要单独编译LibraryA模块就行， 如果使用的是api或者旧时代的compile，由于App Module 也可以访问到 LibraryC,所以 App Module部分也需要重新编译。当然这是在全编的情况下。

写法

单个依赖

dependencies {
    //写法1
    compile group: 'ch.qos.logback', name: 'logback-classi', version: '1.2.3'
    //写法2
    compile "ch.qos.logback:logback-classic:1.2.3"
}

多个依赖

dependencies {
    //写法1
    compile "javax.servlet:javax.servlet-api:3.1-b07"
    compile "org.slf4j:slf4j-log4j12:1.7.5"
    //写法2
    compile (  
        "javax.servlet:javax.servlet-api:3.1-b07",  
        "org.slf4j:slf4j-log4j12:1.7.5"
    )  
}

工程依赖

同一个构建中可以建立工程依赖，一个工程的 jar 包可以提供给另外一个工程使用。例如我们可以让 api 工程以依赖于 my_base 工程的 jar 包。这样 Gradle 在构建 api 之前总是会先构建 my_base工程。

api工程的build.gradle文件：

dependencies {
    compile project(':my_base')
}

文件夹下的jar依赖

可以依赖指定文件夹下的jar文件，如，依赖lib目录下所有的jar文件

dependencies {
    implementation fileTree(dir:'lib',includes:['*.jar'])
}

buildscript{}

简介

gradle在执行脚本时，会优先执行buildscript代码块中的内容，然后才会执行剩余的build脚本。

如果你想在脚本中使用一些第三方的插件、类库等，就需要自己手动添加对这些插件、类库的 引用。而这些插件、类库又不是直接服务于项目的，而是支持其它build脚本的运行。所以你应当将这部分的引用放置在buildscript代码块中。

项目实例

buildscript {
    ext {
        springBootVersion = '2.1.1.RELEASE'
        lombokVersion = '1.18.10'
    }
    repositories {
        ...
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}
apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
group = 'abcd'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
ext['springCloudVersion'] = 'Greenwich.RC2'
dependencies {
  //Spring Boot
  compile('org.springframework.boot:spring-boot-starter')
  //Spring MVC
  compile('org.springframework.boot:spring-boot-starter-web')
  compile('org.springframework.boot:spring-boot-starter-aop')
  compile("org.projectlombok:lombok:${lombokVersion}")
}
dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
    }
}

ext{}

其他网址

ext官网文档

简介

ext是Gradle领域对象的一个属性，我们可以将自定义的属性添加到ext对象上，Build.gradle中的其它代码片段可以使用。Gradle的属性可以用此命令打印出来：gradle properties。

ext属性是ExtensionAware类型的一个特殊的属性，ExtentionAware接口的实现类为Project, Settings, Task, SourceSet等，ExtentionAware可以在运行时扩充属性，而这里的ext，就是里面的一个特殊的属性而已。

一般单项目中，ext所在类型为project，即，通过project.${key}可以访问到；root项目中，ext所在类型为rootProject，即，通过rootProject.${key}可以访问到。

gradle.properties跟build.gradle的ext{}有同样作用，见：gradle系列—其他文件_feiying0canglang的博客-CSDN博客

单项目示例

build.gradle

buildscript {
    ext {
        springBootVersion = '2.1.1.RELEASE'
        lombokVersion = '1.18.10'
    }
    repositories {
        ...
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}
apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
group = 'abcd'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
ext['springCloudVersion'] = 'Greenwich.RC2'
dependencies {
    //Spring Boot
    compile('org.springframework.boot:spring-boot-starter')
    //Spring MVC
    compile('org.springframework.boot:spring-boot-starter-web')
    compile('org.springframework.boot:spring-boot-starter-aop')
    compile("org.projectlombok:lombok:${lombokVersion}")
}
dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
    }
}

多项目示例

build.gradle（root项目）

buildscript {
    ...
}
allprojects {
    ...
}
...
ext {
    lombokVersion = '1.18.10'
}

build.gradle（module级项目）

dependencies {
    compile("org.projectlombok:lombok:${rootProject.lombokVersion}")
    //这样也可以
    //compile("org.projectlombok:lombok:${rootProject.ext.lombokVersion}")
}

sourceSets{}

其他网址

The Java Plugin

说明

Java插件默认的目录项目如下：

src/main/java              //Production Java source.
src/main/resources         //Production resources, such as XML and properties files.
src/test/java              //Test Java source.
src/test/resources         //Test resources.
src/sourceSet/java         //Java source for the source set named sourceSet.
src/sourceSet/resources    //Resources for the source set named sourceSet

这个目录是可以修改的，例如：

sourceSets {
    main {
        java {
            srcDirs = ['src/main/java', '../my_base/src/main/java']
        }
        /*resources {
            srcDirs = ['../my_base/main/resources']
        } */
    }
}

这样修改之后，把base（根项目）放到子项目同级路径之下，子项目就可以包含根项目了。

其他

allprojects{}

subprojects{}

configurations{}

artifacts{}

publishing{}