Gradle初体验 - 码农教程

Windows下安装Gradle

Gradle官方的安装文档，地址如下：

https://gradle.org/install/

1.Gradle是基于JVM的，所以首先需要确保已经安装好了JDK，而我这里是已经安装好的了，官方文档中表示目前最新版本的Gradle需要的JDK环境是1.7以上。我这里用的是jdk10：

2.到官网上下载Gradle，下载地址如下，我这里下载的是二进制安装包：

https://gradle.org/next-steps/?version=4.10&format=bin

3.下载好后，解压后目录如下：

4.配置环境变量：

在path中增加这个环境变量：

5.执行gradle查看版本命令，确认安装成功：

CentOS7下安装Gradle

1.同样的，需要确认安装好了JDK环境，我这里CentOS下使用的JDK版本是1.8：

[root@01server ~]# java -version
java version "1.8.0_171"
Java(TM) SE Runtime Environment (build 1.8.0_171-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.171-b11, mixed mode)
[root@01server ~]#

2.到官网上获取下载链接，然后下载并解压Gradle，过程如下：

[root@01server ~]# cd /usr/local/src/
[root@01server /usr/local/src]# wget https://downloads.gradle.org/distributions/gradle-4.10-bin.zip
[root@01server /usr/local/src]# unzip gradle-4.10-bin.zip # 解压
[root@01server /usr/local/src]# mv gradle-4.10 /usr/local/gradle  # 我这里习惯放到/usr/local下

3.配置环境变量：

[root@01server ~]# vim /etc/profile  # 在文件末尾添加如下内容
export GRADLE_HOME=/usr/local/gradle
export PATH=$PATH:$GRADLE_HOME/bin
[root@01server ~]# source /etc/profile  # 使配置生效
[root@01server ~]#

4.执行gradle查看版本命令，确认安装成功：

groovy理论介绍

Groovy简介：

Groovy是用于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，即可以用于面向对象编程，又可以用作纯粹的脚本语言。使用该语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。

Groovy特点：

Groovy完全兼容Java的语法
分号是可选的
类、方法默认是public的
编译器给属性自动添加getter/setter方法
属性可以直接用点号获取
最后一个表达式的值会被作为返回值
== 等同于Java的equals()，并且不会有空指针异常

Groovy特性的高级特性：

支持assert语句
支持可选类型定义
可选的括号
支持三种字符串
拥有集合API
支持闭包

构建脚本介绍

什么是构建块：

Gradle构建中的两个基本概念是项目（project）和任务（task），每个构建至少包含一个项目，项目中包含一个或多个任务。在多项目构建中，一个项目可以依赖于其他项目；类似的，任务可以形成一个依赖关系图来确保他们的执行顺序

什么是项目（project）：

一个项目代表一个正在构建的组件（比如一个jar文件），当构建启动后，Gradle会基于build.gradle实例化一个org.gradle.api.Project类，并且能够通过project变量使其隐式可用。项目（project）主要的三个属性分别是group、name、version，就好比于maven中的groupId、artifactId、version，是作为组件的坐标存在的项目（project）比较重要的方法分别是plugins、repositories、dependencies、task，plugins用于添加插件，dependencies用于依赖管理，repositories用于指定仓库，task用于声明项目中的任务

什么是任务（task）：

任务（task）对应org.gradle.api.Task，主要包括任务动作和任务依赖。任务动作定义了一个最小的工作单元，可以定义依赖于其他任务、动作序列和执行条件任务（task）比较重要的方法分别是dependsOn、doFirst、doLast ，dependsOn用于声明任务依赖，任务也是一个动作列表，而doFirst用于在任务列表最前面添加一个动作，doLast则是用于在任务列表末尾添加一个动作，其中doLast可以简写为 <<

项目和任务的关系图：

groovy与java比较

本小节我们用一个简单的demo项目，来直观的演示一下Java和groovy在语法上的区别。首先创建一个Gradle工程：

自定义GroupId和ArtifactId：

选择本地的Gradle：

项目创建好后，打开Gradle控制台：

我们先来使用Java语法进行编写，代码及运行结果如下：

如果使用groovy语法进行编写的话，将会简单很多。代码及运行结果如下：

groovy中常用的高级特性写法示例：

// 1.可选类型定义
def version = 1

// 2.assert语句
assert version == 1

// 3.括号是可选的
println(version)
println version

// 4.字符串
// 单引号是纯粹的字符串
def s1 = 'demo'
// 双引号的字符串可以插入变量
def s2 = "current version is ${version}"
// 多行字符串
def s3 = '''this
is a
demo'''

// 5.集合API
// 默认的类型是ArrayList
def list = ['a', 'b', 'c']
// list添加元素
list << 'd'

// 默认的类型是LinkedHashMap
def map = ['ant': 2000, 'maven': 2004]
// map添加元素
map.gradle = 2009

// 6.闭包
// 定义有参数的闭包
def c1 = {
    v ->
        println v
}
// 定义无参数的闭包
def c2 = {
    println 'hello'
}
// 定义使用闭包的方法
def method1(Closure closure) {
    closure('param')
}

def method2(Closure closure) {
    closure()
}

//调用使用闭包的方法，并将闭包对象传递进去
method1(c1)
method2(c2)

我们利用以上所提到的高级特性语法来写一个简单的构建脚本，代码如下：

// 在构建脚本中，默认都是有个Project实例的

// plugins 是Project里的方法
plugins {
    id 'java'
}

// version是Project里的属性
version = '0.1'

// repositories是Project里的方法，用于仓库管理，这里使用了有参数的闭包进行调用
repositories {
    mavenCentral()
}

// dependencies是Project里的方法，用于依赖管理，这里同样使用了有参数的闭包进行调用
dependencies {
    compile 'commons-codec:commons-codec:1.6'
}

以上的代码是一个比较常见的构建脚本，但是写习惯Java语言的话，可能看不太懂，因为都忽略了括号。若不忽略括号，则代码如下：

plugins({
    id 'java'
})

version = '0.1'

repositories({
    mavenCentral()
})

dependencies({
    compile 'commons-codec:commons-codec:1.6'
})

如果能够完全看懂以上的代码，就代表已经掌握了groovy的基本语法了。

使用Gradle将项目打包

本小节我们来使用Gradle将项目打包为jar包，首先按上一小节所演示的，新建一个Gradle项目，默认IDEA会帮我们生成构建脚本，即项目根目录下的build.gradle文件，然后随便在工程里创建个类写些代码。如下：

点击右边的Gradle进入控制台，点击jar进行打包：

生成的jar包会存放在build目录下：

同样的，我们可以使用Gradle将项目打包为war包，只需要在构建脚本中，增加打war包的插件即可：

plugins {
    id 'java'
    id 'war'
}

这时Gradle的控制台，就会多出一个war插件，点击这个war，即可将项目打成war包：

生成的war包也是会存放在build目录下：

自定义任务

我们可以在构建脚本中自定义一些任务，例如我的工程里没有自动创建目录的话，就可以编写自定义任务让Gradle帮你创建目录。在build.gradle构建脚本中，编写如下内容：

// 定义一个闭包，用于完成目录的创建
def createDir = {
    path ->
        File dir = new File(path)
        if (!dir.exists()) {
            dir.mkdirs()
        }
}

// 定义makeJavaDir任务
task makeJavaDir() {
    def paths = ['src/main/java', 'src/main/resources', 'src/test/java', 'src/test/resources']
    // 在任务列表最前面添加动作
    doFirst {
        paths.forEach(createDir)
    }
}

// 定义makeWebDir任务
task makeWebDir() {
    // 依赖makeJavaDir任务
    dependsOn 'makeJavaDir'
    def paths = ['src/main/webapp', 'src/test/webapp']
    // 在任务列表末尾添加动作
    doLast {
        paths.forEach(createDir)
    }
}

此时，我的工程的src目录下是没有任何目录的：

点击执行makeWebDir任务：

目录创建成功：

构建的生命周期

Gradle构建的生命周期分为三个阶段：

初始化阶段：主要初始化项目，有哪些项目需要参于构建
配置阶段：主要生成Task的依赖关系和执行图
执行阶段：执行Task的动作代码

依赖管理

大部分时候，我们使用构建工具都是使用其中的依赖管理功能。依赖管理概述：

几乎所有基于JVM的软件项目都需要依赖外部类库来重用现有的功能。自动化的依赖管理可以明确依赖的版本，可以解决因传递性依赖带来的版本冲突。一个jar包属于一个工件，在gradle中，工件在仓库的坐标是group、name以及version。而工件存放在仓库里，在gradle中常用的仓库有mavenLocal、mavenCentral、jcenter，其中mavenCentra和jcenter是中央仓库，mavenLocal则是本地仓库

关于依赖的传递性：

B依赖A，如果C依赖B，那么C依赖A

关于依赖阶段：

依赖阶段分为两个阶段，即编译阶段和运行阶段，而测试时也是分为这两个阶段。编译阶段所依赖的jar包，在运行阶段也会依赖。不同的阶段会有不同的标识，如下：
- compile：编译阶段，runtime：运行阶段
- testCompile：测试编译阶段，testRuntime：测试运行阶段

每个依赖阶段的关系图：

gradle特性之一是自动化依赖管理，通过下图，我们可以简单的看到自动化依赖管理过的程：

我们来看看如何添加依赖，例如我现在需要添加logback的依赖，首先到maven中央仓库上，复制logback的gradle依赖：

然后粘贴到 dependencies 方法里就完成了依赖的添加，如下：

dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.12'
    // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
    compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.3'
}

注：如果发生依赖版本冲突，gradle默认可以解决版本冲突的问题，当出现两个不同版本的依赖时，gradle默认会使用最高版本那个

如果我们需要到多个仓库上查找依赖的时候，可以在 repositories 方法里添加仓库，gradle会按照配置先后去仓库里查找jar包，如下：

repositories {
    // 会按先后顺序去查找jar包
    mavenLocal()
    mavenCentral()
}

如果有私服仓库的话，也是在 repositories 方法里进行配置，只不过需要指定一下url地址，如下：

repositories {
    // 一般会把私服仓库配置在最前面
    maven{
        url ''
    }
    mavenLocal()
    mavenCentral()
}

自动化测试

概述：

一些开源的测试框架比如Junit、TestNG能够帮助你编写可复用的结构化的测试用例，为了运行这些测试用例，你要编译他们，就像编译源代码一样。测试代码的作用仅仅用于测试的情况，不应该被发布到生产环境中，需要把源代码和测试代码分开来

Gradle测试目录结构：

Gradle和Maven一样，能够自动进行测试用例的发现，测试发现规则如下：

任何继承自junit.framework.TestCase或groovy.util.GroovyTestCase的类
任何被@RunWith注解的类
任何至少包含一个被@Test注解的类

由于Gradle和Maven的测试很类似，我这里就不进行演示了