Gradle 是一款构建工具，常用于Java、Android等项目的构建。本文介绍了Gradle的基本概念和使用方法，包括Gradle的下载与安装、Gradle基础、Gradle文件详解等内容。本文旨在帮助读者了解Gradle的基本知识和使用方法，以便在开发中更好地使用Gradle。

Gradle下载与安装

• Gradle 运行依赖JVM，请提前安装jdk和jre
• gradle与java版本对照

Java version	First Gradle version to support it
8	2.0
9	4.3
10	4.7
11	5.0
12	5.4
13	6.0
14	6.3
15	6.7
16	7.0
17	7.3
18	7.5
19	7.6

• 我们通过直接下载二进制包的方式安装gradle，官网地址：gradle.org/releases/

• 下载压缩包后，解压，然后配置环境变量

如果是MacOS，在~/.bash_profile中添加如下代码

export GRADLE_HOME=${HOME}/gradle-2.14.1
PATH=${PATH}:${GRADLE_HOME}/bin
export PATH

其中，gradle-4.10是文件的解压路径

• 保存后在终端输入source ~/.bash_profile回车执行让刚刚的配置生效。
• 通过 gradle -v检查是否安装成功

Gradle基础

• Gradle 里的任何东西都是基于这两个基础概念: projects ( 项目 ) 和 tasks ( 任务 ) 。每一个构建都是由一个或多个 projects 构成的，每一个 project 是由一个或多个 tasks 构成的。一个 project 可以代表一个 JAR ，一个网页应用，一个发布的 ZIP 压缩包等。一个tasks就是一段可执行的代码，比如编译代码、运行测试、打包等。
• gradle命令行基本格式：gradle 任务名称 ，比如 gradle clean（清空所有编译、打包生成的文件） ，gradle build -x test（跳过测试构建构建）
• build.gradle文件是 Gradle 构建脚本的核心，它可以用来定义项目的构建逻辑、依赖管理、插件管理等内容。 该文件通常位于项目根目录下。
• 执行Gradle命令的时候，会默认加载当前目录下的build.gradle脚本文件，你也可以通过 -b 参数指定想要加载执行的文件。
• Gradle插件是一种可重用的构建逻辑，它可以提供各种功能来简化构建过程。Gradle中有丰富的插件，例如：application 插件可以打包可执行的Java应用程序,war 插件可以打包Web应用程序。除了官方插件之外，还有很多第三方插件。
• Gradle Wrapper是Gradle的一个特性，它能够让我们在不安装Gradle的情况下运行Gradle构建。它是一个shell脚本和一个二进制文件，可以自动下载指定版本的Gradle，并使用该版本运行Gradle构建。

以下是一个简单的Gradle项目：

plugins {
    id 'java'
}

repositories {
    jcenter()
}

dependencies {
    implementation 'com.google.guava:guava:23.0'
    testImplementation 'junit:junit:4.12'
}

task hello {
    doLast {
        println 'Hello, world!'
    }
}

这个项目使用了Java插件，定义了两个依赖，一个是Guava，一个是JUnit，以及一个任务，输出 "Hello, world!"。

Gradle文件详解

• Gradle为每个build.gradle都会创建一个相应的Project领域对象，在编写Gradle脚本时，我们实际上是在操作诸如Project这样的Gradle领域对象。
• 在多Project的项目中，我们会操作多个Project领域对象。一般我们会在项目根目录下 加入名为settings.gradle的配置文件，该文件应该包含各个子Project的名称。

build.gradle 文件通常包含以下内容

基本信息

在 build.gradle 文件中，我们可以定义项目的基本信息，例如项目名称、版本号、描述等。这些信息可以在构建过程中用来生成构建输出的名称、版本等属性。

group 'com.example'
version '1.0.0'
description 'My project description'

依赖管理

在 build.gradle 文件中，我们可以定义项目所依赖的库和组件，例如 Java 库、Android 库、第三方库等。依赖可以通过 Maven Central、JCenter、本地仓库等方式进行管理。在 Gradle 中，依赖通常包括两个部分：group 和 name。例如，下面的代码定义了一个依赖：

dependencies {
    implementation 'com.google.guava:guava:23.0'
}

其中

• com.google.guava 是库的 group，guava 是库的 name，23.0 是库的版本号。
• 我们通过group、name、version共同定位一个远程依赖库，远程依赖库是我们最常用的依赖类型，其他依赖类型包括：本地模块，本地二进制文件（jar文件）
• 除implementation外, Gradle 还支持多种依赖方式，例如 compile、runtime、testCompile 等，可以根据不同的需求来选择不同的配置。

插件管理

在 build.gradle 文件中，我们可以配置项目所使用的插件。插件可以提供各种构建逻辑和功能，例如 Java 插件、Android 插件、Scala 插件等。在 Gradle 中，插件可以通过 plugins 块来配置，例如：

plugins {
    id 'java'
    id 'org.s\pringframework.boot' version '2.1.3.RELEASE'
}

其中，id 后面的参数表示插件的 ID，version 后面的参数表示插件的版本号。如果插件在 Gradle 插件仓库中不存在，我们还可以通过 buildscript 块来指定插件的依赖，例如：

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.4.2'
    }
}

其中，repositories 块指定了插件所在的仓库，dependencies 块指定了插件的依赖。

在build.gradle中使用自定义插件

我们还可以编写自定义插件，来满足项目特定的构建需求。自定义插件通常包括两个部分：插件类和插件描述文件。插件类是实现插件逻辑的核心代码，插件描述文件则是指定插件 ID、版本号等元数据的文件。自定义插件可以通过 Maven Central、JCenter 等仓库进行分发和使用。

首先，我们需要在项目的 src/main/groovy 目录下创建一个新的目录，例如 com/example/gradle。在该目录下，我们可以创建插件类，例如：

package com.example.gradle

import org.gradle.api.Plugin
import org.gradle.api.Project

class MyPlugin implements Plugin<Project> {
    void apply(Project project) {
        project.task('hello') {
            doLast {
                println "Hello, world!"
            }
        }
    }
}

在插件类中，我们实现了 Plugin 接口，并重写了 apply 方法。在该方法中，我们定义了一个名为 hello 的任务，并在任务中输出了一条消息。

接下来，我们需要在 build.gradle 文件中指定插件的描述文件，例如：

plugins {
    id 'com.example.gradle.myplugin' version '1.0.0'
}

在该代码中，id 指定了插件的 ID，version 指定了插件的版本号。我们还需要在项目的 src/main/resources/META-INF/gradle-plugins 目录下创建一个新的文件，例如 com.example.gradle.myplugin.properties。在该文件中，我们需要指定插件的类名，例如：

implementation-class=com.example.gradle.MyPlugin

这样，我们就完成了自定义插件的编写。我们可以运行 gradle hello 命令来执行插件中的任务，输出一条消息。

构建任务

在 build.gradle 文件中，我们可以定义各种构建任务，例如编译代码、运行测试、打包等。任务可以通过 task 块来定义，例如：

task compileJava {
    doLast {
        // Compile Java code here
    }
}

其中，compileJava 是任务的名称，doLast 块中的代码表示任务的执行逻辑。Gradle 还支持多种任务类型，例如 Copy、Exec、Test 等，可以根据不同的需求来选择不同的任务类型。

配置构建参数

在 build.gradle 文件中，我们可以通过以下方式配置构建参数

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
    options.fork = true
    options.forkOptions.memoryMaximumSize = '4g'
    options.forkOptions.jvmArgs.add('-Xms512m')
    options.forkOptions.jvmArgs.add('-Xmx4g')
}

其中

• sourceCompatibility 和 targetCompatibility 指定了 Java 版本为 1.8
• options.fork = true 表示使用独立的 JVM 进程编译
• options.forkOptions.memoryMaximumSize = '4g' 表示设置 JVM 的最大堆大小为 4GB
• options.forkOptions.jvmArgs.add('-Xms512m') 和 options.forkOptions.jvmArgs.add('-Xmx4g') 分别表示设置 JVM 的初始堆大小为 512MB，最大堆大小为 4GB。
• 需要注意的是，堆大小及JVM参数在发布jar包时仍可通过命令参数修改

配置构建输出

在 build.gradle 文件中，我们可以配置构建输出，例如生成 Jar 包、War 包、自定义包名、自定义输出路径等。

apply plugin: 'java'
jar {
    archiveName = "myproject.jar"
    destinationDir = file("/path/to/output")
    manifest {
        attributes 'Main-Class': 'com.example.Main'
    }

}

其中

• apply plugin: 'java' 表示使用 Java 插件
• jar 块用于配置 Jar 包生成的相关属性，例如 Main-Class 等。
• archiveName 表示生成的 Jar 包名称
• destinationDir 表示输出目录。

要将构建输出发布到 Maven 仓库或者其他仓库中，我们可以在 build.gradle 文件中添加以下内容：

apply plugin: 'maven-publish'
publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
        }
    }
    repositories {
        maven {
            url "<http://repo.mycompany.com/maven2>"
        }
    }
}

其中

• apply plugin: 'maven-publish' 表示使用 Maven Publish 插件
• publications 块用于配置发布的组件
• repositories 块用于配置发布到的仓库。

配置代码检查和测试

Gradle 可以集成多种代码检查和测试工具，例如 Checkstyle、FindBugs、JUnit 等。这些工具可以帮助我们检查代码质量、发现潜在的问题、提高代码可读性和可维护性。

配置 Checkstyle

Checkstyle 是一个Java 代码静态分析工具，用于检查代码风格和规范。我们可以通过 Gradle 将 Checkstyle 集成到项目中。

1. 首先，我们需要在 build.gradle 文件中添加 Checkstyle 插件：

plugins {
    id 'checkstyle'
}

1. 然后，我们需要配置 Checkstyle，例如：

checkstyle {
    toolVersion = '8.42'
    configFile = rootProject.file('config/checkstyle/checkstyle.xml')
    ignoreFailures = false
}

其中，

• toolVersion 指定了 Checkstyle 的版本号；
• configFile 指定了 Checkstyle 的配置文件；
• ignoreFailures 表示是否忽略检查失败。

1. 最后，我们需要配置 Checkstyle 的任务，例如：

task checkstyle(type: Checkstyle) {
    source 'src/main/java'
    include '**/*.java'
    reports {
        xml.enabled = true
        html.enabled = true
        xml.destination = file("$buildDir/reports/checkstyle/checkstyle.xml")
        html.destination = file("$buildDir/reports/checkstyle/checkstyle.html")
    }
}

其中，

• source 和 include 指定了需要检查的源代码目录和文件；
• reports 指定了检查报告的输出格式和位置。

我们可以通过运行 gradle checkstyle 命令来执行 Checkstyle 任务，生成检查报告。

配置 FindBugs

FindBugs 是一个Java 代码静态分析工具，用于发现代码中的缺陷和潜在的问题。我们可以通过 Gradle 将 FindBugs 集成到项目中。

1. 首先，我们需要在 build.gradle 文件中添加 FindBugs 插件：

plugins {
    id 'findbugs'
}

1. 然后，我们需要配置 FindBugs，例如：

findbugs {
    toolVersion = '3.0.2'
    ignoreFailures = false
    reportsDir = file("$buildDir/reports/findbugs")
}

其中，

• toolVersion 指定了 FindBugs 的版本号；
• ignoreFailures 表示是否忽略检查失败；
• reportsDir 指定了 FindBugs 报告的输出目录。

1. 最后，我们需要配置 FindBugs 的任务，例如：

task findbugs(type: FindBugs) {
    classes = files("$buildDir/classes/java/main")
    source = fileTree('src/main/java')
    include '**/*.class'
    reports {
        html.enabled = true
        xml.enabled = true
        html.destination = file("$buildDir/reports/findbugs/findbugs.html")
        xml.destination = file("$buildDir/reports/findbugs/findbugs.xml")
    }
}

其中，

• classes 指定了需要检查的 class 文件；
• source 和 include 指定了需要检查的源代码文件；
• reports 指定了检查报告的输出格式和位置。

我们可以通过运行 gradle findbugs 命令来执行 Find

Gradle Wrapper

Gradle Wrapper 是 Gradle 提供的一个用于管理 Gradle 版本的工具，可以让我们在开发和构建时自动下载指定版本的 Gradle。使用 Gradle Wrapper 可以避免因为 Gradle 版本不一致而导致的构建问题，同时也可以让项目更加易于构建和共享。

Gradle Wrapper 的使用

Gradle Wrapper 包含了一个 shell 脚本和一个 jar 文件，可以通过以下命令来生成 Gradle Wrapper：

gradle wrapper

执行上述命令后，会在当前项目的根目录下生成一个 gradlew 脚本和一个 gradle/wrapper/gradle-wrapper.jar 文件。我们可以通过执行 gradlew 脚本来执行 Gradle 命令，例如：

./gradlew build

执行上述命令后，Gradle Wrapper 会自动下载指定版本的 Gradle 并执行 build 任务。

Gradle Wrapper 的优势

使用 Gradle Wrapper 有以下优势：

• 版本管理：Gradle Wrapper 可以自动下载指定版本的 Gradle，避免了因 Gradle 版本不一致而导致的构建问题。
• 跨平台：Gradle Wrapper 可以在 Windows、Linux、Mac 等平台上使用，避免了因平台不同而导致的构建问题。
• 构建共享：使用 Gradle Wrapper 可以让项目更加易于构建和共享，其他人只需要执行 gradlew 脚本即可构建项目，无需安装 Gradle。

Gradle Wrapper 的配置

可以在 gradle/wrapper/gradle-wrapper.properties 文件中配置 Gradle Wrapper 的属性，例如：

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\\://services.gradle.org/distributions/gradle-6.5-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

其中，

• distributionUrl 指定了 Gradle 的下载地址。

Gradle Wrapper 的版本

可以通过以下命令来指定 Gradle Wrapper 的版本：

gradle wrapper --gradle-version=6.5

执行上述命令后，Gradle Wrapper 会自动下载指定版本的 Gradle。我们也可以手动将 Gradle 的压缩包放到 gradle/wrapper 目录中，然后在 gradle/wrapper/gradle-wrapper.properties 文件中指定 Gradle 的压缩包路径。

Gradle Wrapper 的注意事项

使用 Gradle Wrapper 有以下注意事项：

• Gradle Wrapper 需要联网才能下载 Gradle。
• Gradle Wrapper 的性能可能会受到网络和硬盘速度的影响。
• Gradle Wrapper 只能下载指定版本的 Gradle，如果需要使用其他版本的 Gradle，则需要手动安装。

Gradle Wrapper 的结论

Gradle Wrapper 是 Gradle 提供的一个用于管理 Gradle 版本的工具，可以让我们在开发和构建时自动下载指定版本的 Gradle。使用 Gradle Wrapper 可以避免因为 Gradle 版本不一致而导致的构建问题，同时也可以让项目更加易于构建和共享。

与maven相比

• 性能方面，Gradle的构建速度比Maven更快，因为它可以并行地执行任务。
• 与Maven不同的是，Gradle不提供内建的项目生命周期管理，只是java Plugin向Project中添加了许多Task，这些Task依次执行，为我们营造了一种如同Maven般项目构建周期。

参考

Gradle用户指南官方文档中文版_Gradle开发中文手册[PDF]下载-UDN开源文档

Build Script Basics

The Java Plugin