Tutorialspoint Gradle 教程

来源：易百教程

Gradle教程™

Ant和Maven共享在Java市场上相当大的成功。ANT是在2000年发布了第一个版本的工具，它是基于程序编程思想的发展。 后来，人们在 Apache-Ivy的帮助下，网络接受插件和依赖管理的能力有所提升。但主要缺点是使用XML作为一种格式来写构建脚本。XML是分层的，不利于程序的编程，而且当XML文件变大以后变得难以管理。

Maven在2004年推出的，它比ANT有一个很大的改进。它改变了结构并且继续使用XML编写生成规范。Maven的依赖约定和能够通过网络下载依赖关系。Maven的主要好处是它的生命周期。虽然接连的多个项目生命周期相同，这是以灵活性为代价的。 Maven也面临着依赖管理的一些问题。它不会在同一库版本之间处理好矛盾，复杂的定制构建脚本实际上Maven比ANT更难写。

最后，Gradle于2012年发布，带来了一些更高效的特点。

Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化建构工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，抛弃了基于XML的各种繁琐配置。 面向Java应用为主。当前其支持的语言限于Java、Groovy和Scala，计划未来将支持更多的语言。

下面是一些Gradle的功能

按约定声明构建和建设；

强大的支持多工程的构建；

强大的依赖管理（基于Apache Ivy），提供最大的便利去构建工程；

全力支持已有的 Maven 或者Ivy仓库基础建设；

支持传递性依赖管理，在不需要远程仓库和pom.xml和ivy配置文件的前提下；

基于groovy脚本构建，其build脚本使用groovy语言编写；

具有广泛的领域模型支持构建；

深度 API；

易迁移；

自由和开放源码，Gradle是一个开源项目，基于 ASL 许可。

为什么使用Groovy?

完整的Gradle API是使用Groovy语言设计的。这是基于XML内部 DSL 的优点。Gradle是其核心的通用构建工具; 它的主要焦点是Java项目。在这些项目中，团队成员要熟悉Java，这是为了更好的构建透明，给所有团队成员的项目。

类似于 Python，Groovy或Ruby语言是最好的构建框架。为什么Groovy被选中？这是因为它为使用Java的人提供了迄今为止最大的透明度。Groovy的基本语法与Java是一样的。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle教程

Gradle安装配置（Windows） - Gradle教程™

在本教程中，我们将学习 Gradle 的安装，对于一个初学者，有时安装开发环境也是一个比较麻烦的问题。如果按照 Gradle 官方网站的说明安装，则可能会遇到一些麻烦，有时还要在互联网上做一些搜索，查找为什么进入命令提示符输入 gradle -v 得不到任何东西。下面是完整的步骤来安装 Gradle ，为我们后续的 Gradle学习的开发环境作好准备！

前提条件

Windows 8 (或更高版本，本教程是 Windows 10 64bit)

Java JDK必须安装（本教程 JDK1.8）

执行以下命令来验证 Java 安装。在写本教程之前，我的系统中已经安装了JDK1.8。

C:/Users/Administrator>java -version

如果命令执行成功，应该会得到下面的输出。

C:/Users/Administrator>java -version
java version "1.8.0_65"
Java(TM) SE Runtime Environment (build 1.8.0_65-b17)
Java HotSpot(TM) 64-Bit Server VM (build 25.65-b01, mixed mode)

如果没有安装 JDK，可以自行安装，参考 - http://www.yiibai.com/java/java_environment_setup.html

安装步骤说明

从网站上下载 Gradle： http://www.gradle.org/downloads ， 当前最新版本是 GRADLE 3.1 。
下载后将它解压缩。 通常把这样的东西放入到我的开发目录中。如：D:workspyiibai.com 目录下。现在，在桌面上右键点击“电脑”（又名“我的电脑”或”此电脑”），然后选择“属性”，打开 “高级” 选项卡，如下图所示：

在上图中点击“环境变量”， 如下图所示 -

在上图中点击“编辑”后新建一个环境变量项， 把解压的 D:workspgradle-3.1�in 目录放入输入框中并点击 “确定”。如下图所示 -

将 Gradle 和 Java JDK 的 bin 目录加入到环境变量之后，单击“确定”（有多次回退点击“确定”）完成。
现在，让我们来测试一下安装的情况。打开命令提示符，然后键入gradle -v，将看到类似下面的内容：

C:/Users/Administrator>gradle -v

------------------------------------------------------------
Gradle 3.1
------------------------------------------------------------

Build time:   2016-10-02 10:53:53 UTC
Revision:     13f38ba699afd86d7cdc4ed8fd7dd3960c0b1f97

Groovy:       2.4.7
Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
JVM:          1.8.0_65 (Oracle Corporation 25.65-b01)
OS:           Windows 10 10.0 amd64

相关教程

Gradle 15分钟入门教程

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle安装配置（Windows）

Gradle构建脚本 - Gradle教程™

Gradle构建脚本文件用来处理两件事情：一个是项目和另一个的任务。每个Gradle生成表示一个或多个项目。一个项目表示一个JAR库或Web应用程序，也可能表示由其他项目产生的JAR文件组装的ZIP。 简单地说，一个项目是由不同的任务组成。一个任务是指构建执行的一块工作。任务可能是编译一些类，创建一个JAR，产生的Javadoc或发布一些归档文件库。

注：Gradle使用Groovy语言编写脚本。

编写构建脚本

Gradle提供了一个域特定语言（DSL），用于描述构建。 它使用 Groovy 语言，使其更容易来形容和构建。Gradle 中的每一个构建脚本使用UTF-8进行编码保存，并命名为 build.gradle 。

创建build.gradle文件

看看下面的例子演示一个小脚本，它将打印 “Yiibai gradle qick start“。复制并保存以下脚本到文件：D:workspyiibai.comgradle-3.1studyscriptbuild.gradle。脚本中定义一个任务名称 helloword，这是用来打印”Yiibai gradle qick start“ 字符串。

在命令提示符下，进入存储 build.gradle 文件的目录并执行以下命令，得到结果如下所示 -

D:workspyiibai.comgradle-3.1studyscript>gradle -q helloword
Yiibai gradle qick start

可以通过指定一个快捷键（<<符号表示）到 doLast 语句来简化 helloword 任务。 如果将快捷方式添加到上述 helloword 任务，它看起来如下面脚本。

task helloword << {
   println 'Yiibai gradle qick start'
}

使用 gradle -q helloword 命令执行上面的脚本，也会得到同样的输出结果。

Gradle如何使用Groovy

Gradle 构建脚本使用 Groovy API。 作为一个入门，我们来来看看下面的例子。以下示例演示将字符串转换为大写。
复制并保存下面的代码到 build.gradle 文件。

task upper << {
   String expString = 'YiiBai gradle tutorials'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()}

使用 gradle –q upper 执行上面的代码，如果命令执行成功，会得到下面的输出。

D:workspyiibai.comgradle-3.1studyscript>gradle -q upper
Original: YiiBai gradle tutorials
Upper case: YIIBAI GRADLE TUTORIALS

下面的例子 4 次打印隐式参数 ($it) 的值。复制并保存下面的代码到 build.gradle 文件。

task count << {
   4.times {
      print "$it "
   }
}

使用 gradle –q count 执行上面的代码，如果命令执行成功，会得到下面的输出。

D:workspyiibai.comgradle-3.1studyscript>gradle -q count
0 1 2 3

Groovy的JDK方法

Groovy增加了很多有用的方法到标准的Java类。 例如，从Java API可迭代实现它遍历Iterable接口的元素的each() 方法。

复制并保存下面的代码到 build.gradle 文件。

task groovyJDKMethod << {
   String myName = "Yiibai";
   myName.each() {
      println "${it}"
   };
}

使用 gradle –q groovyJDKMethod 执行上面的代码，如果命令执行成功，会得到下面的输出。

D:workspyiibai.comgradle-3.1studyscript>gradle -q groovyJDKMethod
Y
i
i
b
a
i

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle构建脚本

Gradle任务 - Gradle教程™

Gradle构建脚本描述一个或多个项目。每个项目都由不同的任务组成。任务是构建执行的一项工作。任务可以是编译一些类，将类文件存储到单独的目标文件夹中，创建JAR，生成Javadoc或将一些归档发布到存储库。

定义任务

任务是用于将任务定义到构建脚本中的关键字。看看下面的例子，它是一个叫作 hello 的任务，将打印一个字符串：hello world。将以下脚本复制并保存到 build.gradle 文件中。 此构建脚本定义一个名称为 “hello” 的任务，用于打印hello world字符串。

task hello {
   doLast {
      println 'hello world'
   }
}

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q hello
hello world

可以通过为 doLast 语句指定快捷方式（表示符号 <<）来简化此 hello 任务。如果添加这个快捷方式到上面的 hello 任务中，参考如下脚本。

task hello << {
   println 'hello world'
}

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q hello
hello world

任务依赖关系

您可能已经猜到，可以声明依赖于其他任务的任务。下面声明依赖于其他任务的任务，将以下代码复制并保存到build.gradle文件中。

task hello << {
    println 'Hello world!'
}
task intro(dependsOn: hello) << {
    println "I'm Gradle"
}

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q intro
Hello world!
I'm Gradle

要添加依赖关系，相应的任务不需要存在。懒依赖 - 其他任务不存在，将以下代码复制并保存到build.gradle文件中。

task taskX(dependsOn: 'taskY') << {
    println 'taskX'
}
task taskY << {
    println 'taskY'
}

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q taskX
taskY
taskX

定位任务

如果要查找在构建文件中定义的任务，则必须使用相应的标准项目属性。这意味着每个任务都可以作为项目的属性，使用任务名称作为属性名称。
看看下面的代码访问任务作为属性。将以下代码复制并保存到build.gradle文件中。

task hello

println hello.name
println project.hello.name

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q hello
hello
hello

您还可以通过任务集合使用所有属性。
将以下代码复制并保存到build.gradle文件中。

task hello

println tasks.hello.name
println tasks['hello'].name

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q hello
hello
hello

向任务添加依赖关系

要将一个任务依赖于另一个任务，这意味着当一个任务完成时，另一个任务将开始。 每个任务都使用任务名称进行区分。 任务名称集合由其任务集合引用。 要引用另一个项目中的任务，应该使用项目路径作为相应任务名称的前缀。
以下示例将从任务taskX添加依赖项到任务taskY。

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q taskY
taskX
taskY

上面的例子是通过使用名字添加对任务的依赖。 还有另一种方法实现任务依赖性，即使用Task对象定义依赖性。
现在采用上面任务的相同示例，但是使用任务对象而不是任务参考名称来实现依懒关系。
将以下代码复制并保存到build.gradle文件中。

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q taskY
taskX
taskY

还有另一种方法来添加任务依赖，它就是通过使用闭包。在这种情况下，任务通过闭包释放如果您在构建脚本中使用闭包，那么应该返回任务对象的单个任务或集合。以下示例将任务中从taskX添加依赖项到项目中的所有任务，其名称以“lib”开头。
将以下代码复制并保存到build.gradle文件中。

task taskX << {
   println 'taskX'
}

taskX.dependsOn {
   tasks.findAll {
     task -> task.name.startsWith('lib')
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q taskX
lib1
lib2
taskX

向任务添加描述

可以向任务添加描述。 执行Gradle任务时会显示此描述。 这可以通过使用description关键字。
将以下代码复制并保存到build.gradle文件中。

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q taskX
description applied

跳过任务

如果用于跳过任务的逻辑不能用谓词表示，则可以使用StopExecutionException。 如果操作抛出此异常，则会跳过此操作的进一步执行以及此任务的任何后续操作的执行。 构建继续执行下一个任务。
将以下代码复制并保存到build.gradle文件中。

task compile << {
    println 'We are doing the compile.'
}

compile.doFirst {
    // Here you would put arbitrary conditions in real life.
    // But this is used in an integration test so we want defined behavior.
    if (true) { throw new StopExecutionException() }
}
task myTask(dependsOn: 'compile') << {
   println 'I am not affected'
}

在存储 build.gradle 文件的目录位置执行以下命令，应该看到输出结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q myTask
I am not affected

Gradle在处理任务时有不同的阶段。 首先，有一个配置阶段，其中直接在任务的闭包中指定的代码被执行。 针对每个可用任务执行配置块，而不仅针对稍后实际执行的那些任务。

参考 -

https://docs.gradle.org/current/userguide/more_about_tasks.html

https://docs.gradle.org/current/userguide/tutorial_using_tasks.html

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle任务

Gradle依赖管理 - Gradle教程™

Gradle构建脚本定义了构建项目的过程; 每个项目包含一些依赖项和一些发表项。依赖性意味着支持构建项目的东西，例如来自其他项目的所需JAR文件以及类路径中的外部JAR（如JDBC JAR或Eh-cache JAR）。发布表示项目的结果，如测试类文件和构建文件，如war文件。

Gradle负责构建和发布结果。 发布基于定义的任务。 可能希望将文件复制到本地目录，或将其上传到远程Maven或lvy存储库，或者可以在同一个多项目构建中使用另一个项目的文件。 发布的过程称为发布。

声明依赖关系

Gradle遵循一些特殊语法来定义依赖关系。 以下脚本定义了两个依赖项，一个是Hibernate core 3.6.7，第二个是Junit 4.0和更高版本。如下面的代码所示，可在build.gradle文件中使用此代码。

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

依赖关系配置

依赖关系配置只是定义了一组依赖关系。 您可以使用此功能声明从Web下载外部依赖关系。这定义了以下不同的标准配置。

编译 − 编译项目的生产源所需的依赖关系。

运行时 - 运行时生产类所需的依赖关系。 默认情况下，还包括编译时依赖项。

测试编译 - 编译项目测试源所需的依赖项。 默认情况下，它包括编译的产生的类和编译时的依赖。

测试运行时 - 运行测试所需的依赖关系。 默认情况下，它包括运行时和测试编译依赖项。

外部依赖

外部依赖是一种依赖。 这是对当前构建之外构建的一些文件的依赖，并且存储在某种类型的存储库中，例如：Maven central，corporate Maven或lvy repository或本地文件系统中的目录。
以下代码片段是定义外部依赖关系。 在build.gradle文件中使用如下代码。

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

存储库

在添加外部依赖关系时， Gradle在存储库中查找它们。 存储库只是文件的集合，按分组，名称和版本来组织构造。 默认情况下，Gradle不定义任何存储库。 我们必须至少明确地定义一个存储库。 下面的代码片段定义了如何定义 maven 仓库。 在build.gradle文件中使用此代码。

repositories {
   mavenCentral()
}

下面的代码是定义远程maven。 在build.gradle文件中可使用下面代码。

repositories {
   maven {
      url "http://repo.mycompany.com/maven2"
   }
}

发布文件

依赖关系配置也用于发布文件。 这些已发布的文件称为工件。 通常，我们使用插件来定义工件。 但是需要告诉Gradle在哪里发布文件。可以通过将存储库附加到上传存档任务来实现此目的。 请查看以下用于发布Maven存储库的语法。 执行时，Gradle将根据项目需求生成并上传Pom.xml。 在build.gradle文件中使用此代码。

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/tmp/myRepo/")
      }
   }
}

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle依赖管理

Gradle插件 - Gradle教程™

插件只是一组任务，几乎所有的任务，如编译任务，设置域对象，设置源文件等都由插件处理。

插件类型

Gradle中有两种类型的插件：脚本插件和二进制插件。 脚本插件是一个额外的构建脚本，它提供了一种声明性方法来操作构建，通常在构建中使用。 二进制插件是实现插件接口并采用编程方法来操作构建的类。二进制插件可以驻留在插件JAR中的一个构建脚本和项目层次结构或外部。

应用插件

Project.apply（）API方法用于应用特定的插件。您可以多次使用相同的插件。有两种类型的插件：一种是脚本插件，第二种是二进制插件。

脚本插件

脚本插件可以从本地文件系统上的脚本或远程位置应用。文件系统位置相对于项目目录，而远程脚本位置指定HTTP URL。看看下面的代码片段。它将other.gradle插件用于构建脚本。 在build.gradle文件中使用此代码如下。

apply from: 'other.gradle'

二进制插件

每个插件由插件标识。一些核心插件是使用短名称来应用它，一些社区插件是使用插件ID的完全限定名称。有时它允许指定一个插件类。
看看下面的代码片段。 它显示如何使用应用Java插件。 在build.gradle文件中使用此代码。

apply plugin: JavaPlugin

看看下面的代码，使用短名称应用核心插件。 在build.gradle文件中使用此代码如下所示。

plugins {
   id 'java'
}

看看下面的代码，使用短名称应用社区插件。 在build.gradle文件中使用此代码如下所示。

plugins {
   id "com.yiibai.bintray" version "0.1.0"
}

编写自定义插件

在创建自定义插件时，您需要编写一个插件的实现。 Gradle实例化插件并使用Plugin.apply（）方法调用插件实例。以下示例包含一个简单的hello插件，它将一个问候任务添加到项目中。看看下面的代码。 在build.gradle文件中使用此代码。

apply plugin: HelloPlugin

class HelloPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the HelloPlugin."
      }
   }
}

使用以下代码执行上述脚本。

D:/worksp/yiibai.com/gradle-3.1/study/script> gradle -q hello
Hello from the HelloPlugin

从构建获取输入

大多数插件需要从构建脚本中的配置获得支持。 Gradle项目有一个关联“ExtensionContainer”对象，它有助于跟踪传递给插件的所有设置和属性。

让我们在项目中添加一个简单的扩展对象。在这里，我们向项目中添加一个问候语扩展对象，它允许我们配置问候语。在build.gradle文件中使用此代码如下所示。

apply plugin: HelloPlugin

greeting.message = 'Hi,this from configure Gradle message.'

class HelloPlugin implements Plugin<Project> {
   void apply(Project project) {
      // Add the 'greeting' extension object
      project.extensions.create("greeting", HelloPluginExtension)

      // Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class HelloPluginExtension {
   def String message = 'Hello,this from HelloPluginExtension message.'
}

使用以下代码执行上述脚本，得到结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q hello
Hi,this from configure Gradle message.

Gradle为每个扩展对象添加了一个配置闭包，因此可以将分组设置在一起。 看看下面的代码。 在build.gradle文件中使用此代码。

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)

      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

使用以下代码执行上述脚本，得到结果如下 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q hello
Hi from Gradle

标准Gradle插件

在Gradle分布中包含不同的插件。

语言插件

这些插件的添加，让JVM在编译和执行时对各种语言支持。

插件Id | 自动应用 | 描述
java | java-base | 向项目添加Java编译，测试和绑定的功能。它作为许多其他Gradle插件的基础。
groovy | java,groovy-base | 添加对构建Groovy项目的支持。
scala | java,scala-base | 添加对构建Scala项目的支持。
antlr | Java | 添加了使用Antlr生成解析器的支持。

孵化语言插件

这些插件添加对各种语言的支持。

插件Id | 自动应用 | 描述
汇编 | — | 向项目添加本地汇编语言功能。
c | — | 向项目添加C语言的源代码编译功能。
cpp | — | 向项目添加C++语言的源代码编译功能。
objective-c | — | 向项目添加objective-c语言的源代码编译功能。
objective-cpp | — | 向项目添加Objective-C++语言的源代码编译功能。
windows-resources | — | 添加本机二进制文件包括Windows资源的支持。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle插件

Gradle运行构建 - Gradle教程™

Gradle提供了一个命令行来执行构建脚本。 它可以一次执行多个任务。在这里将介绍如何使用不同的选项来执行多个任务。

执行多个任务

Gradle可以从单个构建文件执行多个任务。使用gradle命令处理构建文件。此命令将按列出的顺序编译每个任务，并使用不同的选项执行每个任务以及依赖关系。

示例 - 假设有四个任务 - task1，task2，task3和task4。task3和task4取决于task1和task2。 看看下面的图表。

在上面的四个任务是相互依赖的，用一个箭头符号表示。 看看下面的代码。 将其复制并粘贴到build.gradle文件中。

task task1 << {
   println 'compiling source #1'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests #2'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests #3'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution #4'
}

使用以下代码来编译和执行上述任务。如果命令执行成功，将获得以下输出 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle task4 task1
:task1
compiling source #1
:task2
compiling unit tests #2
:task3
running unit tests #3
:task4
building the distribution #4

BUILD SUCCESSFUL

Total time: 1.265 secs

排除任务

要执行中排除某个任务时，可以在gradle命令中使用-x选项，并指出要排除的任务的名称。
使用以下命令用于从上面的脚本中排除 task1 这个任务。
使用以下代码来编译和执行上述任务。如果命令执行成功，将获得以下输出 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle task4 -x task1
:task2
compiling unit tests #2
:task3
running unit tests #3
:task4
building the distribution #4

BUILD SUCCESSFUL

Total time: 1.272 secs

发生故障时继续构建

Gradle将在任何任务失败时立即中止执行。但是有时我们希望即使发生故障，也可以继续执行。 为此，要在gradle命令使用-continue选项。它分别处理每个任务及其依赖关系。 重要的是，它将捕获每个遇到的故障，并在构建的执行结束时生成报告。 假设一个任务失败，那么相关的后续依懒任务也不会被执行。

选择执行哪些构建

当运行gradle命令时，它在当前目录中查找构建文件。我们也可以使用-b选项选择指定的构建文件的路径。以下示例显示在subdir/ 子目录中创建一个新文件 newbuild.gradle，并创建一个名称为 hello 项目。创建的newbuild.gradle文件的代码内容如下 -

task hello << {
   println "Use File：$buildFile.name in '$buildFile.parentFile.name'."
}

使用以下代码来编译和执行上述任务。如果命令执行成功，将获得以下输出 -

D:/worksp/yiibai.com/gradle-3.1/study/script> gradle -q -b subdir/newbuild.gradle hello
Use File：newbuild.gradle in 'subdir'.

获取构建信息

Gradle提供了几个内置任务来检索有关任务和项目的详细信息。这对理解构建的结构和依赖性以及调试一些问题很有用。可使用项目报告插件向项目中添加任务，来生成这些报告。

列出项目

可以使用gradle -q projects命令来列出所选项目及其子项目的项目层次结构。下面是一个列出构建文件中的所有项目的示例 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q projects

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'script'
No sub-projects

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :tasks

报告显示每个项目的描述（如果有指定的话）。可以使用以下命令指定描述。将其粘贴到build.gradle文件中。
再一次执行命令，得到以下结果 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q projects

------------------------------------------------------------
Root project - The shared API for the application
------------------------------------------------------------

Root project 'script' - The shared API for the application
No sub-projects

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :tasks

列出任务

使用以下命令列出属于多个项目的所有任务。如下所示 -

D:/worksp/yiibai.com/gradle-3.1/study/script>gradle -q tasks --all

------------------------------------------------------------
All tasks runnable from root project - The shared API for the application
------------------------------------------------------------

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'script'.
components - Displays the components produced by root project 'script'. [incubating]
dependencies - Displays all dependencies declared in root project 'script'.
dependencyInsight - Displays the insight into a specific dependency in root project 'script'.
help - Displays a help message.
model - Displays the configuration model of root project 'script'. [incubating]
projects - Displays the sub-projects of root project 'script'.
properties - Displays the properties of root project 'script'.
tasks - Displays the tasks runnable from root project 'script'.

Other tasks
-----------
task4
    task1
    task2
    task3

以下是其它一些命令及其说明的列表。

编号 | 命令 | 描述
1 | gradle –q help –task | 提供有关指定任务或多个任务的使用信息（如路径，类型，描述，组）。
2 | gradle –q dependencies | 提供所选项目的依赖关系的列表。
3 | gradle -q api:dependencies —configuration | 提供有关配置的有限依赖项的列表。
4 | gradle –q buildEnvironment | 提供构建脚本依赖项的列表
5 | gradle –q dependencyInsight | 提供了一个洞察到一个特定的依赖
6 | gradle –q properties | 提供所选项目的属性列表

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle运行构建

Gradle构建JAVA项目 - Gradle教程™

本章介绍如何使用Gradle构建文件来构建一个Java项目。 首先，我们必须向构建脚本中添加Java插件，因为它提供了编译Java源代码，运行单元测试，创建Javadoc和创建JAR文件的任务。 在build.gradle文件中使用以下代码行。

apply plugin: 'java'

怎么样，是不是很简单？

Java默认的项目布局

每当添加一个插件到构建中，它会假设一个特定的Java项目设置（类似于Maven）。看看下面的目录结构。

src/main/java 目录包含Java源代码；

src/test/java 目录包含测试用的源代码；

如果遵循上面设置，以下构建文件足以编译，测试并捆绑Java项目。
要启动构建，请在命令行上键入以下命令。

D:/worksp/gradle> gradle build

SourceSets可用于指定不同的项目结构。例如，指定源代码存储在src文件夹中，而不是在src/main/java中。 看看下面的目录结构。

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }

   test {
      java {
         srcDir 'test'
      }
   }
}

初始化任务执行

Gradle还不支持多个项目模板。但它提供了一个init来初始化任务来创建一个新的Gradle项目的结构。如果没有指定其他参数，任务将创建一个Gradle项目，其中包含gradle包装器文件，build.gradle和settings.gradle文件。

当使用java-library作为值并添加--type参数时，将创建一个java项目结构，build.gradle文件包含带有Junit的某个Java模板。 看看下面build.gradle文件的代码。

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

在仓库(repositories)这部分中，它定义了要从哪里找到依赖。Jcenter是为了解决依赖问题。 依赖关系（dependencies）部分用于提供有关外部依赖关系的信息。

指定Java版本

通常，Java项目要有一个版本和一个目标JRE，在其上编译它。version和sourceCompatibility属性可以在build.gradle文件中设置。

version = 0.1.1
sourceCompatibility = 1.8

如果这是一个可执行的Java应用程序，MANIFEST.MF文件必须要指定具有main方法的类。

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.yiibai.main.Application'
   }
}

让我们考虑一个例子。创建一个目录结构，如下面的屏幕截图所示。

将以下Java代码复制到App.java文件中，并将其存储到 D:/worksp/gradle/src/main/java/com/yiibai 目录中。

package com.yiibai;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World, Gradle Build Work! " );
   }
}

将以下Java代码复制到AppTset.java文件中，并存储到D:/worksp/gradle/src/test/java/com/yiibai目录中。

package com.yiibai;

/**
* Hello world!
*
*/

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

将以下代码复制到build.gradle文件中，并放入 D:/worksp/gradle 目录。

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.yiibai.main.App'
   }
}

要编译和执行上述脚本，请使用以下命令。

D:/worksp/gradle> gradle tasks
....
D:/worksp/gradle> gradle assemble
....
D:/worksp/gradle> gradle build
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:jar UP-TO-DATE
:assemble UP-TO-DATE
:compileTestJava
:processTestResources UP-TO-DATE
:testClasses
:test
:check
:build

BUILD SUCCESSFUL

Total time: 1.638 secs

查看相应目录中的所有类文件，并检查 D:/worksp/gradle/build/libs文件夹中，应该会有一个 gradle.jar文件。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle构建JAVA项目

Gradle构建Groovy项目 - Gradle教程™

本章介绍如何使用build.gradle文件编译和执行Groovy项目。

Groovy插件

Gradle的Groovy插件扩展了Java插件，并为Groovy程序提供了任务。可以使用以下行来应用groovy插件。

apply plugin: 'groovy'

完整的构建脚本文件如下。将以下代码复制到build.gradle文件中。

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

可以使用以下命令来执行构建脚本。

gradle build

Groovy项目的默认项目布局

Groovy插件假定Groovy项目有手动做过一定的设置。

src/main/groovy 包含Groovy源代码；

src/test/groovy包含Groovy测试源代码；

src/main/java包含Java源代码；

src/test/java 包含Java测试源代码；

在build.gradle文件所在当前目录下的build文件夹中查看相应的目录，是否执行后有生成文件。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle构建Groovy项目

Gradle测试 - Gradle教程™

测试任务自动检测和执行测试源集合中的所有单元测试。它还会在测试执行完成后生成报告。 JUnit和TestNG都是支持的API。

测试任务提供了一个Test.set Debug（）方法，可以将其设置为启动JVM等待调试器。在继续执行之前，它将调试器发布值设置为5005。

测试检测

测试任务通过检查编译的测试类来检测哪些类是测试类。 默认情况下，它扫描所有.class文件。不过也可以设置自定义包含/排除，只有那些类才会被扫描。根据所使用的测试框架（JUnit / TestNG），测试类检测使用不同的标准。

如果不想使用测试类检测，可以通过将scanForTestClasses设置为false来禁用它。

测试分组

JUnit和TestNG允许复杂的测试方法分组。对于分组，JUnit有测试类和方法。JUnit 4.8引入了类别的概念。测试任务允许指定要包括或排除的JUnit类别。

可以使用build.gradle文件中的以下代码段对测试方法进行分组。如下代码所示 -

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

包括和排除指定测试

Test类有一个include和exclude方法。这些方法可以用于指定哪些测试应该运行。
只运行包含的测试 -

test {
   include '**my.package.name/*'
}

跳过排除的测试 -

test {
   exclude '**my.package.name/*'
}

以下代码中所示的build.gradle示例文件显示了不同的配置选项。

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "64m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'

   // listen to events in the test execution lifecycle
   beforeTest {
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput {
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: "
         + event.message )
   }
}

可以使用以下命令语法来执行一些测试任务。

gradle <someTestTask> --debug-jvm

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle测试

Gradle多项目构建 - Gradle教程™

Gradle可以轻松处理各种大小规模的项目。小项目由一个单一的构建文件和一个源代码树构成。 大项目可以将其拆分成更小的，相互依赖的模块，以便更容易理解。Gradle完美支持这种多项目构建的场景。

多项目构建的结构

这种构建有各种形状和大小，但它们都有一些共同的特点 -

在项目的根目录或主目录中都有一个settings.gradle文件。

根目录或主目录都有一个build.gradle文件。

具有自己的*.gradle构建文件的子目录（某些多项目构建可能会省略子项目构建脚本）。

要列出构建文件中的所有项目，可以使用以下命令。

D:/water>gradle -q projects

如果命令执行成功，将获得以下输出。

D:/water>gradle -q projects

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'water'
+--- Project ':bluewhale'
/--- Project ':krill'

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :bluewhale:tasks

报告将显示每个项目的描述（如果指定）。可以使用以下命令指定描述。 将其粘贴到build.gradle文件中。

description = 'The shared API for the application'

指定常规构建配置

在根项目中的build.gradle文件中，常规配置可以应用于所有项目或仅应用于子项目。

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

这指定了一个公共com.example.gradle组和一个0.1.0版本到所有项目。subprojects 闭合所有应用对子项目通用配置，但不对根项目应用，如：allprojects闭合。

项目指定配置和依赖关系

核心ui和util子项目也可以有自己的build.gradle文件，如果它们有特定的需求，那么一般不会应用根项目配置。

例如，ui项目通常具有对核心项目的依赖性。所以在ui项目中需要有配置自己的build.gradle文件来指定这个依赖。

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

项目依赖项可使用项目方法指定。

Gradle多项目构建的示例

定义公共行为

让我们看看下面的一个例子的项目树。这是一个多项目构建，其中包含一个名为water的根项目和一个名称为bluewham的子项目。在这个示例中，我们把在创建一个目录D:/water，作为根项目的目录。
多项目树 - water 和bluewham项目的构建布局如下图所示 -

water/
  build.gradle
  settings.gradle
  bluewhale/

首先，创建一个文件 settings.gradle 并写入以下代码内容 -

include 'bluewhale'

bluewhale项目的构建脚本在哪里？ 在Gradle中构建脚本是可选的。显然，对于单个项目构建，如果没有构建脚本那么项目是没有意义的。但对于多项目构建情况不同。让我们看看water项目的构建脚本并执行它，创建一个文件build.gradle 并写入以下代码：

Closure cl = { task -> println "I'm $task.project.name" }
task hello << cl
project(':bluewhale') {
    task hello << cl
}

并执行 gradle -q hello 输出结果如下 -

D:/water>gradle -q hello
I'm water
I'm bluewhale

Gradle允许从构建脚本中访问多项目构建的任何项目。 Project API提供了一个名称为project（）的方法，它将一个路径作为参数，并返回此路径的Project对象。
为每个项目显式添加任务是不方便的。我们可以稍微做一下调整，先将另一个名称为krill的项目添加到多项目构建中。
现在目录结构看起来如下所示 -

water/
  build.gradle
  settings.gradle
  bluewhale/
  krill/

再次编辑 settings.gradle 将以下代码加入到文件中 -

include 'bluewhale', 'krill'

现在我们已经重写 water 构建脚本并将其放在一行中。
将文件water项目中的 build.gradle 并写入以下代码：

allprojects {
    task hello << { task -> println "I'm $task.project.name" }
}

并执行 gradle -q hello 输出结果如下 -

D:/water>gradle -q hello
I'm water
I'm bluewhale
I'm krill

这是如何工作的？ Project API提供了一个属性allprojects，它返回当前项目及其下面所有子项目的列表。 如果使用闭包调用allprojects，则闭包的语句将委派给与所有项目相关联的项目。当然也可以通过allprojects.each进行迭代，但这将更冗长。

其他构建系统使用继承作为定义公共行为的主要方法。Gradle也为项目提供继承，您将在后面看到。但Gradle使用配置注入作为定义公共行为的常用方式。这是一种非常强大和灵活的配置多项目构建的方式。共享配置的另一种可能性是使用公共外部脚本。

子项目配置

Project API还提供了一个仅用于访问子项目的属性。

定义公共行为

定义所有项目和子项目的公共行为，编辑 build.gradle 文件使用以下代码 -

allprojects {
    task hello << {task -> println "I'm $task.project.name" }
}
subprojects {
    hello << {println "- I depend on water"}
}

并执行 gradle -q hello 输出结果如下 -

D:/water>gradle -q hello
I'm water
I'm bluewhale
- I depend on water
I'm krill
- I depend on water

注意两个代码片段引用“hello”任务。 第一个，它使用“task”关键字，构建任务并提供它的基本配置。第二部分不使用“task”关键字，因为它进一步配置现有的“hello”任务。只能在项目中构建一次任务，但可以添加任意数量的代码块以提供其他配置。

添加指定行为

可以在常见行为之上添加指定的行为。要应用这个特定的行为，通常将项目特定的行为放在项目的构建脚本中。我们可以为 bluewhale 项目添加项目特定的行为，如下所示：
编辑 build.gradle 文件使用以下代码 -

allprojects {
    task hello << {task -> println "I'm $task.project.name" }
}
subprojects {
    hello << {println "- I depend on water"}
}
project(':bluewhale').hello << {
    println "- I'm the largest animal that has ever lived on this planet."
}

并执行 gradle -q hello 输出结果如下 -

D:/water>gradle -q hello
I'm water
I'm bluewhale
- I depend on water
- I'm the largest animal that has ever lived on this planet.
I'm krill
- I depend on water

正如上面所说的，通常把项目特定的行为放入这个项目的构建脚本中。现在重构代码并向krill项目添加一些项目特定的行为。

定义 krill 项目的具体行为

构建布局如下图中所示 -

water/
  build.gradle
  settings.gradle
  bluewhale/
    build.gradle
  krill/
    build.gradle

settings.gradle 文件的内容 -

include 'bluewhale', 'krill'

bluewhale/build.gradle 文件的内容 -

hello.doLast {
  println "- I'm the largest animal that has ever lived on this planet."
}

krill/build.gradle 文件的内容 -

hello.doLast {
  println "- The weight of my species in summer is twice as heavy as all human beings."
}

build.gradle 文件的内容 -

allprojects {
    task hello << {task -> println "I'm $task.project.name" }
}
subprojects {
    hello << {println "- I depend on water"}
}

并执行 gradle -q hello 输出结果如下 -

D:/water>gradle -q hello
I'm water
I'm bluewhale
- I depend on water
- I'm the largest animal that has ever lived on this planet.
I'm krill
- I depend on water
- The weight of my species in summer is twice as heavy as all human beings.

参考

https://docs.gradle.org/current/userguide/multi_project_builds.html

https://www.petrikainulainen.net/getting-started-with-gradle/

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle多项目构建

Gradle部署 - Gradle教程™

Gradle提供了几种部署构建工件(artifacts)存储库的方法。将工件的签名部署到Maven存储库时，还需要签署已发布的POM文件。

使用Maven插件发布

Gradle默认提供maven-publish插件。 它用于发布gradle脚本。 看看下面的代码。

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

当应用Java和maven-publish插件时，有几个发布选项。 看看下面的代码，它会将项目部署到远程仓库。

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'mypasswd'
         }
         // 发布maven存储库的url
         url "http://localhost:8080/nexus/content/repositories/releases/"
      }
   }
}

将项目从Maven转换为Gradle

有一个特殊的命令用于将Apache Maven pom.xml文件转换为Gradle构建文件，如果此任务已经知道使用的所有Maven插件。

在本节中，以下pom.xml 的maven配置将转换为Gradle项目。创建一个D:/pom.xml并使用下面的代码。

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">

   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>

   <version>1.0.0-SNAPSHOT</version>

   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>

</project>

可以命令行上使用以下命令，然后生成以下Gradle配置内容。

D:/> gradle init --type pom
Starting a Gradle Daemon, 1 incompatible and 1 stopped Daemons could not be reused, use --status for details
:wrapper
:init
Maven to Gradle conversion is an incubating feature.

BUILD SUCCESSFUL

Total time: 11.542 secs

init任务依赖于包装器任务，因此它创建了一个Gradle包装器。
生成的build.gradle文件类似于以下内容。

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.yiibai.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {

     maven { url "http://repo.maven.apache.org/maven2" }
}
dependencies {
    testCompile group: 'junit', name: 'junit', version:'4.11'
}

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle部署

Gradle和Eclipse集成 - Gradle教程™

本章将介绍了Eclipse集成Gradle。以下是将Gradle插件添加到Eclipse的步骤。

步骤1 - 打开Eclipse Marketplace

打开在系统中安装好的Eclipse。 转到 Jelp → Eclipse Marketplace，如下面的屏幕截图所示。

步骤2 - 安装Buildship插件

单击 Eclipse 中的 Marketplace，在打开界面中找到以下屏幕截图。在左侧搜索栏上输入buildship。Buildship是一个Gradle集成插件。当在屏幕上找到Buildship时，单击屏幕右侧的安装（Install）按钮，如以下屏幕截图所示。

找到以下屏幕截图。并通过单击确认(Confirm)按钮确认软件安装。请看下面的截图 -

在以下屏幕中单击“I accept the terms of the license agreement”，然后单击“Finish”。看看下面的截图。

整个安装过程需要一些时间。
安装完成成后要求重启 Eclipse ，然后点击 Yes 按钮就好，提示如下所示 -

步骤3 - 验证Gradle插件安装情况

在Gradle插件安装情况时，将按照给定的过程创建一个新项目。 在 Eclipse 中, 打开 File → 点击 New → 点击 Other projects 将弹出以下屏幕。 选择Gradle项目，然后单击下一步。

单击下一步(Next)按钮后将弹出以下屏幕，这里我们创建一个名称为 GradleProject 的项目。然后单击下一步(Next)按钮，如下面的屏幕截图所示。

这这一步中，必须选择本地文件系统的 Gradle主目录路径， 现在选择 Gradle 的安装目录，如下图中所示 -

点击下一步(Next)按钮，开始创建 Gradle项目然后点击完成(Finish)按钮，如下图所示 -

步骤4 - 验证目录结构

成功安装Gradle插件并创建工程后，请检查上面一步中所创建的 GradleProject 项目目录结构中的默认文件和文件夹，如下面的屏幕截图所示。

剩下的，就可以按照您自己的方式来构建项目了。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle和Eclipse集成

Gradle 15分钟入门教程 - Gradle教程™

1-Gradle入门介绍

在阅读或实践本文中的实例前，必须首先确保已将Gradle插件安装到Eclipse中。如果没有，可以点击下面的链接查看Gradle安装说明：

http://www.yiibai.com/gradle/how-install-gradle-windows.html

本教程的目标：

这是项目完成后的代码结构图：

2-创建Gradle项目

打开 Eclipse，单击并选择菜单 File->New->Other 并选择 Gradle Project 如下图所示 -

点击下一步（Next)显示集成的一些说明，如下 -

点击下一步（Next)，并填入要创建的项目的名称 HelloGradle 并点击完成（Finish)，如下 -

在第一次运行时，Eclipse将下载Gradle相关软件或要求指定本机安装 Gradle 的路径。请参考Eclipse+Gradle集成教程。

默认情况下，Gradle软件将通过Eclipse下载到 C:/Users/{username}/.gradle。不过可以配置更改到其它位置，此配置在本指南的最后一个附录中有说明。

Gradle将自动创建项目所需要的文件结构。其结构类似于Maven项目。

注意，这是一个 gradle 项目定义的项目结构，怎么样，是不是有点熟悉？

src/main/java - 文件夹包含所有java源文件。

src/test/java - 文件夹包含所有java测试用例。

build.gradle - 文件包含项目构建所使用的脚本。

settings.gradle - 文件将包含必要的一些设置，例如，任务或项目之间的依懒关系等。

3- 配置Gradle

build.gradle文件是配置项目中要使用的库的文件。它和Maven工程中的pom.xml相同。
打开build.gradle文件配置将要使用的库，默认生成的代码内容如下：

/*
 * This build file was auto generated by running the Gradle 'init' task
 * by 'Administrator' at '16-10-30 下午4:20' with Gradle 3.1
 *
 * This generated file contains a sample Java project to get you started.
 * For more details take a look at the Java Quickstart chapter in the Gradle
 * user guide available at https://docs.gradle.org/3.1/userguide/tutorial_java_projects.html
 */

// Apply the java plugin to add support for Java
apply plugin: 'java'

// In this section you declare where to find the dependencies of your project
repositories {
    // Use 'jcenter' for resolving your dependencies.
    // You can declare any Maven/Ivy/file repository here.
    jcenter()
}

// In this section you declare the dependencies for your production and test code
dependencies {
    // The production code uses the SLF4J logging API at compile time
    compile 'org.slf4j:slf4j-api:1.7.21'

    // Declare the dependency for your favourite test framework you want to use in your tests.
    // TestNG is also supported by the Gradle Test task. Just change the
    // testCompile dependency to testCompile 'org.testng:testng:6.8.1' and add
    // 'test.useTestNG()' to your build script.
    testCompile 'junit:junit:4.12'
}

向上面的源代码文件中添加以下代码 -

// https://mvnrepository.com/artifact/org.apache.commons/commons-lang3

compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.0'

添加后如下 -

注意：如果build.gradle文件更新，Eclipse目前不会自动更新类路径。要在项目上或在build.gradle文件中点击右键选择 Gradle/Refresh Gradle 来更新项目。

如果将新的库添加到 build.gradle 中声明，Gradle 将会把它们下载到本地计算机上。

接下来，创建一些 Java 类来测试使用下载的类库，这里创建一个简单的 CheckNumeric.java 类，如下所示 -

CheckNumeric.java 类的代码如下所示 -

package com.yiibai.hellogradle;

import org.apache.commons.lang3.StringUtils;

public class CheckNumeric {

    public static void main(String[] args) {
        String text1 = "a12340";
        String text2 = "1234";

        boolean result1 = StringUtils.isNumeric(text1);
        boolean result2 = StringUtils.isNumeric(text2);

        System.out.println(text1 + " is a numeric? " + result1);
        System.out.println(text2 + " is a numeric? " + result2);

    }

}

运行 CheckNumeric 类应该会得到以下结果：

可以在项目中清楚地看到使用的库，它在硬盘上的位置如下图所示 -

4-解释Gradle的操作原理

上面的步骤中我们已经创建了项目，并且成功地运行了。该项目使用的StringUtils类，它是一个Apache类，而不是在JDK的标准库中的类。传统上做法，必须将这个类库复制到项目并声明类路径。但是，这里并不需要像传统方式那样复制和声明类路径。这些类库可以让Gradle来管理。 现在来看看Gradle是如何工作的，如下图中所示 -

上图显示了Gradle工作的整个过程，下面我们一步步来说明。

在build.gradle中声明了该项目依赖于common-lang3库版本3.0。

当使用Gradle工具刷新项目时，Gradle将检查指定的依赖库是否在计算机上有本地存储库。 如果没有，Gradle将从互联网的存储库中下载到本地。

最后，Gradle将自动声明Classpath。

所以只需要在build.gradle文件中声明所有想要使用的库，这些库由Gradle自己管理。

5-查看本地存储库

你会不会有这样的一个问题：本地存储库在我电脑的什么位置？如果是按上面所有套路来创建工程，那么看下图就知道了 -

而上面配置中使用到的 commons-lang3 库的路径在 C:/Users/Administrator/.gradle/caches/modules-2/files-2.1/org.apache.commons，如下图所示 -

6- Gradle位置配置

默认情况下，Gradle软件将通过 Eclipse 下载到C:/Users/{username}/.gradle目录中。但是可以将配置更改其位置。例如想要把这个下载目录修改为 D:/worksp/gradle/Downloads，那么可以按照以下操作来配置。

在 Eclipse 菜单中，打开 Window -> References 选择目录 D:/worksp/gradle/Downloads，如下图所示 -

右键单击项目，然后选择 Gradle -> Refresh Gradle Project，Gradle将重新下载到刚刚设置的新文件夹。如下图所示 -

7-在网络查看Gradle存储库

问题：在哪里查找信息groupId，artifactId和版本呢？
可以去网站： http://mvnrepository.com ，例如在我们上面示例使用的 common-lang3 ，可在网站中搜索找到打开URL：http://mvnrepository.com/artifact/org.apache.commons/commons-lang3
如下图中所示 -

可根据你想要的一个版本，找到 gradle 的相关信息，如下所示 -

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Gradle 15分钟入门教程

创建Gradle Java Web应用程序并在Tomcat上运行 - Gradle教程™

1- 创建Gradle工程

打开 Eclipse ，在菜单中找到 File -> New -> Other…，在打开界面中选择 Gradle Project，如下图中所示 -

点击下一步（Next），如下图中所示，并继续点击下一步（Next） -

在新打开的界面中输入项目代码的名称，这里我们创建一个名称为 GradleWebApp 如下图所示-

在新打开界面中，选择 Gradle 的安装目录，如下图中所示，并继续点击下一步（Next）-

构建完成后，点击完成（Finish）即可，界面提示如下 -

项目创建完成后，它的一个初始结构如下图中所示：

2- 配置Gradle

这是Eclipse所创建的build.gradle文件的默认内容，这里我们删除所有注释：

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {

   compile 'org.slf4j:slf4j-api:1.7.21'

   testCompile 'junit:junit:4.12'

}

接下来需要将应用程序的配置添加“WEB应用程序”。并且可以让这个项目可直接在 Eclipse+Tomcat 插件上运行。修改build.gradle文件的添加一些代码内容，如下所示 -

apply plugin: 'java'
apply plugin: 'war'
apply plugin: 'com.bmuschko.tomcat'

repositories {
    jcenter()
}

dependencies {

    testCompile 'junit:junit:4.12'

    providedCompile "javax.servlet:javax.servlet-api:3.1.0"

}

dependencies {
    def tomcatVersion = '7.0.59'

    tomcat "org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}",
           "org.apache.tomcat.embed:tomcat-embed-logging-juli:${tomcatVersion}",
           "org.apache.tomcat.embed:tomcat-embed-jasper:${tomcatVersion}"
}

buildscript {

    repositories {
        jcenter()
    }

    dependencies {
        classpath 'com.bmuschko:gradle-tomcat-plugin:2.2.2'
    }
}

注意，每次build.gradle内容有发生变化时，需要使用Gradle工具来更新项目。如下图中所示 -

3-编辑应用程序结构

In “src/main” folder, you need to create 2 sub folders are “resources” and “webapp”.

在”src/main“文件夹中，需要创建2个子文件夹，分别为“resources”和“webapp”。

src/main/java: 此文件夹中存放 java 源文件代码。

src/main/resources: 此文件夹中可以存放属性文件和其他资源。

src/main/webapp: 此文件夹包含jsp和其他Web应用程序内容。

创建完成后，目录结构如下图中所示 -

项目代码

创建一个简单的类，叫作 Greeting.java 在 gradlewebapp.bean 包下，其项目结构和代码如下所示 -

Greeting.java 文件的源代码如下所示 -

package com.yiibai.gradlewebapp.bean;

public class Greeting {

    public String getHello()  {
        return "Hello Gradle Web Application";
    }
}

接下来，我们还要创建一个简单的JSP页面，在 webapp 目录下创建一个 hello.jsp 文件，如下图所示 -

hello.jsp 文件的代码如下所示 -

<!DOCTYPE html>
<html>
<head>

<meta charset="UTF-8">

<title>Hello Gradle Web App</title>
</head>
<body>

<jsp:useBean id="greeting" class="com.yiibai.gradlewebapp.bean.Greeting"/>

<h3>${greeting.hello}</h3>

</body>
</html>

5- Gradle构建

在 Eclipse 菜单中 Window -> Show View -> Other... -> Gradle -> Gradle Tasks 打开“Gradle任务”视图。如下所示 -

Right-click on “build” and select “Run Gradle Tasks”.

右键单击“build”并选择“Run Gradle Tasks”，如下图中所示 -

查看 Gradle Executions 选项卡，应该看到执行的任务的列表。

注意，如果出现类似错误：Gradle Could not find tools.jar. Please check that ...，则在右键单击“build” 选择“Create Gradle Run Configurate...”(第二个选项)并对应JDK安装的目录，重新构建编译即可，如下图中所示 -

构建成功，输出结果如下所示 -

Working Directory: D:/worksp/GradleWebApp
Gradle User Home: D:/worksp/gradle/Downloads
Gradle Distribution: Local installation at D:/worksp/yiibai.com/gradle-3.1
Gradle Version: 3.1
Java Home: D:/Program Files/Java/jdk1.8.0_65
JVM Arguments: None
Program Arguments: None
Gradle Tasks: build

:compileJava
:processResources UP-TO-DATE
:classes
:war
:assemble
:compileTestJava
:processTestResources UP-TO-DATE
:testClasses
:test
:check
:build

BUILD SUCCESSFUL

Total time: 8.521 secs

6-配置以运行应用程序

在项目名称上点击右键，在弹出的菜单选项中选择 Run As -> Run Configurations... 在弹出的界面中选择 “New”，如下图中所示 -

输入以下几个内容：

Name: Run GradleWebApp

Gradle Tasks: tomcatRun

Working Directory: ${workspace_loc:/GradleWebApp}

如有必要，还需要指定 Gradle和JDK的安装的目录，最终的结果如下图所示 -

如果是第一次运行，可能还要下载一些应用程序，所以需要等待一段时间…找点咖啡之类的东西喝先。
运行成功后，应该可以看到类似下面的输出结果 -

Working Directory: D:/worksp/GradleWebApp
Gradle User Home: D:/worksp/gradle/Downloads
Gradle Distribution: Local installation at D:/worksp/yiibai.com/gradle-3.1
Gradle Version: 3.1
Java Home: D:/Program Files/Java/jdk1.8.0_65
JVM Arguments: None
Program Arguments: None
Gradle Tasks: tomcatRun

:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:tomcatRun
Download https://jcenter.bintray.com/org/apache/tomcat/embed/tomcat-embed-core/7.0.59/tomcat-embed-core-7.0.59.pom
Download https://jcenter.bintray.com/org/apache/tomcat/embed/tomcat-embed-logging-juli/7.0.59/tomcat-embed-logging-juli-7.0.59.pom
Download https://jcenter.bintray.com/org/apache/tomcat/embed/tomcat-embed-jasper/7.0.59/tomcat-embed-jasper-7.0.59.pom
Download https://jcenter.bintray.com/org/apache/tomcat/embed/tomcat-embed-el/7.0.59/tomcat-embed-el-7.0.59.pom
Download https://jcenter.bintray.com/org/eclipse/jdt/core/compiler/ecj/4.4/ecj-4.4.pom
Download https://jcenter.bintray.com/org/apache/tomcat/embed/tomcat-embed-core/7.0.59/tomcat-embed-core-7.0.59.jar
Download https://jcenter.bintray.com/org/apache/tomcat/embed/tomcat-embed-logging-juli/7.0.59/tomcat-embed-logging-juli-7.0.59.jar
Download https://jcenter.bintray.com/org/apache/tomcat/embed/tomcat-embed-jasper/7.0.59/tomcat-embed-jasper-7.0.59.jar
Download https://jcenter.bintray.com/org/apache/tomcat/embed/tomcat-embed-el/7.0.59/tomcat-embed-el-7.0.59.jar
Download https://jcenter.bintray.com/org/eclipse/jdt/core/compiler/ecj/4.4/ecj-4.4.jar
Started Tomcat Server
The Server is running at http://localhost:8080/GradleWebApp

打开浏览器，输入URL：http://localhost:8080/GradleWebApp/hello.jsp ，得到以下显示结果。

注意：您还可以使用Gradle Tomcat插件来创建其他任务：

任务名称 | 类型 | 描述
tomcatRun | TomcatRun | 启动Tomcat实例并部署浏览Web应用程序
tomcatRunWar | TomcatRunWar | 启动Tomcat实例并将WAR部署它
tomcatStop | TomcatStop | 停止Tomcat实例
tomcatJasper | tomcatJasper | 运行JSP编译器，并使用Jasper将JSP页面转换为Java源代码

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » 创建Gradle Java Web应用程序并在Tomcat上运行

使用Gradle构建多模块项目 - Gradle教程™

1- 介绍

本教程文章基于：

Eclipse Java EE IDE for Web Developers. Version: Mars.1 Release (4.5.1)

如果您是初学者Gradle的。那么建议先看看初学者Gradle（Gradle Hello world）的文章：
http://www.yiibai.com/gradle/gradle-tutorial-for-beginners.html

2- 示例模型

这是本文章中的模型示例。如下图所示 -

本文章教程的目的是：

如何在Gradle中使用其他模块在一个模块中；

使用Gradle打包多个模块（输出为：jar，war）；

在Gradle Tomcat插件上运行Web应用程序；

MathWebApp: 这是一个WebApp项目；
MathLibrary: 这是一个库项目，包含MathWebApp使用的实用程序类。

GradleMain：将打包上面的两个项目，它是一个主要模块。GradleMain 将：

将 MathLibary 打包装到jar文件中；

将 MathWebApp 打包装到war文件中；

3-创建项目数学库

创建一个 Gradle 项目，在 Eclipse 菜单中，File/New/Other… 找到 Gradle 如下图所示 -

点击下一步（Next>）并输入项目名称: MathLibrary，如下图所示 -

点击下一步（Next>）并选择 Gradle 的安装目录，如下图所示 -

点击下一步（Next>），等待 Eclipse 创建项目，最后点击完成（Finish）就好。如下图所示 -

项目创建完成后，其结构如下图中所示 -

接下来，我们创建一个 MathUtils类，如下所示:

MathUtils类的代码实现如下所示 -

package com.yiibai;

public class MathUtils {

      public static int sum(int a, int b) {
          return a + b;
      }

    }

4- 创建另一个项目：MathWebApp

同样地，创建另外一个叫作 MathWebApp 的Gradle项目，参考上面 MathLibrary 项目创建的步骤。

打开 build.gradle 文件，并添加一些依懒库，如下图中所示 -

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'war'

apply plugin: 'com.bmuschko.tomcat'

repositories {
   jcenter()
}

dependencies {

   testCompile 'junit:junit:4.12'

   providedCompile "javax.servlet:javax.servlet-api:3.1.0"

   compile project(':MathLibrary')
}

dependencies {
   def tomcatVersion = '7.0.59'

   tomcat "org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}",
          "org.apache.tomcat.embed:tomcat-embed-logging-juli:${tomcatVersion}",
          "org.apache.tomcat.embed:tomcat-embed-jasper:${tomcatVersion}"
}

buildscript {

   repositories {
       jcenter()
   }

   dependencies {
       classpath 'com.bmuschko:gradle-tomcat-plugin:2.2.2'
   }
}

完成后，执行 Gradle Project Refresh-

创建index.jsp文件，并在这个JSP文件中使用在项目Math Library中创建的MathUtils类。

index.jsp 文件的代码如下所示 -

<html>
<body>
<h2>Hello World!</h2>

<%

int a = 200;
int b = 300;

int c = com.yiibai.MathUtils.sum(a,b);

out.println("<h2>"+ c+"</h2>");

%>

</body>
</html>

5- 创建GradleMain项目

同样地，我们再来创建一个Gradle项目：GradleMain 。完成其项目结构如下图所示 -

打开 GradleMain/settings.gradle 修改其内容如下 -

rootProject.name = 'GradleMain'

include   ':MathLibrary', ':MathWebApp'
project(':MathLibrary').projectDir = new File(settingsDir, '../MathLibrary')
project(':MathWebApp').projectDir = new File(settingsDir, '../MathWebApp')

并声明GradleMain依赖于MathLibrary＆MathWebApp这两个项目。编辑 GradleMain/build.gradle 代码内容如下-

apply plugin: 'java'
apply plugin: 'eclipse'

repositories {
    jcenter()
}

dependencies {

    testCompile 'junit:junit:4.12'
}

dependencies {
    compile project(':MathLibrary')
    compile project(':MathWebApp')
}

完成后，执行 Gradle Project Refresh-

6- 构建项目

切换到标签“Gradle Task”，然后选择“build/Run Gradle Tasks”。执行结果如下图所示 -

Gradle将按项目的顺序构建完成，结果如下：

Working Directory: D:/worksp/GradleMain
Gradle User Home: D:/worksp/gradle/Downloads
Gradle Distribution: Local installation at D:/worksp/yiibai.com/gradle-3.1
Gradle Version: 3.1
Java Home: D:/Program Files/Java/jdk1.8.0_65
JVM Arguments: None
Program Arguments: None
Gradle Tasks: build

:MathLibrary:compileJava
:MathLibrary:processResources UP-TO-DATE
:MathLibrary:classes
:MathLibrary:jar
:MathWebApp:compileJava
:MathWebApp:processResources UP-TO-DATE
:MathWebApp:classes
:MathWebApp:jar
:compileJava
:processResources UP-TO-DATE
:classes
:jar
:assemble
:compileTestJava
:processTestResources UP-TO-DATE
:testClasses
:test
:check
:build
:MathLibrary:assemble
:MathLibrary:compileTestJava
:MathLibrary:processTestResources UP-TO-DATE
:MathLibrary:testClasses
:MathLibrary:test
:MathLibrary:check
:MathLibrary:build
:MathWebApp:war
:MathWebApp:assemble
:MathWebApp:compileTestJava
:MathWebApp:processTestResources UP-TO-DATE
:MathWebApp:testClasses
:MathWebApp:test
:MathWebApp:check
:MathWebApp:build

BUILD SUCCESSFUL

Total time: 3.619 secs

7- 运行MathWebApp

在 MathWebApp 项目上右键点击，在弹出的菜单中选择 “Run As“ -> “Run Configurations ...“，在弹出的对话框中，在 “Gradle Project” 右键点击选择 “New”，如下图所示 -

然后写入一些必要的参数，如下图中红圈的输入部分 -

执行后，在终端上输出结果如下-

Working Directory: D:/worksp/GradleMain
Gradle User Home: D:/worksp/gradle/Downloads
Gradle Distribution: Local installation at D:/worksp/yiibai.com/gradle-3.1
Gradle Version: 3.1
Java Home: D:/Program Files/Java/jdk1.8.0_65
JVM Arguments: None
Program Arguments: None
Gradle Tasks: tomcatRun

:MathLibrary:compileJava UP-TO-DATE
:MathLibrary:processResources UP-TO-DATE
:MathLibrary:classes UP-TO-DATE
:MathLibrary:jar UP-TO-DATE
:MathWebApp:compileJava UP-TO-DATE
:MathWebApp:processResources UP-TO-DATE
:MathWebApp:classes UP-TO-DATE
:MathWebApp:tomcatRun
Started Tomcat Server
The Server is running at http://localhost:8080/MathWebApp

现在，我们打开浏览器访问 - http://localhost:8080/MathWebApp/ 得到以下结果 -

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » 使用Gradle构建多模块项目