# 使用Gradle构建Java项目
本指南将引导您逐步使用Gradle构建一个简单的Java项目。
## 你会建立什么
您将创建一个简单的应用程序，然后使用Gradle进行构建。
## 你需要什么
* 约15分钟
* 最喜欢的文本编辑器或IDE
* [JDK 6](https://www.oracle.com/technetwork/java/javase/downloads/index.html) 或更高版本
## 如何完成本指南
像大多数Spring 一样 [入门指南](https://spring.io/guides) ，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。 无论哪种方式，您最终都可以使用代码。
要 **从头开始** ，请继续以 [设置项目](https://spring.io/guides/gs/gradle/#scratch) 。
要 **跳过基础知识** ，请执行以下操作：
* [下载](https://github.com/spring-guides/gs-gradle/archive/master.zip) 并解压缩本指南的源存储库，或使用 对其进行克隆 [Git](https://spring.io/understanding/Git) ： `git clone [https://github.com/spring-guides/gs-gradle.git](https://github.com/spring-guides/gs-gradle.git)`
* 光盘进入 `gs-gradle/initial`
* 跳到 [安装Gradle](https://spring.io/guides/gs/gradle/#initial) 。
**完成后** ，您可以根据中的代码检查结果 `gs-gradle/complete`.
## 设置项目
首先，您设置了一个Java项目供Gradle构建。 为了将重点放在Gradle上，现在使该项目尽可能简单。
### 创建目录结构
在您选择的项目目录中，创建以下子目录结构； 例如， `mkdir -p src/main/java/hello` 在\* nix系统上：
~~~
└── src
└── main
└── java
└── hello
~~~
内 `src/main/java/hello`目录中，您可以创建所需的任何Java类。 为了简单起见并与本指南的其余部分保持一致，Spring建议您创建两个类： `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。
强烈建议使用安装程序：
* [开发人员](https://sdkman.io/)
* [家酿](https://brew.sh) （BREW的gradle安装）
万不得已，如果这些工具都不满足您的需求，则可以从 下载二进制文件 [https://www.gradle.org/downloads](https://www.gradle.org/downloads) 。 仅需要二进制文件，因此请查找gradle- 的链接 *version* \-bin.zip 。 （您也可以选择gradle- *version* \-all.zip来获取源代码和文档以及二进制文件。）
将文件解压缩到您的计算机，然后将bin文件夹添加到您的路径。
要测试Gradle的安装，请从命令行运行Gradle：
~~~
gradle
~~~
如果一切顺利，您会看到一条欢迎消息：
~~~
:help
Welcome to Gradle 6.0.1.
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
To see more detail about a task, run gradle help --task <task>
For troubleshooting, visit https://help.gradle.org
Deprecated Gradle features were used in this build, making it incompatible with Gradle 7.0.
Use '--warning-mode all' to show the individual deprecation warnings.
See https://docs.gradle.org/6.0.1/userguide/command_line_interface.html#sec:command_line_warnings
BUILD SUCCESSFUL in 455ms
1 actionable task: 1 executed
~~~
您现在已经安装了Gradle。
## 找出Gradle可以做什么
现在已经安装了Gradle，看看它能做什么。 在甚至为项目创建build.gradle文件之前，您都可以询问它有哪些可用的任务：
~~~
gradle tasks
~~~
您应该看到可用任务的列表。 假设您在尚未具有 夹中运行Gradle *build.gradle* 文件的文件 ，您将看到一些非常基本的任务，例如：
~~~
:tasks
------------------------------------------------------------
Tasks runnable from root project
------------------------------------------------------------
Build Setup tasks
-----------------
init - Initializes a new Gradle build.
wrapper - Generates Gradle wrapper files.
Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'gs-gradle'.
components - Displays the components produced by root project 'gs-gradle'. [incubating]
dependencies - Displays all dependencies declared in root project 'gs-gradle'.
dependencyInsight - Displays the insight into a specific dependency in root project 'gs-gradle'.
dependentComponents - Displays the dependent components of components in root project 'gs-gradle'. [incubating]
help - Displays a help message.
model - Displays the configuration model of root project 'gs-gradle'. [incubating]
outgoingVariants - Displays the outgoing variants of root project 'gs-gradle'.
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 gradle tasks --all
To see more detail about a task, run gradle help --task <task>
Deprecated Gradle features were used in this build, making it incompatible with Gradle 7.0.
Use '--warning-mode all' to show the individual deprecation warnings.
See https://docs.gradle.org/6.0.1/userguide/command_line_interface.html#sec:command_line_warnings
BUILD SUCCESSFUL in 477ms
1 actionable task: 1 executed
~~~
即使这些任务可用，但如果没有项目构建配置，它们也不会提供太多价值。 当你充实 `build.gradle`文件，一些任务会更有用。 当您向其中添加插件时，任务列表将增加 `build.gradle`，因此您偶尔会想 运行 **任务** 再次 以查看可用的任务。
说到添加插件，接下来您将添加一个启用基本Java构建功能的插件。
## 建立Java程式码
从简单开始，创建一个非常基础的 `build.gradle`您在本指南开头创建的中的文件。 只给它一行：
~~~
apply plugin: 'java'
~~~
构建配置中的这一行带来了巨大的力量。 运行 **gradle任务** 再次 ，您会看到新任务已添加到列表中，包括用于构建项目，创建JavaDoc和运行测试的任务。
您将 使用 **gradle构建** 经常 任务。 该任务将代码编译，测试并将其组装到一个JAR文件中。 您可以这样运行它：
~~~
gradle build
~~~
几秒钟后，“ BUILD SUCCESSFUL”表明构建已完成。
要查看构建工作的结果，请查看 *构建* 文件夹。 在其中，您将找到几个目录，包括以下三个著名的文件夹：
* *类* 。 项目的已编译.class文件。
* *报告* 。 构建生成的报告（例如测试报告）。
* *库* 。 组装的项目库（通常是JAR和/或WAR文件）。
classes文件夹包含.class文件，这些文件是通过编译Java代码生成的。 具体来说，您应该找到HelloWorld.class和Greeter.class。
此时，该项目没有任何库依赖关系，因此 没有任何内容 **dependency\_cache** 文件夹中 。
reports文件夹应包含项目上正在运行的单元测试的报告。 由于该项目尚无任何单元测试，因此该报告将变得毫无意义。
libs文件夹应包含以项目文件夹命名的JAR文件。 接下来，您将看到如何指定JAR的名称及其版本。
## 声明依赖
简单的Hello World示例是完全独立的，并且不依赖于任何其他库。 但是，大多数应用程序都依赖于外部库来处理常见和/或复杂的功能。
例如，假设除了说“ Hello World！”外，您还希望应用程序打印当前日期和时间。 您可以使用本机Java库中的日期和时间工具，但是可以使用Joda Time库使事情变得更有趣。
首先，将HelloWorld.java更改如下：
~~~
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 {
mavenCentral()
}
~~~
这 `repositories`块指示构建应从Maven Central存储库中解决其依赖项。 Gradle在很大程度上依赖于Maven构建工具建立的许多约定和功能，包括使用Maven Central作为库依赖源的选项。
现在我们已经准备好第三方库了，让我们声明一下。
~~~
sourceCompatibility = 1.8
targetCompatibility = 1.8
dependencies {
implementation "joda-time:joda-time:2.2"
testImplementation "junit:junit:4.12"
}
~~~
随着 `dependencies`块，您声明Joda Time的单个依赖项。 具体来说，您要在joda-time组中要求（从右到左阅读）joda-time库的2.2版。
关于此依赖项要注意的另一件事是，它是一个 `compile`依赖关系，指示它在编译时应该可用（如果正在构建WAR文件，则包含在WAR的/ WEB-INF / libs文件夹中）。 其他值得注意的依赖类型包括：
* `implementation`。 编译项目代码所需的依赖关系，但将在运行时由运行代码的容器（例如Java Servlet API）提供。
* `testImplementation`。 用于编译和运行测试的依赖关系，但对于构建或运行项目的运行时代码不是必需的。
最后，让我们为我们的JAR工件指定名称。
~~~
jar {
archiveBaseName = 'gs-gradle'
archiveVersion = '0.1.0'
}
~~~
这 `jar`块指定如何命名JAR文件。 在这种情况下，它将呈现 `gs-gradle-0.1.0.jar`.
现在，如果您运行 `gradle build`，Gradle应该从Maven Central存储库中解决Joda Time依赖关系，并且构建将成功。
## 使用Gradle Wrapper建立您的专案
Gradle包装器是开始Gradle构建的首选方法。 它由Windows的批处理脚本以及OS X和Linux的Shell脚本组成。 这些脚本使您可以运行Gradle构建，而无需在系统上安装Gradle。 这曾经是添加到您的构建文件中的东西，但是已经被折叠到Gradle中，因此不再需要。 相反，您只需使用以下命令。
~~~
$ gradle wrapper --gradle-version 6.0.1
~~~
该任务完成后，您会注意到一些新文件。 这两个脚本位于文件夹的根目录中，而包装jar和属性文件已添加到新文件夹中。 `gradle/wrapper` 文件夹。
~~~
└── <project folder>
└── gradlew
└── gradlew.bat
└── gradle
└── wrapper
└── gradle-wrapper.jar
└── gradle-wrapper.properties
~~~
Gradle包装器现在可用于构建您的项目。 将其添加到您的版本控制系统中，每个克隆您的项目的人都可以相同地构建它。 它的使用方式与Gradle的安装版本完全相同。 运行包装程序脚本以执行构建任务，就像之前一样：
~~~
./gradlew build
~~~
第一次为指定版本的Gradle运行包装程序时，它将下载并缓存该版本的Gradle二进制文件。 Gradle Wrapper文件旨在用于源代码控制，因此任何人都可以构建项目，而无需首先安装和配置特定版本的Gradle。
在这一阶段，您将构建代码。 您可以在此处查看结果：
~~~
build
├── classes
│ └── main
│ └── hello
│ ├── Greeter.class
│ └── HelloWorld.class
├── dependency-cache
├── libs
│ └── gs-gradle-0.1.0.jar
└── tmp
└── jar
└── MANIFEST.MF
~~~
包括两个预期的类文件 `Greeter` 和 `HelloWorld`，以及JAR文件。 快速浏览：
~~~
$ 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文件也不可运行。
为了使此代码可运行，我们可以使用gradle的 `application`插入。 将此添加到您的 `build.gradle` 文件。
~~~
apply plugin: 'application'
mainClassName = 'hello.HelloWorld'
~~~
然后，您可以运行该应用程序！
~~~
$ ./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插件](https://www.gradle.org/docs/current/userguide/war_plugin.html) 。 如果您使用的是Spring Boot，并且想要一个可运行的JAR文件，则 [spring-boot-gradle-plugin](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using-boot-gradle) 非常方便。 在此阶段，gradle对您的系统了解不足，无法做出选择。 但是就目前而言，这应该足以开始使用gradle。
总结一下本指南的内容，以下是完成的内容 `build.gradle` 文件：
`build.gradle`
~~~
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'application'
mainClassName = 'hello.HelloWorld'
// tag::repositories[]
repositories {
mavenCentral()
}
// end::repositories[]
// tag::jar[]
jar {
archiveBaseName = 'gs-gradle'
archiveVersion = '0.1.0'
}
// end::jar[]
// tag::dependencies[]
sourceCompatibility = 1.8
targetCompatibility = 1.8
dependencies {
implementation "joda-time:joda-time:2.2"
testImplementation "junit:junit:4.12"
}
// end::dependencies[]
// tag::wrapper[]
// end::wrapper[]
~~~
这里嵌入了许多开始/结束注释。 这样就可以将构建文件的某些内容提取到本指南中，以进行上述详细说明。 您的生产构建文件中不需要它们。
## 概括
恭喜你！ 现在，您已经创建了一个简单而有效的Gradle构建文件，用于构建Java项目。
- springboot概述
- springboot构建restful服务
- spring构建一个RESTful Web服务
- spring定时任务
- 消费RESTful Web服务
- gradle构建项目
- maven构建项目
- springboot使用jdbc
- springboot应用上传文件
- 使用LDNA验证用户
- 使用 spring data redis
- 使用 spring RabbitTemplate消息队列
- 用no4j访问nosql数据库
- springboot验证web表单
- Spring Boot Actuator构j建服务
- 使用jms传递消息
- springboot创建批处理服务
- spring security保护web 安全
- 在Pivotal GemFire中访问数据
- 使用Spring Integration
- 使用springboot jpa进行数据库操作
- 数据库事务操作
- 操作mongodb
- springmvc+tymleaf创建web应用
- 将Spring Boot JAR应用程序转换为WAR
- 创建异步服务
- spring提交表单
- 使用WebSocket构建交互式Web应用程序
- 使用REST访问Neo4j数据
- jquery消费restful
- springboot跨域请求
- 消费SOAP Web服务
- springboot使用缓存
- 使用Vaadin创建CRUD UI
- 使用REST访问JPA数据
- 使用REST访问Pivotal GemFire中的数据
- 构建soap服务
- 使用rest访问mongodb数据
- 构建springboot应用docker镜像
- 从STS部署到Cloud Foundry
- springboot测试web应用
- springboot访问mysql
- springboot编写自定义模块并使用
- 使用Google Cloud Pub / Sub进行消息传递
- 构建反应式RESTful Web服务
- 使用Redis主动访问数据
- Spring Boot 部署到Kubernetes
- 使用反应式协议R2DBC访问数据
- Spring Security架构
- spring构建Docker镜像详解
- Spring Boot和OAuth2
- springboot应用部署到k8s
- spring构建rest服务详解