Gradle使用教程

我们在一个build.gradle文件中，按住 ctrl+鼠标左键，点击dependencies，可以进入Project接口。

感兴趣的开发者，可以研究一下gradle的创建过程和Project接口代码。

也可以查阅官方文档。

https://docs.gradle.org/current/javadoc/org/gradle/api/Project.html

https://docs.gradle.org/current/dsl/org.gradle.api.Project.html

（2）apply plugin，plugins

声明gradle脚本使用什么插件，apply plugin单个插件，plugins 多个插件。

一般来说，加一个 ‘java’ 就满足需求了

例1：

apply plugin: 'java'
plugins {
    id 'application'
    id 'java'
}

例2，如下图：

（3）dependencies

可以依赖本地jar，或者远程线上的jar（经常和repositories一起使用）

依赖仓库有很多种写法，这里仅举例几种写法

例1，依赖远程仓，依赖远程仓加版本号

dependencies {
    api 'org.hibernate:hibernate-core:3.6.7.Final'
}

或者可以在外部定义版本号

def springBootVersion = '2.0.3.RELEASE'
dependencies {
    classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    classpath("org.springframework:springloaded:${springBootVersion}")
    classpath("org.springframework.build.gradle:propdeps-plugin:0.0.6")
}

例2，依赖本地仓，依赖单个jar和多个jar

repositories {
    flatDir {
        dirs 'libs'
    }
}
dependencies {
    api fileTree(include: ['*.jar'], dir: 'libs')
}
dependencies {
    Implementation files('libs/your-library-file-name.jar')
}

例3，类似于maven，也可以做一个排除

implementation("org.springframework.boot:spring-boot-starter:$project.ext.springBootVersion"){
    exclude module: 'org.springframework.boot:spring-boot-starter-logging'
}

例4，依赖本地module

build.gradle里面加入依赖

dependencies {
    compile project(':gdemo')
    compile project(':demo2')
}

setting.gradle配置module，'gdemo'是内部module， 'demo2'是外部module

include 'gdemo'
include 'demo2'
project(':demo2').projectDir = file('../demo2')

例4的本地依赖截图如下：

我的这个项目里面，有2个module，主module是'node-debug-mservice'，副module是'demo_plugin'，

查看截图，可以看到在setting.gradle里面配置主module和其他副module。

查看截图，可以看到在'node-debug-mservice'的build.gradle里面，我配置了 当前的主module去 引用其他的module，这样配置了引用之后，'node-debug-mservice'就可以使用'demo_plugin'里面的代码了。

（4）dependencies使用时的一些函数介绍

implementation、api/compile、classpath

在gradle新版本中compile被替换为api，使用api或compile是等效的

api/compile 使用这个可以使依赖向上传递，

假设有3个模块，分别是baseMoudle、myModule、applaciton。

依赖关系是：myModule依赖了baseMoudle，applaciton 依赖了myModule，

在写dependencies 时用了api/compile，

这时，applaciton 也可以使用baseMoudle里面的代码。

使用implementation 则不会，将代码隐藏在内部，不对外部公开，不会对外传递依赖。

依照上述案例，依赖关系依旧是：myModule依赖了baseMoudle，applaciton 依赖了myModule。

编写依赖时，myModule使用implementation 去依赖baseMoudle，

applaciton里面使用不了baseMoudle里面的代码。

classpath 一般使用在buildscript里面

（5）repositories

声明gradle使用哪一种远程仓库集，这个需要和dependencies配合使用，当dependencies使用的是远程库时，会从远程仓库集中下载远程库到本地，再依赖使用。

如下例子，使用了三个远程仓库集，那么会从仓库集中找到一个远程库jar包下载到本地。

这些仓库集合其实大部分都是maven库，既支持maven又支持gradle。

jcenter()  https://jcenter.bintray.com/

mavenLocal()  直接使用本地maven仓库

mavenCentral()  https://repo1.maven.org/maven2/

如果使用远程仓库，可以直接上https://mvnrepository.com/ 查找全部jar包的版本号

可以直接在https://mvnrepository.com/repos

例1：

repositories {
jcenter()
    mavenLocal()
    mavenCentral()
}

例2，参照阿里云，我们也可以自己搭建一个仓库集合，使用url的方式加载：

repositories {
    maven { url 'http://maven.aliyun.com/nexus/content/repositories/google' }
    maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter'}
}

（6）task 任务

可以定义一个任务，使用命令行执行该任务gradle taskName，或者在idea的侧边gradle工具栏里面执行这个task。

官方文档：https://docs.gradle.org/current/userguide/custom_tasks.html

有两种task，一种是我们自己定义的简单task。一种是官方给我们写好的增强型task。

还可以在增强型task的基础上再自定制一个task。

增强型task的类型，请查看api

https://docs.gradle.org/current/javadoc/org/gradle/api/Task.html

如果是在build.gradle中使用的task，就是使用Interface Project的api，去创建一个task对象，这个对象继承了task接口

增强型task的官方例子

https://docs.gradle.org/current/userguide/java_plugin.html

增强型可选参数

例1，简单的task

例2，增加型task

例3，执行特殊的task脚本，增强型task

我们可以定义一个task，声明任务名，声明类型(type)。

例如声明一个task，函数名为copyJarTodir，类型为Copy，这个Copy类型是gradle的插件提供的一个已经实现好的功能，

org.gradle.api.tasks.Copy
task copyJarTodir(type: Copy) {
    from 'build/libs'
    into '/home/local/bos'
    exclude '**/*.class'
}

例4，参照官方教程，在不使用project的api的场景下，创建一个task类，并实例化它，变量名就是”hello”

class GreetingTask extends DefaultTask {
    @TaskAction
    def greet() {
        println 'hello from GreetingTask'
    }}
// Create a task using the task type
task hello(type: GreetingTask)

（7）TaskContainer

负责管理一组Task实例。有关TaskContainer的用法和函数查阅的api链接，以下举出几个常用的TaskContainer函数。

https://docs.gradle.org/current/dsl/org.gradle.api.tasks.TaskContainer.html

关于TaskContainer，我们可以自己去创建操作一个task，也可以使用TaskContainer来创建操作task。

查找task

findByPath(path: String):

withType(type: Class): TaskCollection

创建task

create(name: String):

当task被加入到TaskContainer时的监听

whenTaskAdded(action: Closure)

例1，云苍穹里面的task用法，查找Interface Project接口里面task: JavaCompile, 并把编码改为utf-8

tasks.withType(JavaCompile) {
    options.encoding = "UTF-8"
}

例2，创建task

（8）buildscript

buildscript中的声明是gradle脚本自身需要使用的资源。可以声明的资源包括依赖项、第三方插件、maven仓库地址等。

而在build.gradle文件中直接声明的依赖项、仓库地址等信息是项目自身需要的资源。

如果构建脚本需要使用外部库，则可以将它们添加到构建脚本本身的脚本的类路径中。

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath group: 'commons-codec', name: 'commons-codec', version: '1.2'
    }
}

（9）allprojects()，subprojects()

allprojects是对所有project的配置，包括Root Project。而subprojects是对所有Child Project的配置。

subprojects {
apply plugin: 'java'
    repositories {
        jcenter()
    }
}
allprojects {
    apply plugin: 'java'
    repositories {
        google()
    }
}

（10）Closure 和 Action

在gradle里面有很多和java类似的参数对象，例如 List，map，int，string，file

介绍一下我在gradle里面经常遇到的另外两种数据类型 Closure 和 Action

闭包closure它代表了一段可执行的代码，和java的 Lambda表达式有点像

Closure的定义格式，如果有参数，要加一个箭头 ->：

def xxx = {paramters -> code}

def xxx = {无参数，纯code}

例1：

活动action

对泛型T执行某些操作。

（11）sourceSets

指定Java源和资源文件的路径。

例1

sourceSets {
    main {
        java {
            srcDir 'src/java' // 指定源码目录
            srcDir "src/other/java"
            sourceSets.all{set ->
                println "${set.name}的文件是 ${set.java.srcDirs}"
            }

            exclude 'com/example/kylin/fristtest/MyTestOne.java'
        }
        resources {
            srcDir 'src/resources' //资源目录
        }
    }
}

（12）def

定义函数，使用

tasks.create(name: 'printTime') {
    String str = releaseTime();
    println str;
}
def releaseTime() {
    return new Date().format("yyyyMMdd hh:mm:ss", TimeZone.getTimeZone("GMT+8"))
}
定义变量，使用
def myStr = 123456;
tasks.create(name: 'printmy') {
    println "hello ${myStr}";
    println myStr;
}

（13）configurations

配置一组依赖，经常和dependencies 连用，具体可查看官方文档

https://docs.gradle.org/current/userguide/declaring_dependencies.html

例1，写一个smokeTest继承自testImplementation，并且再增加一个httpclient依赖。

然后就可以使用smokeTest去进行其他测试依赖。

configurations {
smokeTest.extendsFrom testImplementation
}
dependencies {
    testImplementation 'junit:junit:4.13'
smokeTest 'org.apache.httpcomponents:httpclient:4.5.5'
}

例2，排除，以下排除 'commons'和'shared'的代码应该是相同功能的

configurations {
    compile.exclude module: 'commons'
}
dependencies {
    compile("org.gradle.test.excludes:api:1.0") {
        exclude module: 'shared'
    }
}

（14）ConfigurationContainer

类似于TaskContainer，一个Configuration容器，可以用来创建Configuration或者获取Configuration。

例如：

configurations.create('myConfiguration')
configurations.myConfiguration {
    transitive = false
}

（15）创建对象

class A {
    def String name
    void m() {
        println('method m')
    }
}
def a = new A()
// 创建完成之后在task中执行
task printA{
    a.m()
    a.name = "gg"
    println(a.name)
}

setting.gradle

类似于project，也是一个接口org.gradle.api.initialization.setting

一般用来包含module，就是声明项目结构，导入代码模块的。导入了代码模块之后，就可以在build.gradle中依赖使用了。

例1，以下代码，确定了项目名称，包含了一个本地模块'gdemo'，一个项目外的模块'demo2'

rootProject.name = 'node-debug-mservice'

include 'gdemo'

include 'demo2'
project(':demo2').projectDir = file('../demo2')

gradle/gradle-wrapper.properties

gradle-wrapperr.properties主要是做一些配置，配置gradle的版本和下载url，当gradle更新完成之后，gradle会下载大量的gradle工具包到本地。

官方文档：https://docs.gradle.org/current/dsl/org.gradle.api.tasks.wrapper.Wrapper.html

以下配置指定了，下载gradle-6.5-bin.zip包之后，把压缩包保存在 用户home目录下

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

也可以自己配置一个环境变量，GRADLE_USER_HOME，指定gradle的安装路径

其他选项不需要修改，distributionUrl可以修改url，更换gradle的版本。

三、构建project

构建资料文档

https://docs.gradle.org/current/userguide/building_java_projects.html

Gradle构建java项目，一般形式是打包编译jar，再运行jar。

或者定义task设置运行main方法

（1）定义task，设置运行main方法

task runMain(dependsOn: 'classes', type: JavaExec) {
    main = 'kd.bos.debug.mservice.DebugServer'
    classpath = sourceSets.main.runtimeClasspath
}

（2）打包jar

参照云苍穹项目

task sourcesJar(type: Jar, dependsOn: build) {
    classifier = 'sources'
    from sourceSets.main.allSource
}

也可以直接运行build，这个gradle原生定义好的task。

（3）侧边栏结构

侧边栏的结构，每一个module都有tasks，dependencies

主工程除了tasks，dependencies，还多一个run configurations

Tasks里面就是一些 gradle定义好的原生task，当然也可以自定义task，自定义完成之后，点击刷新，会出现在侧边栏 tasks/other下面。

最常用的就是tasks/build、tasks/other 下面的那些task。

dependencies和run configurations基本不会用到

dependencies是查看项目依赖关系的，可以查看到当前 主工程或者module依赖了哪些库

run configurations是查看运行配置关系的

（4）侧边栏常用task

一些常用task的意义可以查看官方文档

https://docs.gradle.org/current/userguide/java_plugin.html

compileJava 使用JDK编译器编译生产Java源文件，就是.class文件。

Jar 生成.class文件的同时，打jar包，compileJava的升级版

Assemble  多工程编译Multi-Projects Build，Assemble会连同本工程，再把所有的被依赖的module一起打包，jar的升级版

Build  是对整个工程进行彻底的重新编译，只针对更改过的文件进行编译，Assemble的升级版，build还能执行一些其他的脚步，理论上来说 Assemble和build没有区别

buildNeeded  Build的升级版

Clean 清理编译缓存，主要清理build/下的文件

（5）命令行

在idea里面，打开终端，或者使用cmd终端，可以通过命令行去执行task。

win系统中，在执行task时，其实就是在执行gradlew.bat，注意这里的gradlew命令和 “gradle” 相比多了一个w字母，敲命令时不要敲错。

例如 执行 gradlew clean  会清理所有的编译缓存，清理build目录下的文件

执行gradlew build  会重新生成build目录和一些class文件和jar包

执行命令行和idea侧边栏的功能相同。

（6）区分环境构建

可以自定义一些变量来区分不同的环境，在不同的环境下，可以使用不同的jar包、不同的变量，不同的编译策略。

// dev、test、pro
def env = "dev"
sourceSets {
    main {
        // gradle里面 可以用equals，也可以用==号
        if (env.equals("dev")) {
            srcDirs = "src/main/java/";
        } else if (env == "test") {
            srcDirs = "src/main/java/$env"
        } else if (env == "pro") {
            srcDirs = "src/main/java/$env"
        }
    }
}
def envJarsDir = "../lib" + env
dependencies {
    implementation fileTree(dir: envJarsDir, include: '*.jar')
}
task myAssemble(type: Assemble) {
    if (env.equals("dev")) {
        // 执行相应的编译逻辑
    } else if (env == "test") {
        // 执行相应的编译逻辑
    } else if (env == "pro") {
        // 执行相应的编译逻辑
    }
}