Gradle 快速入门

来源：互联网发布：网络作家吧编辑：程序博客网时间：2024/05/21 14:42

1 简介

正如标题所写的那样，本文都是我的一些经验之谈，旨在让读者能够以最快的速度上手Gradle，少走弯路。首先，我并不是资历很深的程序员，所以那些关于Ant和Maven的各种比较我并不感兴趣，甚至我曾经有这么一个概念Ant=Eclipse而Maven=IDEA，如今想来也是醉了。我真正接触到的构建工具应该就是Gradle了，这也许是个巧合吧，在2013年的时候Google发布了使用Gradle作为构建工具的Android Studio，这对于当时十分厌恶丑陋的Eclipse又追求先进事物的我来说真是一个十分激动人心的事情。不久之后我就下载了Android Studio 0.3，并且开始学者使用这个陌生又酷炫（它真的Darcula主题真的很酷）集成开发工具，于是我开始接触Gradle，开始遇到如何导入Library Project、如何以正确的姿势翻墙、如何在Android Studio上打包jar等问题，这一路走来确实坎坷，让我对Gradle又爱又恨，Gradle真的很强大，同时入门的门槛也较高。

1.1 什么是构建工具

项目编译
如果你有一个项目，项目中有很多的包和Java文件，如果你想把这个项目打包成一个jar，你该怎么做？最坑爹的方式恐怕就是通过Java命令行把文件一个个编译成class文件，然后打包成jar了，这样的做法估计编译10个class文件，打包一次jar就可以让你抓狂了。于是构建工具就出现了，你所要做的就是写好配置文件，然后运行构建工具，接下来构建工具就会自动帮你编译所有的文件，并打包成jar文件。

依赖管理
你还在使用Ctrl+C和Ctrl+V的方式把你项目所需的jar包一个个拷贝到libs目录下吗？每次项目依赖的jar包有更新的时候，你又要去手动替换？当你拷贝了一个依赖库到项目里，赫然发现这个库又依赖了其他库，这时候你又要去拷贝其他库，是不是觉得很坑爹？使用构建工具吧，简单地几句配置信息就搞定了，从此你就不在需要去做那些无聊的体力活了。

项目模块化
构建工具的另一个功能就是能够帮助你将项目模块化，也许你会问一个包不就是一个模块了吗？在我看来，真正的模块化应该是一个完全独立的、可以快速移植的小程序，对于Android项目来说其中会包含各种布局文件和素材等，如果你以包作为模块，结果就是在移植的时候你还要去手动拷贝资源文件（这很容易丢三落四），通过构建工具，你可以将一个功能模块完全独立出来，各个模块之间是一种依赖关系。项目的模块化同时也在逼迫着你设计出高内聚低耦合的程序。

1.2 Gradle的特性

Gradle使用Groovy作为脚本语言的构建工具，而Groovy是基于JVM的动态语言，它对Java有着先天的兼容性，你甚至可以在构建脚本中编写Java程序。
Gradle不像Ant和Maven那样使用xml编写脚本，它使用的是Groovy，这意味着你在编写脚本的时候更像是在写程序，而不是编写充满尖括号又不好阅读xml文件。
Gradle像Maven一样遵循约定优于配置的原则，也就是说你的项目只要按照标准约定搭建起来，你只需要做简单的配置就可以构建你的项目了。
Gradle支持现有的Maven仓库，所以你可以很方面地利用Maven上的所有库。
Gradle支持依赖传递，也就是说当A库依赖B库的时候，你只需要引用A库就可以了，Gradle会自动帮你依赖B库。

2 安装Gradle

Gradle的安装很简单，首先你要到Gradle的官网下载Gradle压缩包，这里我们以最新版的Gradle2.5为例，说明如何安装Gradle。

2.1 解压

首先你需要把下载下来的Gradle压缩包解压到任意位置，把Gradle安装在哪里完全取决于你，例如：

Linux系统可以解压到/home/xxx/gradle-2.5目录下。
Windows系统可以解压到C://gradle-2.5目录下。

2.2 配置环境变量

接下来我们需要在环境变了中配置Gradle，熟悉Java的人对于环境变量的配置应该得心应手了，因为这跟配置Java环境变量如出一辙。

Linux系统可以在/home/xxx/.profile中配置环境变量，把/home/xxx/gradle-2.5赋值给GRADLE_HOME，把/home/xxx/gradle-2.5/bin目录加入到PATH中。
```
export GRADLE_HOME=/home/xxx/gradle-2.5export PATH=${GRADLE_HOME}/bin:$PATH
```
Windows系统可以右键我的电脑，选择属性进行环境变量配置，把C://gradle-2.5赋值给GRADLE_HOME，把%GRADLE_HOME%/bin目录加入到path中。

2.3 验证安装是否成功

完成前面两个步骤之后，你可以打开命令行窗口输入gradle -v命令，如果安装成功你会看到类似如下的信息：

------------------------------------------------------------Gradle 2.5------------------------------------------------------------Build time:   2015-07-08 07:38:37 UTCBuild number: noneRevision:     093765bccd3ee722ed5310583e5ed140688a8c2bGroovy:       2.3.10Ant:          Apache Ant(TM) version 1.9.3 compiled on December 23 2013JVM:          1.7.0_79 (Oracle Corporation 24.79-b02)OS:           Linux 3.19.0-23-generic amd64

3 牛刀小试

接下来我们就用一个很简单的Demo来小试一下Gradle，我们会创建一个Java项目并取名为HelloGradle，该项目会在main函数中打印一句话Hello Gradle，我所使用的是Linux操作系统。

3.1 项目结构

我们先创建整个项目的目录结构，由于Gradle遵循约定优于配置的原则，所以我们会创建一个标准的Gradle项目结构，这样Gradle就能过几乎不做任何配置就可以识别我们的项目，整个项目的结构如下所示：

HelloGradle    src/main/java    src/main/resources

src/main/java目录是我们存放源码的地方。
src/main/resources目录是我们存放资源文件的地方。

3.2 编写代码

接着我们在src/main/java目录下创建一个类并取名为Main.java，然后编写如下所示的代码：

public class Main {    public static void main(String[] args)  {        System.out.println("Hello Gradle");    }}

3.3 编写构建脚本

我们需要在项目的根目录，也就是HelloGradle目录下创建一个名为build.gradle的脚本文件，并且在文件中配置我们的项目，Gradle就会根据配置信息帮我们构建整个项目，配置信息如下所示：

build.gradle：

apply plugin: 'java'

没错，就这么一句话就可以了，这就是约定优于配置的威力所在，因为我们整个项目都是按照标准约定搭建的，所以Gradle能够根据约定识别出我们的项目，进而执行构建任务。

3.4 构建项目

最后，我们打开命令号窗口，定位到项目的跟目录下，然后输入gradle build命令，然后我们就会看到Gradle打印出如下信息：

:compileJava:processResources UP-TO-DATE:classes:jar:assemble:compileTestJava UP-TO-DATE:processTestResources UP-TO-DATE:testClasses UP-TO-DATE:test UP-TO-DATE:check UP-TO-DATE:buildBUILD SUCCESSFULTotal time: 3.7 secs

然后我们会在HelloGradle目录下看到几个新的目录，分别是.gradle和build目录，我们可以在build/classes/main目录下找到Gradle编译好的class文件，在build/libs目录下找打Gradle打包好的jar文件。我们可以进入build/classes/main目录执行java Main命令，就会看到打印出Hello Gradle。怎么样，使用Gradle构建一个Java项目是不是很简单，可能有人会说用IDE比这个还简单，我会告诉你当Gradle和IDE结合在一起的时候，会让项目构建更加简单和高效。

4 Gradle基础

想要使用Gradle作为你的项目构建利器，你必须先学会Gradle的脚本知识，这一章我们会讲解Gradle的一些脚本基础，旨在让你能够快速的入门。

4.1 脚本文件（build.gradle）

项目与脚本文件

当我们执行gradle命令的时候，Gradle会在你执行命令的目录下寻找一个名为build.gradle的文件，这个文件就是Gradle的脚本文件，我们所有的脚本、配置信息都写在这里面，并且一个目录下只能有一个脚本文件。下面是一个简单的例子，我们创建一个项目取名为HelloGradle：

HelloGradle    build.gradle    src/main/java/Main.java

实际上，一个脚本文件就代表着一个项目，所以如果你在某个目录下创建一个脚本文件，Gradle就会把该目录作为一个项目的根目录。对于多项目构建的情况下，你可能会在主项目下创建多个子项目，这时候你应该在一个项目（主项目和子项目）的跟目录下创建一个脚本文件，并且通过settings.gradle文件配置主项目与子项目之间的关系，在后面的内容中我们会对多项目构建进行更多的说明，所以这里大家可以先无视settings.gradle的存在。下面是一个简单的例子，我们创建一个主项目名为Project1，在主项目下面有两个子项目分别命名为Project2和Project3，我们通过build.gradle让Gradle识别出每一个项目，并且在settings.gradle文件中将Project2和Project3声明为Project1的子项目：

Project1    build.gradle    settings.gradle    Project2        build.gradle        src/main/java        src/main/resources    Project3        build.gradle        src/main/java        src/main/resources

脚本块

一个build.gradle文件由若干个指定的脚本块组成，每一个脚本块都代表着不同的功能，Gradle内置了好几种脚本块供我们使用，并且脚本块可以嵌套使用，详情可以查看官方文档，我们来看一段脚本：

buildscript {    repositories {        jcenter()    }    dependencies {        classpath 'com.android.tools.build:gradle:1.2.3'    }}allprojects {    repositories {        jcenter()    }}

这是一段配置Android项目的脚本，在build.gradle中通过buildscripte脚本块指定脚本文件所使用的插件来源和远程仓库，通过repositories脚本块指定了所使用的远程仓库，通过dependencies指定了相关的依赖关系，通过allprojects脚本块为所有子项目指定配置信息。

4.2 项目（project）

在Gradle中，每一个项目都会有个名为project的实例与之对应，而之前我们说过一个脚本文件就代表着一个项目，所以实际上我们在脚本文件中编写的脚本最后都是委托给project对象处理的，即project和build.gradle是一对一的关系。我们可以在脚本文件中通过该实例访问项目脚本的属性、方法和任务，例如project.name可以访问项目的名称、project.version可以访问项目的版本名称、project.rootProject可以访问该项目的父项目等，总之project几乎包含了所有脚本的内容。

在编写脚本的时候，虽然在脚本中直接写属性名称是可以的，但是通过project引用属性名称能够让你的脚本更加清晰易懂，例如project.name会比name更容易让人知道这是一个项目的名称。

4.3 属性（property）

在Gradle中，属性分为两种，一种是系统属性，它可以被JVM使用，而另一种我们姑且称之为项目属性，它用于项目的配置。

4.3.1 系统属性

系统属性是可以直接被JVM所使用的，我们可以用它来设置JVM的相关参数，下面按照读取属性的优先级由高到低的方式列出来所有定义方式：

通过命令行执行gradle -D name=value方式定义系统属性，例如gradle -D org.gradle.java.home=/jdk定义了Gradle运行时所依赖的Java路径。
在用户目录下创建gradle.properties文件，然后以systemProp.name=value方式定义系统属性，例如用户目录为/home/jerry，那么我们就在该目录下创建gradle.properties文件，并且在文件内定义org.gradle.java.home=/jdk，这样Gradle所以需的Java路径就被定义了。
在项目目录下创建gradle.properties文件，然后以systemProp.name=value方式定义系统属性，例如项目目录为/HelloGradle，那么我们就在该目录下创建gradle.properties文件，并且在文件内定义org.gradle.java.home=/jdk，这样Gradle所以需的Java路径就被定义了。

4.3.2 项目属性

在开发项目的时候我们经常会遇到各种项目属性的配置，例如项目名称、项目版本、打包路径、渠道名称等等，对于这些属性，Gradle为我们提供了多种方式来定义，下面按照读取属性的优先级由高到低列出来所有定义方式：

通过project.ext.name=value方式定义属性，例如project.ext.channel='360'定义渠道名称为360。
通过命令行执行gradle -P name=value方式定义属性，例如gradle -P channel=360定义渠道名称为360。
在用户目录下创建gradle.properties文件，然后以name=value方式定义系统属性，例如用户目录为/home/jerry，那么我们就在该目录下创建gradle.properties文件，并且在文件内定义channel=360，这样就定义了渠道名为360。
在项目目录下创建gradle.properties文件，然后以name=value方式定义系统属性，例如项目目录为/HelloGradle，那么我们就在该目录下创建gradle.properties文件，并且在文件内定义channel=360，这样就定义了渠道名为360。

4.3.3 读取属性

在脚本中读取属性十分容易，对于系统属性，我们可以通过System.properties['name']方式读取，对于项目属性则通过project.name方式读取：

build.gradle：

println System.properties['org.gradle.java.home']println project.channel

4.4 任务（task）

在构建项目的时候，我们如果对整个构建过程进行分解的话，大概可以分解成编译代码、打包、生成文档等过程，Gradle用task来代表这些构建过程，每个步骤对应一个task。如果把项目比喻成一个类，那么task就是类中的方法，我们也可以认为task就是构建项目的原子操作，再细分下去就没有意义了。

4.4.1 定义task

Hello world

首先我们来定义一个打印Hello world的task，在build.gradle中编写如下脚本：

build.gradle：

task Hello {    doFirst {        println 'Hello world'    }}

然后我们执行gradle -q Hello命令，-q参数用于过滤多余信息而已，并不是必须的，执行命令后我们会看到如下输出：

> gradle -q HelloHello world

执行顺序

在上面的脚本中，我们看到了doFirst关键字，我想大家也理所当然会想是不是有doLast之类的关键字，答案是肯定的。在task中，我们通过doFirst和doLast来控制task内部脚本的执行顺序，我们来看下面的脚本：

build.gradle：

task MyTask {    doLast {        println 'Execute doLast'    }    doFirst {        println 'Execute doFirst'    }}

执行gradle -q MyTask命令，我们会看到如下输出：

> gradle -q MyTaskExecute doFirstExecute doLast

也许有人会说这有什么特别的，不就相当于把脚本的编写顺序改一下而已，那么我们来看下面一段脚本：

task MyTask {    doLast {        println 'Execute doLast A'    }    doFirst {        println 'Execute doFirst A'    }}MyTask.doFirst {    println 'Execute doFrist B'}MyTask.doLast {    println 'Execute doLast B'}

执行gradle -q MyTask命令，我们会看到如下输出：

> gradle -q MyTaskExecute doFrist BExecute doFirst AExecute doLast AExecute doLast B

从执行结果，我们可以看出MyTask的行为被我们修改了，也就是说Gradle允许你在定义完task之后动态添加更多的行为，其中MyTask.doFirst {...}新增的doFrist会被添加到执行队列的头部，而MyTask.doLast {...}新增的doLast会被添加到执行队列的尾部，所以我们会看到先打印Execute doFirst again，最后打印Execute doLast again。

如果我们不关心脚本的执行顺序，我们可以用<<来快速定义task，<<等价于doLast，也就是说下面的两种定义方式是等价的：

task Task1 << {    println 'Hello'}task Task2 {    doLast {        println 'Hello'    }}

动态定义

Gradle允许我们动态定义task，看如下代码：

3.times { i ->    task "MyTask$i" << {        println "My task $i"    }}

> 提示：这段代码是Groovy的语法，它的作用相当于Java的`for(int i = 0; i < 3; i++)`。执行`gradle -q MyTask0 MyTask1 MyTask2`命令，我们会看到如下输出：~~~> gradle -q MyTask0 MyTask1 MyTask2My task 0My task 1My task 2~~~

4.4.2 依赖关系

task之间可以通过关键字dependsOn指定依赖关系，比如负责打包的task A依赖于编译class文件的task B，这时候当我们允许task A的时候，task B会被先执行，然后才执行task A。

单个依赖

首先我们来看一个最简单的依赖关系，我们称他为单个依赖，因为一个task的运行只依赖于另一个依赖：

task task2 << {    println  'Execute task2'}task task1(dependsOn: task2) << {    println 'Execute task1'}

执行gradle -q task1命令，我们会看到如下输出：

> gradle -q task1Execute task2Execute task1

多个依赖

如果我们想指定更多的依赖关系的话，可以用”[ ] “定义多个task，看如下脚本：

task task2 << {    println  'Execute task2'}task task3 << {    println  'Execute task3'}task task4 << {    println  'Execute task4'}task task1(dependsOn: [task2, task3, task4]) << {    println 'Execute task1'}

执行gradle -q task1命令，我们会看到如下输出：

> gradle -q task1Execute task2Execute task3Execute task4Execute task1

4.4.3 指定类型

在定义task的时候，我们可以通过关键字type为task指定一种类型，task会根据不同类型具有不同的功能，并且Gradle内置了很多实用的task类型，比如Copy类型让task具有拷贝文件的功能，task的类型指定有点像继承的关系：

task copyFile(type: Copy) {    from '/home/xxx/'    into '/home/yyy/'    include 'file1.txt'    rename 'file1.txt', 'file2.txt'}

执行gradle copyFile命令，然后该task就会从/home/xxx/目录下将file1.txt文件复制到/home/yyy/目录下，并且重命名为file2.txt。更多的task类型可以查看Gradle的官方文档。

4.4.4 查看task

最后你可以通过gradle tasks命令查看有多少的task可用，并且父项目可以直接操作子项目的task，反过来却不行：

> gradle tasks------------------------------------------------------------All tasks runnable from root project------------------------------------------------------------Build tasks-----------assemble - Assembles the outputs of this project.build - Assembles and tests this project.buildDependents - Assembles and tests this project and all projects that depend on it.buildNeeded - Assembles and tests this project and all projects it depends on.classes - Assembles classes 'main'.clean - Deletes the build directory.jar - Assembles a jar archive containing the main classes.testClasses - Assembles classes 'test'.Build Setup tasks-----------------init - Initializes a new Gradle build. [incubating]wrapper - Generates Gradle wrapper files. [incubating]Documentation tasks-------------------javadoc - Generates Javadoc API documentation for the main source code.Help tasks----------components - Displays the components produced by root project 'Project1'. [incubating]dependencies - Displays all dependencies declared in root project 'Project1'.dependencyInsight - Displays the insight into a specific dependency in root project 'Project1'.help - Displays a help message.model - Displays the configuration model of root project 'Project1'. [incubating]projects - Displays the sub-projects of root project 'Project1'.properties - Displays the properties of root project 'Project1'.tasks - Displays the tasks runnable from root project 'Project1' (some of the displayed tasks may belong to subprojects).Verification tasks------------------check - Runs all checks.test - Runs the unit tests.Other tasks-----------copyFile

4.4 依赖（dependency）

很多时候我们的项目会依赖到一些第三方库，Gradle为我们提供了3中方式配置依赖项。

4.4.1 依赖本地文件

假设我们在项目的libs目录下有个库叫做mylib.jar，我们可以通过以下方式让项目依赖这个库：

dependencies {    compile files('libs/mylib.jar')}

通过上面的脚本，我们的项目在编译的时候会自动依赖mylib.jar库。

如果你的libs下面有好几个文件需要依赖，可以通过以下方式让项目一次性依赖所有库文件：

dependencies {    compile fileTree(dir: 'libs', include: ['*.jar'])}

通过该方式，我们的项目会把libs目录下的所有jar文件都当做依赖库。

4.4.2 依赖网络库

我们可以通过Gradle依赖网络上的第三方库，这些库一般都会保存在一个网络仓库中，例如maven或jcenter，使用网络上的库带来的好处就是我们可以简单修改版本号就可以更新到最新版的库，并且也省去了我们手动去复制文件。

想要依赖网络仓库里面的第三方库，我们需要知道3个信息：group、name和version。

group：第三方库的组织名称。
name：第三方库的名称。
version：第三方库的版本。

现在假设我们有一个第三方库在maven仓库下，它的信息如下：

group: com.hjdzone.libname: mylibversion: 1.0.0

想要使用这个第三方库，我们可以编写如下脚本：

repositories {    mavenCentral()}dependencies {    compile group: 'com.hjdzone.lib', name: 'mylib', version: '1.0.0'}

该脚本告诉Gradle应该到maven仓库去查找库文件，并且Gradle会把该文件自动加载到本地。

你还可以用以简写方式式来声明依赖，简写方式要求group、name和version之间用:隔开：

repositories {    mavenCentral()}dependencies {    compile 'com.hjdzone.lib:mylib:1.0.0'}

4.6 插件（plugin）

严格上来说Gradle只是一个构建框架，并没有提供任何真正的构建功能，构建任务其实是通过插件实现的，不同的插件会根据不同构建需求定义各种task供我们使用，并且Gradle已经提供了大量的插件，大多数情况下我们无需自己重写plugin，只需要简单地指定plugin就可以使用了。其实在前面的例子中我们就用到了名为java的插件，接下来我们就继续以之前的HelloGradle项目为例，介绍插件的用法。

首先你必须在build.gradle中声明使用java插件：

apply plugin: 'java'

Gradle遵循约定优于配置的原则，所以你的项目结构必须符合插件的要求才能够被插件所识别，例如java插件要求我们的代码必须放在src/main/java 目录下，资源文件必须放在src/main/resources目录下，测试代码必须放在src/test/java目录下，测试资源必须放在src/test/resources目录下：

HelloGradle    build.gradle    src/main/java/Main.java    src/main/resources/logo.png    src/test/java/TestMain.java    src/test/resources/logo.png

java插件提供了各种脚本块用于配置项目，例如你可以通过插件提供的脚本块sourceSets修改项目的结构：

sourceSets {    main {        java './java'        resources './resources'    }}

该脚本把代码目录指定到了./java目录下，把资源文件目录指定到了./resources目录下。

java插件为我们提供了一套完整的构建任务，我们可以通过执行gradle tasks命令查看可用的task：

assemble - Assembles the outputs of this project.build - Assembles and tests this project.buildDependents - Assembles and tests this project and all projects that depend on it.buildNeeded - Assembles and tests this project and all projects it depends on.classes - Assembles classes 'main'.clean - Deletes the build directory.jar - Assembles a jar archive containing the main classes.testClasses - Assembles classes 'test'.

更多关于java插件的用法可以参照官方文档，本文只是起到一个引导作用而已。

简单来说插件就是事先定义好的脚本块和task的集合，我们只需要参照文档使用就可以了。

1 0