使用 Gradle 构建 Java 项目

使用 Gradle 构建 Java 项目

这个手册将经过一个简单的 Java 项目向你们介绍如何使用 Gradle 构建 Java 项目。

咱们将要作什么？

咱们将在这篇文档航中建立一个简单的 Java 项目，而后使用 Gradle 构建它。

须要准备什么？

• 预留15分钟空闲时间
• 一件称手的兵器（你最喜欢的 IDE 或者文本编辑器）
• Java环境（[JDK6](http://www.oracle.com/technetwork/java/javase/downloads/index.html”JDK”及以上版本）

如何完成这个手册的内容？

与大多数 Spring 的入门手册同样，你能够从头开始一步步完成教程中的每一步工做，也能够跳过你已经烂熟的基础步骤。无论采用那种方式，你最后都会获得可工做的代码。

1. 若是要重头开始，猛戳这里
2. 若是要跳过基础部分，需执行如下操做：
   • 下载并解压本文档相关源代码，或者使用Git克隆一个：git clone https://github.com/spring-guides/gs-gradle.git
   • cd 进入 gs-gradle/initial
   • 参考到安装Gradle部分

当你完成后，你可使用 gs-gradle/complete 来检查你的结果。

配置项目

首先须要配置一个项目给 Gradle 进行构建。为了保证咱们能专一于 Gradle，目前最好建立最简单的Java项目。

建立目录结构

在项目主目录下，建立如下子目录;在 *nix 系统下可使用命令：

mkdir -p src/main/java/hello

 

└── src
    └── main
        └── java
            └── hello

在 src/main/java/hello 目录中，你能够建立任何 Java 类。为简单起见而且为了与指南的其他部分保持一致，咱们建议建立两个类 HelloWorld.java 和 Greeter.java

 

src/main/java/hello/HelloWorld.java 的源代码：

package hello;
 
public class HelloWorld {
  public static void main(String[] args) {
    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}

src/main/java/hello/Greeter.java 的源代码：

package hello;
 
public class Greeter {
  public String sayHello() {
    return "Hello world!";
  }
}

 

安装Gradle

到目前为止，咱们已经搭建了一个能够用来使用 Gradle 构建的项目，如今到了安装Gradle的时候了。

Gradle能够从 http://www.gradle.org/downloads 下载。咱们仅须要下载Gradle的二进制发布包，因此在刚才提供的链接上寻找 gradle-version-bin.zip 文件

（固然，也能够下载 gradle-version-all.zip，它包含源代码、文档以已编译代码）

解压缩下载的文件，并将解压后目录中的 bin 目录加到环境变量中。

能够在命令行中执行如下代码来测试 Gradle 是否安装成功

> gradle

若是你很幸运，嘛事都OK，你会看到下面的welcome信息：

:help
 
Welcome to Gradle 1.8.
 
To run a build, run gradle <task> ...
 
To see a list of available tasks, run gradle tasks
 
To see a list of command-line options, run gradle --help
 
BUILD SUCCESSFUL
 
Total time: 2.675 secs

看到这个了，说明Gradle已经成功安装到系统中了。若是没看到……再去看看 Gradle的手册 先。

Gradle能够作些什么呢？

Gradle已经安装到系统上了，那么它能够作什么呢？在咱们为项目建立 build.gradle 文件以前，咱们能够先问一下Gradle目前有哪些可用的任务（Tasks）：

gradle tasks

咱们能够看到可用任务（Tasks）的列表。假设你执行Gradle的目录不存在 build.gradle 文件，你能够看到一些很是基础的任务，相似于：

:tasks
 
== All tasks runnable from root project
 
== Build Setup tasks
setupBuild - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]
 
== Help tasks
dependencies - Displays all dependencies declared in root project 'gs-gradle'.
dependencyInsight - Displays the insight into a specific dependency in root project 'gs-gradle'.
help - Displays a help message
projects - Displays the sub-projects of root project 'gs-gradle'.
properties - Displays the properties of root project 'gs-gradle'.
tasks - Displays the tasks runnable from root project 'gs-gradle'.
 
To see all tasks and more detail, run with --all.
 
BUILD SUCCESSFUL
 
Total time: 3.077 secs

尽管上面的列出的任务是可用的，可是若是没有项目的构建配置他们没法提供太多的价值。当配置了项目的 build.gradle 后，一些任务将变得很是有用。

若是在 build.gradle 中配置了插件(plugins)上面的任务列表会变得更长，最好在配置插件后使用 gradle task 看看那些任务是可用的。

刚说到配置插件，立刻咱们就会配置一个插件来启用基础的 Java 构建功能。

 

构建Java代码

先从简单的开始，建立一个最简单的只有一行的 build.gradle 文件：

apply plugin: 'java'

别看只有一行配置，提供的能力可不是一点点哦。再执行一下gradle task，咱们能够看到任务列表中增长了一些内容，

好比：用来编译java项目的任务、用来建立JavaDoc的任务、用来执行单元测试的任务。

咱们常用的任务是gradle build，这个任务执行如下操做：编译、执行单元测试、组装Jar文件：

gradle build

几秒钟之后，会看到”BUILD SUCCESSFUL”输出，说明构建已经完成了。

能够到”build”目录中查看构建结构，在这个目录中咱们能够看到不少子目录，其中有三个咱们须要特别注意：

• classes: 保存被编译后的.class文件
• reports: 构建报告（如：测试报告）
• lib: 组装好的项目包（一般为：.jar或者.war文件）

classes目录包含编译生成的全部.class文件。执行完编译后，咱们应该能够在这里找到”HelloWorld.class”和”Greeter.class”。

到目前为止，咱们项目并无申明任何依赖，因此”debendency_cache”目录是空的。

“reports”目录会包含项目单元测试的测试报告，固然，当前项目并未编写任何单元测试，因此，也是空目录。

“lib”目录包含打包后的jar或war文件，在后面的内容中咱们将学会如何定义JAR的名称和版本号。

 

申明依赖

咱们的Hello World例程很是简单且不依赖于任何第三方库，可是大多数应用程序都会依赖第三方库提供的通用或复杂的功能。

例如：假设咱们但愿更好的说”Hello World!”，咱们但愿应用程序能同时输出当前的日期和时间。

固然这可使用Java自身的日期和时间相关库，可是咱们可使用”Joda Time”库实现更有趣的功能。

首先，把HelloWorld.jara类修改为下面这样：

package hello;
 
import org.joda.time.LocalTime;
 
public class HelloWorld {
  public static void main(String[] args) {
    LocalTime currentTime = new LocalTime();
    System.out.println("The current local time is: " + currentTime);
 
    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}

这里咱们的HelloWorld使用”Joda Time”的LocalTime类来获取和输出当前时间。

若是咱们立刻执行gradle build来构建项目，构建过程将会失败，由于咱们并未将”Joda Time”库声明为编译时依赖库。

首先，咱们须要添加一些配置来定义第三方库的来源：

repositories {
    mavenLocal()
    mavenCentral()
}

上面的repositories定义，告诉构建系统经过Maven中央库来检索项目依赖的软件包，

Gradle在很大程度上依赖Maven构建工具的许多约定和基础功能,包括使用Maven中央的库来处理依赖关系。

如今咱们可使用第三方库了，但现须要定义：

dependencies {
    compile "joda-time:joda-time:2.2"
}

使用dependencies块，咱们定义了一条Joda Time的依赖项。这里，明确指定使用joda-time组内的版本为2.2的joda-time库。

另外一个要注意的是，咱们在这个依赖定义中指定依赖是compile范围的。意思是，这个库在编译和运行时都须要

（若是咱们正在构建WAR文件，这个文件会在/WEB-INF/libs目录下）。另外值得注意的依赖类型包括：

• providedCompile：在编译期间须要这个依赖包，但在运行期间可能由容器提供相关组件（好比：Java Servlet API）
• testCompile：依赖项仅在构建和运行测试代码时须要，在项目运行时不须要这个依赖项。

最后，咱们来定义咱们将生成的Jar文件的名字：

jar {
    baseName = 'gs-gradle'
    version =  '0.1.0'
}

jar块定义如何命名JAR文件，在上面的例子中，咱们的JAR文件的名字为：gs-gradle-0.1.0.jar。

注：这个时候若是执行 gradle build，Gradle会花一些时间从 Maven 中央库下载 Joda Time 包（具体下载时间依赖于你的网速）

 

使用Gradle Wrapper来构建项目

Gradle Wrapper是开始一个Gradle构建的首选方式。它包含了windows批处理以及OS X和Linux的Shell脚本。

这些脚本容许咱们在没有安装Gradle的系统上执行Gradle构建。要实现这个功能，咱们须要在咱们的build.gradle文件中增长如下代码：

task wrapper(type: Wrapper) {
    gradleVersion = '1.11'
}

执行下面代码来下载和初始化wrapper脚本:

gradle wrapper

命令执行完后，咱们能够看到增长了一些新文件。有两个文件在根目录下，

wapper 的 jar 文件和 properties 文件在新增的 gradle/wrapper 目录下。

└── initial
    └── gradlew
    └── gradlew.bat
    └── gradle
        └── wrapper
            └── gradle-wrapper.jar
            └── gradle-wrapper.properties

如今Gradle Wrapper已经能够用来构建系统了。把这些文件增长到版本控制系统中，

而后再任什么时候候、任何地方只要迁出这些文件就一个按照一样的方式（与当前生成 Wrapper的Gradle版本一致）构建系统。

运行wrapper脚原本构建系统，跟咱们以前桥的命令很像：

./gradlew build

当第一次经过wrapper使用指定版本的Gradle构建系统时，wrapper首先下载对应版本的Gradle可执行文件。

Gradle Wrapper 的全部文件在均可以被提交到版本库中，因此，任何人均可以在没有安装Gradle的环境下使用相同版本的 Gradle构建系统。

在这个时候，咱们须要从新构建咱们的代码，构建的结果目录以下：

build
├── classes
│   └── main
│       └── hello
│           ├── Greeter.class
│           └── HelloWorld.class
├── dependency-cache
├── libs
│   └── gs-gradle-0.1.0.jar
└── tmp
    └── jar
        └── MANIFEST.MF

Jar 文件中包含咱们但愿打包的 Gretter 和 HelloWorld 类。

$ jar tvf build/libs/gs-gradle-0.1.0.jar
  0 Fri May 30 16:02:32 CDT 2014 META-INF/
 25 Fri May 30 16:02:32 CDT 2014 META-INF/MANIFEST.MF
  0 Fri May 30 16:02:32 CDT 2014 hello/
369 Fri May 30 16:02:32 CDT 2014 hello/Greeter.class
988 Fri May 30 16:02:32 CDT 2014 hello/HelloWorld.class

须要注意的,即便咱们声明了joda-time依赖,但这里也没有包括对应的库文件，并且生成的JAR文件也不是可运行JAR文件。

要想让代码能够运行，咱们可使用Gradle的application插件。增长如下内容到build.gradle文件中。

apply plugin: 'application'
 
mainClassName = 'hello.HelloWorld'

如今咱们的app能够执行了。

$ ./gradlew run
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:run
The current local time is: 16:16:20.544
Hello world!
 
BUILD SUCCESSFUL
 
Total time: 3.798 secs

为了可以将依赖包也以一块儿打包，好比，咱们但愿构建一个 WAR 包，能够包含第三方组件的打包格式，

咱们可使用 Gradle 的WAR插件。若是咱们使用Spring Boot而且但愿获得一个可执行的JAR文件，

咱们可使用 spring-boot-gradle-plugin 插件。在咱们的示例中，gradle没有足够的信息来了解咱们的目标系统。

可是，目前介绍的内容已经足够咱们开始使用Gradle了。

下面是本文须要用的的build.gradle文件：

apply plugin: 'java'
apply plugin: '<span class="wp_keywordlink"><a href="http://res.importnew.com/eclipse" title="Eclipse ImportNew主页" target="_blank">Eclipse</a></span>'
apply plugin: 'application'
 
mainClassName = 'hello.HelloWorld'
 
// tag::repositories[]
repositories {
    mavenLocal()
    mavenCentral()
}
// end::repositories[]
 
// tag::jar[]
jar {
    baseName = 'gs-gradle'
    version =  '0.1.0'
}
// end::jar[]
 
// tag::dependencies[]
dependencies {
    compile "joda-time:joda-time:2.2"
}
// end::dependencies[]
 
// tag::wrapper[]
task wrapper(type: Wrapper) {
    gradleVersion = '1.11'
}
// end::wrapper[]

注意：文件中有不少start/end注释，这些注释是为了方便拷贝文件中的内容到文章的各个部分，在实际使用中不须要包含他们。

总结

恭喜，你已经建立了一个简单的然而可用的Gradle构建文件来构建Java项目。

 

好吧， 感谢看到这 

原文摘自：http://www.importnew.com/15881.html

 —> http://spring.io/guides/gs/gradle/