关于java:Gradle极简入门

首发于 Enaium 的集体博客

什么是 Gradle

Gradle是一个基于 Apache Ant 和Apache Maven概念的我的项目自动化构建工具。它应用一种基于 Groovy 的特定畛域语言 (DSL) 来申明我的项目设置，而不是传统的 XML。Gradle 构建脚本是用 Groovy 编写的，也能够应用 Kotlin 编写，两者都是基于 JVM 的语言。

装置 Gradle

在开始之前，想必大家曾经学会了 Java 或者 Kotlin，当初大家都在应用Android Studio 开发 Android 利用，Android Studio是基于 IntelliJ IDEA 开发的，但当初不从 Android Studio 的角度来讲，也不从 IntelliJ IDEA 的角度来讲，而是从 Gradle 的角度来讲，所以咱们须要去官网下载 Gradle，而后在IntelliJ IDEA 中去应用Gradle。

首先去官网下载 Gradle，下载地址：https://gradle.org/releases/，之后点击最新版本中的binary-only，这会间接下载一个zip 压缩包，下载实现后解压到一个目录，而后再配置环境变量到 bin 目录，这样就能够在 Terminal 中应用 gradle 命令了，因为 Java 跨平台的缘故，在其余的操作系统上配置环境变量的形式都是大相不差的，这里我就不再赘述了，如果不会配置环境变量的话，能够去网上搜寻一下，这里我就不再赘述了。

配置好环境变量之后，关上 Terminal，输出gradle -v，如果呈现上面的信息，阐明Gradle 装置胜利了。

------------------------------------------------------------
Gradle 8.1
------------------------------------------------------------

Build time:   2023-04-12 12:07:45 UTC
Revision:     40ba32cde9d6daf2b92c39376d2758909dd6b813

Kotlin:       1.8.10
Groovy:       3.0.15
Ant:          Apache Ant(TM) version 1.10.11 compiled on July 10 2021
JVM:          17.0.6 (BellSoft 17.0.6+10-LTS)
OS:           Windows 10 10.0 amd64

创立 Hello World 我的项目

创立一个文件夹，而后在文件夹中关上Terminal，输出gradle init，之后依照我的步骤来。

Select type of project to generate:
  1: basic
  2: application
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 2 // 抉择 application

Select implementation language:
  1: C++
  2: Groovy
  3: Java
  4: Kotlin
  5: Scala
  6: Swift
Enter selection (default: Java) [1..6] 3 // 抉择 Java

Generate multiple subprojects for application? (default: no) [yes, no] // 默认 no

Select build script DSL:
  1: Groovy
  2: Kotlin
Enter selection (default: Groovy) [1..2] 2 // 抉择 Kotlin

Select test framework:
  1: JUnit 4
  2: TestNG
  3: Spock
  4: JUnit Jupiter
Enter selection (default: JUnit Jupiter) [1..4] // 默认 JUnit Jupiter

Project name (default: gradle_learn):
Source package (default: gradle_learn): cn.enaium
Enter target version of Java (min. 7) (default: 17): // 默认 17
Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] // 默认 no


> Task :init
Get more help with your project: https://docs.gradle.org/8.1/samples/sample_building_java_applications.html

BUILD SUCCESSFUL in 32s // 构建胜利
2 actionable tasks: 2 executed

如果最初呈现BUILD SUCCESSFUL，阐明我的项目创立胜利了，当初咱们来看一下我的项目的构造，这里先简略的介绍一下，前面会具体的介绍。

│  .gitattributes // git 配置文件
│  .gitignore // git 配置文件
│  gradlew // gradle 脚本, 当你没有装置 gradle 的时候，能够应用这个脚本来构建我的项目
│  gradlew.bat // windows 下的 gradlew 脚本
│  settings.gradle.kts // gradle 的 settings 配置文件
│  
├─.gradle
├─app // 我的项目模块, 这是一个子项目
│  │  build.gradle.kts // app 模块的 build 配置文件
│  │  
│  └─src // app 模块的源码
│      ├─main
│      │  ├─java
│      │  │  └─cn
│      │  │      └─enaium
│      │  │              App.java
│      │  │              
│      │  └─resources
│      └─test
│          ├─java
│          │  └─cn
│          │      └─enaium
│          │              AppTest.java
│          │              
│          └─resources
└─gradle // gradle 的 wrapper 配置文件, 当你没有装置 gradle 的时候，脚本会自应用 wrapper 来下载 gradle
    └─wrapper
            gradle-wrapper.jar
            gradle-wrapper.properties // gradle 的 wrapper 配置文件, 下载的 gradle 版本，下载地址等

运行我的项目，关上 Terminal，输出gradle run，如果呈现上面的信息，阐明我的项目运行胜利了，这里我的项目中自带了一个Guava 库和 JUnit 库，如果嫌下载太慢的话，能够本人去 build.gradle.kts 中删除掉。

> Task :app:run                                                                                                         
Hello World!

BUILD SUCCESSFUL in 10s
2 actionable tasks: 2 executed

删掉

dependencies {
    // Use JUnit Jupiter for testing.
    testImplementation("org.junit.jupiter:junit-jupiter:5.9.1")

    // This dependency is used by the application.
    implementation("com.google.guava:guava:31.1-jre")
}

tasks.named<Test>("test") {
    // Use JUnit Platform for unit tests.
    useJUnitPlatform()}

我的项目构造

settings.gradle.kts

settings.gradle.kts是 Gradle 的配置文件，这个文件中配置了我的项目的名称和模块，这里的模块指的是 app 模块，这个模块是 Gradle 默认创立的，如果你想创立其余的模块，能够在这里配置。

// 这个是 gradle 创立时自带的一个插件，这个插件能够主动下载 jdk
plugins {
    // Apply the foojay-resolver plugin to allow automatic download of JDKs
    id("org.gradle.toolchains.foojay-resolver-convention") version "0.4.0"// 插件的 ID 和版本，这里的插件会从 Gradle 的插件仓库中下载，构造和 Maven 仓库相似
}

rootProject.name = "gradle_learn"// 项目名称
include("app")// 蕴含的模块

build.gradle.kts

在大部分状况下，都没有应用 App 最为子模块 (除了Android 我的项目)，也就是间接从其中的 src 开始，我的项目构造如下。

│  build.gradle.kts // build 配置文件
│  settings.gradle.kts// settings 配置文件
│  
├─gradle
│  └─wrapper
│          gradle-wrapper.jar
│          gradle-wrapper.properties
│          
└─src // 源码
    ├─main
    └─test

但基本上都差不多，因为每个我的项目中都会有 build.gradle.kts，这就是以后我的项目的build 配置文件，这个文件中配置了我的项目的 build 信息，比方我的项目的 group，version，dependencies 等。

plugins {// 以后我的项目应用的插件，这里如果有子项目，子项目也会应用这里的插件
    // Apply the application plugin to add support for building a CLI application in Java.
    application // 利用插件，这个插件会主动创立一个 `run` 工作，用于运行我的项目
}

repositories {// 我的项目的仓库，这里的仓库是用于下载依赖的，这里的仓库是 `Maven` 仓库，也就是 `Maven Central`
    // Use Maven Central for resolving dependencies.
    mavenCentral()}

dependencies {// 我的项目的依赖，这里的依赖是 `Maven` 仓库中的依赖，这里的依赖是 `JUnit` 和 `Guava`
    // Use JUnit Jupiter for testing.
    testImplementation("org.junit.jupiter:junit-jupiter:5.9.1")// 测试依赖，testImplementation 是测试依赖，implementation 是利用依赖

    // This dependency is used by the application.
    implementation("com.google.guava:guava:31.1-jre")// 利用依赖，其中的字符串是 `Maven` 仓库中的依赖，应用分号宰割，第一个是 `group`，第二个是 `name`，第三个是 `version`
}

// Apply a specific Java toolchain to ease working on different environments.
java {// java 的配置，这里配置了 java 的版本
    toolchain {languageVersion.set(JavaLanguageVersion.of(17))// java 的版本
    }
}

tasks.named<Test>("test") {// test 工作的配置，这里配置了 test 工作的应用的测试框架
    // Use JUnit Platform for unit tests.
    useJUnitPlatform()// 应用 JUnit 作为测试框架}

//Application 插件的配置，这里配置了 mainClass，也就是我的项目的入口类
application {
    // Define the main class for the application.
    mainClass.set("cn.enaium.App")// 入口类
}

gradle-wrapper.properties

# distributionBase 就是下载的 gradle 的寄存地位，如果环境中没有配置 GRADLE_USER_HOME，那么就会应用默认的地位，也就是以后用户的目录下
distributionBase=GRADLE_USER_HOME
# distributionPath 就是下载的 gradle 的寄存地位，也就是 distributionBase 的目录中的 wrapper/dists 目录
distributionPath=wrapper/dists
# distributionUrl 就是下载的 gradle 的地址，这里的地址是 gradle 的官网地址，也就是 https://services.gradle.org/distributions/gradle-8.1-bin.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-8.1-bin.zip
# networkTimeout 就是下载 gradle 的超时工夫，单位是毫秒
networkTimeout=10000
# 和下面同理
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

src

├─main
│  ├─java
│  │  └─cn
│  │      └─enaium
│  └─resources
└─test
    ├─java
    │  └─cn
    │      └─enaium
    └─resources

这个目录下的内容就是我的项目的源码了，这里的 main 和test两个都是源码目录，只不过 main 是我的项目的源码，test是我的项目的测试源码，这两个目录下都有 java 和resources两个目录，java目录下寄存的是 java 源码，resources目录下寄存的是资源文件，比方 properties 文件，xml文件等，这里都是固定的格局，如果你想要自定义，能够在 build.gradle.kts 中配置，但本篇文章是简略的入门，所以就不介绍了。

命令 / 工作

gradle tasks

这个命令是查看以后我的项目的所有工作，这个命令会列出所有的工作，包含 Gradle 自带的工作，比方 build，clean 等，还有 App 模块自带的工作，比方 run，test 等，这里只介绍一下比拟罕用的命令，其余的命令能够自行查看。

> Task :tasks // 工作的名称，这里是 tasks，也就是说查看所有工作也是一个工作                                                                                                           

------------------------------------------------------------
Tasks runnable from root project 'gradle_learn'
------------------------------------------------------------

Application tasks// 工作的 Group，这里是 Application，这个是 Application 插件自带的工作
-----------------
run - Runs this project as a JVM application // 工作的名称

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 main classes.
clean - Deletes the build directory.
jar - Assembles a jar archive containing the main classes.
testClasses - Assembles test classes.

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

Distribution tasks
------------------
assembleDist - Assembles the main distributions
distTar - Bundles the project as a distribution.
distZip - Bundles the project as a distribution.
installDist - Installs the project as a distribution as-is.

Documentation tasks
-------------------
javadoc - Generates Javadoc API documentation for the main source code.

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'gradle_learn'.
dependencies - Displays all dependencies declared in root project 'gradle_learn'.
dependencyInsight - Displays the insight into a specific dependency in root project 'gradle_learn'.
help - Displays a help message.
javaToolchains - Displays the detected java toolchains.
kotlinDslAccessorsReport - Prints the Kotlin code for accessing the currently available project extensions and conventions.
outgoingVariants - Displays the outgoing variants of root project 'gradle_learn'.
projects - Displays the sub-projects of root project 'gradle_learn'.
properties - Displays the properties of root project 'gradle_learn'.
resolvableConfigurations - Displays the configurations that can be resolved in root project 'gradle_learn'.
tasks - Displays the tasks runnable from root project 'gradle_learn' (some of the displayed tasks may belong to subprojects).

Verification tasks
------------------
check - Runs all checks.
test - Runs the test suite.

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

BUILD SUCCESSFUL in 1s
1 actionable task: 1 executed

gradle run

这个命令是 Application 插件专有的命令，这个命令会运行 Application 插件配置的入口类，这里的入口类是 cn.enaium.App，也就是build.gradle.kts 中配置的mainClass。

gradle init

也就是本篇文章最开始所用到的工作，这个工作会生成一个 gradle 我的项目。

gradle build

构建我的项目，这个命令会执行 build.gradle.kts 中配置的 build 工作，这个命令会生成一个 build 目录，这个目录下寄存的是构建后的文件，比方 jar 文件，class文件等。

IntelliJ IDEA

导入我的项目

关上IntelliJ IDEA，点击Open，抉择我的项目所在的目录，点击OK，这样就能够导入我的项目了。

配置 Gradle

基本上大多数的我的项目都不须要特意配置 Gradle，关上设置中File> Settings> Build, Execution, Deployment> Build Tools> Gradle，这里就是对于Gradle 的配置，其中 Gradle JVM 是Gradle的 JVM 配置，也就是运行 Gradle 的JDK版本，之后关上 IntelliJ IDEA 右侧的 Gradle，能够看到所有的我的项目模块还有所有工作，并且我的项目中所用到的依赖都会在这里显示进去，如果你想要运行某个工作，能够在这里双击，也能够在Terminal 中输出 gradle <task>，比方gradle run，这样就能够运行run 工作了。

总结

本篇文章次要介绍了 Gradle 的根本应用，包含 Gradle 的装置，Gradle的目录构造，Gradle的命令 / 工作，IntelliJ IDEA的配置，Gradle的配置，Gradle的应用，Gradle的插件，Gradle的依赖，Gradle的 JVM 配置，然而本篇文章只是简略的介绍了一下，如果想要深刻理解，能够查看 Gradle 官网文档。