作者： Yann

来源：原力注入

Gradle 是一种构建工具，它抛弃了基于XML的构建脚本，取而代之的是采用一种基于 Groovy（现在也支持 Kotlin）的内部领域特定语言。

Gradle特点

1. Gradle是很成熟的技术，可以处理大规模构建

2. Gradle对多语言、多平台支持性更好

3. Gradle关注在构建效率上

4. Gradle发布很频繁，重要feature开发计划透明化

5. Gradle社区很活跃，并且增加迅速

安装Gradle

• 从 官网 (https://gradle.org/install/)下载二进制文件。

• 解压Zip文件，加入环境变量（在PATH中加入GRADLE_HOME/bin目录）

如果在安装过程中遇到问题，可以进一步查看官方的安装指南(https://gradle.org/install/)。最后验证一下 Gradle 是否工作正常

1. gradle -v

2. ------------------------------------------------------------

3. Gradle 4.2.1

4. ------------------------------------------------------------

5. Build time:   2017-10-02 15:36:21 UTC

6. Revision:     a88ebd6be7840c2e59ae4782eb0f27fbe3405ddf

7. Groovy:       2.4.12

8. Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015

9. JVM:          1.8.0_162-ea (Oracle Corporation 25.162-b01)

10. OS:           Mac OS X 10.13.5 x86_64

Gradle快速体验

初始化一个项目

• 创建一个 demo 目录

1. ❯ mkdir gradle-demo

• 初始化 Gradle 项目

1. ❯ gradle init

2. Starting a Gradle Daemon (subsequent builds will be faster)

3. BUILD SUCCESSFUL in 3s

4. 2 actionable tasks: 2 executed

Gradle目录结构

我们看看上一步我们生成了什么文件

├── build.gradle  ❶├── gradle│   └── wrapper│       ├── gradle-wrapper.jar    ➋│       └── gradle-wrapper.properties  ➌├── gradlew    ➍├── gradlew.bat  ➎└── settings.gradle  ➏

❶ 当前项目的配置脚本

➋ Gradle Wrapper 的执行jar包（后续介绍）

➌ Gradle Wrapper 的配置文件

➍ Gradle Wrapper Unix 系执行脚本

➎ Gradle Wrapper Windows 系执行脚本

➏ 项目脚本设置

创建一个Task

Gradle提供了用于通过基于Groovy或Kotlin的DSL创建和配置。项目包括一组Task，每个Task执行一些基本操作。

• 创建一个目录叫 src

• 在src目录创建一个 myfile.txt

• 在构建文件中定义一个名为Copy的类型 Task ，该任务将src目录复制到名为dest的新目录

groovy代码：

1. task copy(type: Copy, group: "Custom", description: "Copies sources to the dest directory") {

2.    from "src"

3.    into "dest"

4. }

kotlin代码：

1. tasks.create<Copy>("copy") {

2.    description = "Copies sources to the dest directory"

3.    group = "Custom"

4.    from("src")

5.    into("dest")

6. }

group 和 description 是自定义的任意值。现在让我们执行这个 task

1. ❯ ./gradlew copy

2. > Task :copy

3. BUILD SUCCESSFUL in 0s

4. 1 actionable task: 1 executed

再一次 ls 我们就可以看见 gradle 为我们创建了一个新的 dest 目录并且将 文件复制进去。

Gradle Task

在Gradle中，有两个基本概念：项目和任务。

• 项目是指我们的构建产物（比如Jar包）或实施产物（将应用程序部署到生产环境）一个项目包含一个或多个任务。

• 任务是指不可分的最小工作单元，执行构建工作（比如编译项目或执行测试）。

在项目目录中的 build.gradle 指定了一个项目和它的任务。

Task执行顺序

任务可能依赖于其他任务，或者可能被安排为始终在另一个任务之后运行。

1. project('projectA') {

2.    task taskX(dependsOn: ':projectB:taskY') {

3.        doLast {

4.            println 'taskX'

5.        }

6.    }

7. }

8. project('projectB') {

9.    task taskY {

10.        doLast {

11.            println 'taskY'

12.        }

13.    }

14. }

1. > gradle -q taskX

2. taskY

3. taskX  // taskx 在 y 之后

我们可以用 dependsOn 让我们的 Task 有顺序的运行起来。

Gradle插件

看到这里，如果每一件事情我们都需要写 Task 岂不是会累死，而且很多功能是可以被复用的，所以Gradle 提供一个 插件 功能，Gradle 默认就内置了大量的插件，比如在 base 中有一系列的功能。

groovy代码：

1. plugins {

2.    id "base"

3. }

kotlin代码：

1. plugins {

2.    id("base")

3. }

这个时候我们就可以利用一些额外的 Task，举个例子，我们要把一个目录中的东西都打成一个 ZIP 压缩包。

groovy代码：

1. task zip(type: Zip, group: "Archive", description: "Archives sources in a zip file") {

2.    from "src"

3.    setArchiveName "basic-demo-1.0.zip"

4. }

kotlin代码：

1. tasks.create<Zip>("zip") {

2.    description = "Archives sources in a zip file"

3.    group = "Archive"

4.    from("src")

5.    setArchiveName("basic-demo-1.0.zip")

6. }

Gradle 的设计理念是

• 在项目中添加新任务

• 为新加入的任务提供默认配置，这个默认配置会在项目中注入新的约定（如源文件位置）。

• 加入新的属性，可以覆盖插件的默认配置属性。

• 为项目加入新的依赖。

Gradle Java

Gradle 内置了 Java 插件，Java插件将Java编译以及测试和捆绑功能添加到项目中。它是许多其他Gradle插件的基础。如果我们需要使用 Java 插件 修改 build.gradle

1. plugins {

2.    id 'java'

3. }

一旦导入了 Java 插件，就会有一系列的默认的配置值，并且会导入大量的 Task。

Task	含义
compileJava(type: JavaCompile)	Java 编译
processResources(type: Copy)	拷贝 Resources 资源
classes(type: Task)	组装 Java 类
compileTestJava(type: JavaCompile)	Java Test 编译
processTestResources(type: Copy)	拷贝 Test Resources 资源
testClasses(type: Task)	组装 Test 类
jar(type: Jar)	合成Jar包
javadoc(type: Javadoc)	生成 doc 文档
test(type: Test)	运行测试
uploadArchives(type: Upload)	上传 jar 到仓库
clean(type: Delete)	clean

我们从这些 Task 名字就可以看出来他们分别作作了， 和其他的设计理念类型，在 Task 也会嵌入一些生命周期，其实原理也就是我们之前看的执行顺序。

资源：Gradle插件仓库

Gradle依赖管理

先盗取一张官方的图。

和 Maven 类似，Gradle 也会将依赖缓冲在本地中，方便在无网的环境使用，和依赖管理相关的有两个参数，举个例子。

1. repositories {

2.    mavenCentral() // 定义仓库

3. }

4. dependencies {

5.    compile 'org.springframework:spring-web:5.0.2.RELEASE' // 定义依赖

6. }

Gradle支持以下仓库格式：

• Ivy仓库

• Maven仓库

• Flat directory仓库

lvy仓库

我们可以通过URL地址或本地文件系统地址，将Ivy仓库加入到我们的构建中。

1. repositories {

2.    ivy {

3.        url "http://ivy.petrikainulainen.net/repo"

4.    }

5. }

6. //或者是本地

7. repositories {

8.    ivy {      

9.        url "../ivy-repo"

10.    }

11. }

Maven仓库

1. repositories {

2.    maven {

3.        url "http://maven.petrikainulainen.net/repo"

4.    }

5. }

在加入Maven仓库时，Gradle提供了三种“别名”供我们使用，它们分别是

• mavenCentral()别名，表示依赖是从Central Maven 2 仓库中获取的。

• jcenter()别名，表示依赖是从Bintary’s JCenter Maven 仓库中获取的。

• mavenLocal()别名，表示依赖是从本地的Maven仓库中获取的。

Flat Directory仓库

1. repositories {

2.    flatDir {

3.        dirs 'lib'

4.    }

5. }

6. //多个仓库

7. repositories {

8.    flatDir {

9.        dirs 'libA', 'libB'

10.    }

11. }

依赖管理

在配置完项目仓库后，我们可以声明其中的依赖，首先 Java 插件指定了若干依赖配置项

• compile 配置项中的依赖是依赖必须的。

• runtime 配置项中包含的依赖在运行时是必须的。

• testCompile 配置项中包含的依赖在编译项目的测试代码时是必须的。

• testRuntime 配置项中包含的依赖在运行测试代码时是必须的。

在 Gradle 最新版本中更是增加

• implementation 配置项中的实现类

• api 配置项中的暴露API

1. dependencies {

2.    api 'commons-httpclient:commons-httpclient:3.1'

3.    implementation 'org.apache.commons:commons-lang3:3.5'

4. }

声明项目依赖

最普遍的依赖称为外部依赖，这些依赖存放在外部仓库中。一个外部依赖可以由以下属性指定：

• group属性指定依赖的分组（在Maven中，就是groupId）

• name属性指定依赖的名称（在Maven中，就是artifactId）

• version属性指定外部依赖的版本（在Maven中，就是version）

1. dependencies {

2.    compile group: 'foo', name: 'foo', version: '0.1'

3. }

4. // 我们也可以合并到一起去

5. dependencies {

6.    compile 'foo:foo:0.1'

7. }

声明项目文件依赖

我们如何依赖本地的一些 jar 呢，正确的操作是如下

1. dependencies {

2.    compile files('libs/commons-lang.jar', 'libs/log4j.jar')

3. }

声明依赖排除项目

我们都知道在 Maven中我们有

1.    <dependency>

2.        <groupId>sample.ProjectB</groupId>

3.        <artifactId>Project-B</artifactId>

4.        <version>1.0-SNAPSHOT</version>

5.        <exclusions>

6.            <exclusion>

7.                <groupId>log4j</groupId>

8.                <artifactId>log4j</artifactId>

9.            </exclusion>

10.        </exclusions>

11.    </dependency>

而在 Gradle 中，我们可以这么做。

1. compile('com.example.m:m:1.0') {

2.    exclude group: 'org.unwanted', module: 'x

3. }

Gradle与Kotlin

我们想要在 gradle 中增加 kotlin 非常的简单，仅仅需要在 build.gradle 增加

1. plugins {

2.     id "org.jetbrains.kotlin.jvm" version "x.x.xx" // 增加插件

3. }

4. dependencies {

5.  compile "org.jetbrains.kotlin:kotlin-stdlib:x.xx.xx" // 增加依赖

6. }

大功告成，对了，默认的 Kotlin 的源码路径是 src/main/kotlin, 测试源码是 src/text/kotlin 如果需要修改可以使用

1. sourceSets {

2.    main.kotlin.srcDirs += 'src/main/myKotlin'

3.    main.java.srcDirs += 'src/main/myJava'

4. }

其他

Gradle Wrapper

Gradle Wrapper 做了三件事情

• 解析参数传入 gradlew

• 安装正确的 Gradle 版本

• 调用 Gradle 执行命令

Ops，Gradle Wrapper 为什么还需要安装 Gradle，我们在用 Maven 都知道，我们需要自己先安装好一个 Maven版本，因为 Maven 发展多年，现在已经稳定，已经不存在很多个版本并存的现状了，但是我们依然需要去在每个机器上去安装，那我什么我们不能在自己的 构建脚本 中就指定我们的构建工具呢？所以我们在 wrapper/gradle-wrapper.properties 中就可以发现 distributionUrl=https\://services.gradle.org/distributions/gradle-4.2.1-bin.zip 这里也就是定义了我们的gradle所使用的版本。

Gradle In Real World

1. // 定义一堆基础插件

2. apply plugin: 'java'

3. apply plugin: 'maven'

4. apply plugin: "jacoco"

5. apply plugin: 'checkstyle'

6. apply plugin: 'pmd'

7. apply plugin: 'findbugs'

8. apply plugin: 'eclipse'

9. apply plugin: 'idea'

10. // 定义项目属性

11. group = 'Common'

12. version = '1.0.0'

13. description = """Giant common library"""

14. // 定义依赖仓库

15. repositories {

16.    mavenCentral()

17. }

18. // 额外增加source path

19. sourceSets {

20.    main {

21.        resources {

22.            srcDir "src/main/profiles/${profile}"

23.        }

24.    }

25. }

26. // project依赖

27. dependencies {

28.    compile 'ch.qos.logback:logback-core:1.0.13'

29.    compile 'ch.qos.logback:logback-classic:1.0.13'

30.    compile 'ch.qos.logback:logback-access:1.0.13'

31.    compile 'commons-io:commons-io:2.0.1'

32.    compile 'commons-lang:commons-lang:2.6'

33.    compile 'joda-time:joda-time:1.6.2'

34.    compile 'org.testng:testng:6.8.7'

35.    compile 'com.googlecode.jmockit:jmockit:1.5'

36.    ...

37. }

38. // task配置

39. checkstyle {

40.    ignoreFailures = true

41.    sourceSets = [sourceSets.main]

42. }

43. findbugs {

44.    ignoreFailures = true

45.    sourceSets = [sourceSets.main]

46. }

47. pmd {

48.    ruleSets = ["basic", "braces", "design"]

49.    ignoreFailures = true

50.    sourceSets = [sourceSets.main]

51. }

52. jacocoTestReport {

53.    reports {

54.        xml.enabled true

55.        html.enabled true

56.        csv.enabled false

57.    }

58.    sourceSets sourceSets.main

59. }

60. tasks.withType(Compile) {

61.    options.encoding = "UTF-8"

62. }

63. test {

64.    useTestNG()

65.    jacoco {

66.        excludes = ["org.*"]

67.    }

68. }

Gradle常用指令

枚列所有可用任务

1. ❯ gradle tasks

2. ------------------------------------------------------------

3. All tasks runnable from root project

4. ------------------------------------------------------------

5. Archive tasks

6. -------------

7. zip - Archives sources in a zip file

8. Build tasks

9. -----------

10. assemble - Assembles the outputs of this project.

11. build - Assembles and tests this project.

12. clean - Deletes the build directory.

构建配置属性

1. ❯ gradle properties

显示构建详情

在 build.gradle 设置

1. logging.level = LogLevel.DEBUG

或者在运行的

1. ❯ gradle build --stacktrace

参考资料&推荐文档

• Gradle入门教程(http://blog.jobbole.com/71999/)

• Gradle介绍(https://www.jianshu.com/p/00d5469e25e7)

• 官方教材(https://guides.gradle.org/creating-new-gradle-builds/)

-END-

 近期热文：

• JIRA配置手册 （3）：字段和界面

• JIRA配置手册 （2）：工作流

• JIRA配置手册 （1）：问题类型管理

• HashMap? ConcurrentHashMap? 相信看完这篇没人能难住你！

• 你真的了解lambda吗？一文让你明白lambda用法与源码分析

• 程序员格斗指南

• 设计RPC接口时，你有考虑过这些吗？

• 阿里巴巴硅谷 Istio 专家解读Istio 1.0 发布

• 如何用图像识别玩忍术？

• 来自95后的天池中间件大赛总结

• 为Spring Cloud Config插上管理的翅膀

• Spring Cloud Config采用Git存储时两种常用的配置策略

• Hystrix降级逻辑中如何获取触发的异常？

• 重磅剧透！阿里巴巴计划开源 Nacos，为Dubbo生态发展铺路

• Spring Cloud Config采用数据库存储配置内容

• 你可能会忽略的 Git 提交规范

• SpringBoot应用部署于外置Tomcat容器

关注我

点击“阅读原文”，看本号其他精彩内容