乐趣区

关于java:Gradle极简入门

作者：

jiezi

在

首发于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官网文档。

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章