Gradle极简入门

简介: Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,而不是传统的XML。Gradle构建脚本是用Groovy编写的,也可以使用Kotlin编写,两者都是基于JVM的语言。

首发于Enaium的个人博客


什么是 Gradle

Gradle是一个基于Apache AntApache Maven概念的项目自动化构建工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,而不是传统的XMLGradle构建脚本是用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.ktsGradle的配置文件,这个文件中配置了项目的名称和模块,这里的模块指的是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信息,比如项目的groupversiondependencies等。

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

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

命令/任务

gradle tasks

这个命令是查看当前项目的所有任务,这个命令会列出所有的任务,包括Gradle自带的任务,比如buildclean等,还有App模块自带的任务,比如runtest等,这里只介绍一下比较常用的命令,其他的命令可以自行查看。

> 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 JVMGradleJVM配置,也就是运行GradleJDK版本,之后打开IntelliJ IDEA右侧的Gradle,可以看到所有的项目模块还有所有任务,并且项目中所用到的依赖都会在这里显示出来,如果你想要运行某个任务,可以在这里双击,也可以在Terminal中输入gradle <task>,比如gradle run,这样就可以运行run任务了。

总结

本篇文章主要介绍了Gradle的基本使用,包括Gradle的安装,Gradle的目录结构,Gradle的命令/任务,IntelliJ IDEA的配置,Gradle的配置,Gradle的使用,Gradle的插件,Gradle的依赖,GradleJVM配置,但是本篇文章只是简单的介绍了一下,如果想要深入了解,可以查看Gradle官方文档

目录
相关文章
|
7月前
|
XML Java 测试技术
Gradle安装部署与基础入门详解
Gradle安装部署与基础入门详解
773 0
|
Java 测试技术 Spring
Gradle从0入门到实战系列【八】SpringBoot集成Junit单元测试
JUnit 是一个 Java 编程语言的单元测试框架。JUnit 在测试驱动的开发方面有很重要的发展,是起源于 JUnit 的一个统称为 xUnit 的单元测试框架之一。
1644 1
Gradle从0入门到实战系列【八】SpringBoot集成Junit单元测试
|
Java API Apache
Gradle从0入门到实战系列【一】Hello World Gradle
早期没有项目管理工具时,对于项目所依赖的第三方包采用的是:拷贝三方jar包到本地,然后加入到lib目录下,这样做劣势不言而喻,管理复杂容易冲突。 Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置,也增加了基于Kotlin语言的kotlin-based DSL,抛弃了基于XML的各种繁琐配置。面向Java应用为主。
641 0
Gradle从0入门到实战系列【一】Hello World Gradle
|
7月前
|
XML 缓存 Java
Gradle 构建自动化工具入门
Gradle 构建自动化工具入门
|
XML 存储 缓存
|
架构师 Java 测试技术
Gradle从0入门到实战系列【三】build.gradle之Project
在gradle中,每一个build.gradle文件对应一个Project实例,我们在build.gradle中编写的内容,就相当于Project实例的属性或方法, build.gradle和Maven中的pom.xml都是一个项目(project)的依赖配置文件,只有掌握了Project相关知识,才能编写出强大的build.gradle。
945 1
Gradle从0入门到实战系列【三】build.gradle之Project
|
弹性计算 Java jenkins
Gradle从0入门到实战系列【十】集成Dockerfile构建Docker镜像
在工作中,我们会将SpringBoot程序打包成Docker镜像,这就需要在Gradle中配置Dockerfile构建程序,并且能将打包后的镜像部署并启动为一个容器,Gradle的插件能够帮我们完成这件事
1226 0
Gradle从0入门到实战系列【十】集成Dockerfile构建Docker镜像
|
缓存 Java Linux
Gradle从0入门到实战系列【九】仓库与私服
Gradle沿用了Maven仓库,在使用仓库时能够很友好的基于Maven仓库提供功能,但Gradle所产生的构建并不会提供给Maven仓库,因为Gradle自己拷贝了一份Maven本地仓库缓存到了自己仓库目录下。
1232 0
Gradle从0入门到实战系列【九】仓库与私服
|
缓存 API
Gradle从0入门到实战系列【六】生命周期剖析
Gradle的核心是一种基于依赖的编程语言,任务与任务之间有一定的依赖关系,并且每个任务只会执行一次。在构建时,Gradle会把这些任务串联起来形成有向无环图。那Gradle是在什么时候进行串联的呢?这就需要充分了解Gradle在各个阶段做了什么事情了,从一开始到结束的这一连串动作我们称为生命周期。
309 0
Gradle从0入门到实战系列【六】生命周期剖析