gradle基本知识
Easul Lv6
  2022-03-11 23:42:26 2022-03-11 23:42   2026-03-10 01:04:03      5.3k 字  24 分钟

三种构建工具的比较

ant和maven基于xml，格式过于固定，不灵活
tomcat源码是用ant编译的
gradle不依赖xml，可以使用groovy脚本来构建,更灵活，可以直接用脚本，且兼容ant和maven

安装配置

需要jdk8及以上

BASH 
1
2
3
4
5
6
7
8
9
10
11
12
13
mkdir ~/software && cd ~/software
# 在这里找到最新版：https://gradle.org/releases/，可以下载complete版本，包含源码
# 这里下载当前的最新版7.4.1
wget https://downloads.gradle-dn.com/distributions/gradle-7.4.1-all.zip
unzip gradle-7.4.1-all.zip
rm -rf gradle-7.4.1-all.zip
# 配置环境变量
echo "
GRADLE_HOME=/home/easul/software/gradle-7.4.1
PATH=\$GRADLE_HOME\bin:\$PATH
export PATH
" >> ~/.bash_profile
source ~/.bash_profile

构建脚本编写

构建由一个一个任务构成，这里创建build.gradle来编写脚本，语言使用groovy
groovy，scala都是基于java的语言，所以底层都是编译成class运行，而且用java写也是可以的

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 构建一个任务，后边是任务名称
task first {
    doLast {
        println "hello"
    }
}
// 直接用java的api
task second {
    doLast {
        String test = "asdf"
        System.out.println(test.toUpperCase())
    }
}
// 循环输出四次字符
// 4.times表示从0到3循环四次
// 字符串中用$it代替循环的次数
task third {
    doLast {
        4.times {
            println("$it")
        }
    }
}

然后运行任务

BASH 
1
2
3
# test是任务名称
# -q 静默输出，只显示错误日志
gradle -q test

这里的doLast是最后执行该任务，如下

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
// 使用gradle -q first执行first任务，他会先执行没有doLast的所有任务，最后执行first
task first {
    doLast {
        4.times {
            println("$it + asdf")
        }
    }
}
task second {
    4.times {
        println("$it")
    }
}

build的三个阶段

  • Initialization: Gradle决定哪些工程参与构建（可有多个工程），每个工程建一个Project实例。工程信息在settings.gradle中定义
  • Configuration：配置Project实例，所有工程的构建脚本都会执行，Task， Configuration和许多其他的对象都会被创建和配置
  • Execution：gradle通过构建好的task名称执行任务

doLast的任务在Execution阶段执行，剩下的都在Configuration阶段执行
后边的阶段执行了，前边的阶段就会执行

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
// 通过gradle执行脚本，是执行Configuration阶段，输出1 2 3
// 执行gradle -q second，是在Execution阶段，输出1 2 3 4
// 执行gradle -q first，相当于想在Execution阶段执行first的doLast，但是没有doLast，所以只在Configuration阶段输出了1 2 3
println("1")
task first {
    println("2")
}
task second {
    println("3")
    doLast {
        println("4")
    }
}

任务构建

普通任务

GROOVY 
1
2
3
4
5
6
7
8
// 不写大括号也可以
task test 
// 加上括号
task test2 {
    doLast {
        println("Father")
    }
}

任务依赖

  • 在声明任务时就声明依赖

    GROOVY 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    // 默认运行任务2时，只执行任务2的doLast
    // 但是任务2加了依赖，运行任务2的doLast，会先执行任务1的doLast
    // 如果两个任务循环依赖，将会报错
    task first {
        doLast {
            println("first")
        }
    }

    task second(dependsOn: first) {
        doLast {
            println("second")
        }
    }

  • 在声明完任务后再声明依赖

    GROOVY 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    task test {
        doLast {
            println("Son")
        }
    }
    task test2 {
        doLast {
            println("Father")
        }
    }
    test.dependsOn test2

  • 闭包中声明依赖

    GROOVY 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    task first {
        doLast {
            println "first"
        }
    }
    first.dependsOn {
        // 找到所有任务中的前缀为lib的任务进行依赖
        tasks.findAll {
            task -> task.name.startsWith('lib')
        }
    }
    task lib1 {
        doLast {
            println "lib1"
        }
    }
    task lib2 {
        doLast {
            println "lib2"
        }
    }
    task wlib2 {
        doLast {
            println "wlib2"
        }
    }

定位任务

GROOVY 
1
2
3
4
5
6
task first

// 通过任务名称定位任务
println first.name
// 通过属性定位任务，创建一个gradle，这个gradle的默认工程就是project
println project.first.name

将任务看成数组

GROOVY 
1
2
3
4
5
6
7
task first
task second

// tasks相当于放了所有任务的一个数组
// 形式类似js的数组访问
println tasks.first.name
println tasks["second"].name

在任务中添加描述

主要是用于方便任务阅读

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
// 这里的描述关键字是
// description 任务描述
// from 来源
// into 目的地
// include 包含的文件
task copy(type: Copy) {
    description 'Copies the resource directory to the target directory'
    from 'resources'
    into 'target'
    include('**/*.txt', "**/*.xml", "**/*.properties")
    println("description applied")
}

跳过任务

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// first依赖于compile，但compile有doFirst
// 只要doFirst出现异常，compile就不执行，接着执行剩下的任务
task compile {
    doLast {
        println("compile")
    }
}
compile.doFirst {
    if (true) {
        // 如果使用某些关键字不好停止该任务，就抛出异常即可
        throw new StopExecutionException()
    }
}
task first(dependsOn: 'compile') {
    doLast {
        println("first")
    }
}

依赖管理

声明依赖关系

也就是jar包的依赖，在dependencies写入

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 引入了一个java的插件，相当于引入的java的若干包
apply plugin: 'java'

// 仓库
repositories {
    // 本地库
    mavenLocal()
    // 外部依赖仓库
    maven {
        url 'https://maven.aliyun.com/nexus/content/groups/public/'
    }
    maven {
        url 'https://maven.aliyun.com/nexus/content/repositories/jcenter'
    }
    mavenCentral()
}
dependencies {
    implementation group: 'com.alibaba', name: 'fastjson', version: '1.2.79'
}

依赖关系配置

  • 编译
  • 运行时：默认包含编译阶段
  • 测试编译：默认包含编译产生的类和编译时的依赖
  • 测试运行时：默认包含运行时和测试的依赖

发布文件

可以将包文件发布到远程库

GROOVY 
1
2
3
4
5
6
7
8
9
10
// 发布时使用maven插件
apply plugin 'maven'

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: "file://localhost/tmp/myRepo/")
        }
    }
}

gradle插件

用于编译，设置域对象，设置源文件，测试，打包等等

插件类型

  • 脚本插件：额外的构建脚本，通常在构建中使用
  • 二进制插件（对象插件）：实现插件接口并用编程的方法来操作构建的类。

应用插件

使用Project.apply()方法

脚本插件

新建other.gradle，写入如下内容

GROOVY 
1
2
3
4
5
ext {
    // 放两个属性
    theVersion='1.0'
    url='http://212490197.xyz'
}

在build.gradle应用脚本插件

GROOVY 
1
2
3
4
5
6
7
8
9
apply from: 'other.gradle'

task first {
    doLast {
        // 输出引用的脚本插件内容
        println("version: $theVersion")
        println("url: $url")
    }
}

二进制插件

二进制插件就是实现了org.gradle.api.Plugin接口

  • 内部插件
    是gradle自己实现的插件，可以使用如下方法引入
    GROOVY 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    // 整个包的路径是org.gradle.api.JavaPlugin
    // 但因为默认的命名空间为org.gradle.api，所以引入插件时不用加前边的位置了
    apply plugin: JavaPlugin

    // 使用短名称引入核心插件，该名称已在源码中定义
    plugin {
        id: 'java'
    }

    // 通过社区来拉取第三方插件:https://plugins.gradle.org/
    // 第一种
    // id + 版本号
    plugins {
      id "jp.co.soramitsu.sora-plugin" version "0.5.0"
    }
    // 第二种
    // 通过buildscript指定第三方插件的库和依赖，最后再在buildscript外再声明一下
    // 没有托管到仓库的插件就需要指定链接再使用了
    // 必须要放到最开始
    buildscript {
      repositories {
        maven {
          url "https://plugins.gradle.org/m2/"
        }
      }
      dependencies {
        classpath "jp.co.soramitsu:sora-plugin:0.5.0"
      }
    }

    apply plugin: "jp.co.soramitsu.sora-plugin"

编写自定义插件

实现org.gradle.api.Plugin即可

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
apply plugin: HelloPlugin

class HelloPlugin implements Plugin<Project> {
    // 实现了Plugin，实现了apply方法
    void apply(Project project) {
        // 传入了project对象（gradle文件创建后的默认工程），定义了hello任务
        project.task('hello') {
            doLast {
                println("doLast")
            }
        }
    }
}

自定义插件扩展

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class HelloPlugin implements Plugin<Project> {
    void apply(Project project) {
        // 使用project的extensions.create方法创建一个插件扩展
        // 可以看做是任务，只不过在运行时处理
        // 可以有更灵活的操作
        // 前边是插件名，后边是插件的类
        project.extensions.create('greeting', HelloPluginExtension)

        project.task('hello') {
            doLast {
                // 使用扩展插件中的功能
                // project.扩展名.扩展中的方法或属性
                println(project.greeting.message)
            }
        }
    }
}
// 定义的插件初始化的时候不赋值，使用的时候赋值
class HelloPluginExtension {
    String message
}

apply plugin: HelloPlugin
// 给扩展插件赋值
// 方法1
greeting.message = "extension plugin"
// 方法2
greeting {
    message = "extension plugin"
}

标准gradle插件

插件id 自动应用 描述
java java-base 向项目添加java编译，测试和绑定的功能，是许多gradle插件的基础
groovy java,groovy-base 添加对groovy项目的支持
scala java,scala-base 添加对scala项目的支持
antlr java 添加对Antlr生成解析器的支持

source sets(源集)

源集就是用于编译执行的源文件集合，包含源代码和资源文件(如java文件下的main和test)
源集有相应的编译类路径和运行时类路径
源集相关属性

属性 类型 默认值 描述
name-只读 String 非空 源集名字
output-只读 SourceSetOutput 非空 源集输出文件，包括编译过的类和资源
output.classesDirs-只读 FileCollection $buildDir/classes/java/$name
如build/classes/java/main		 源集编译过的class文件目录
output.resourcesDir-只读 File $buildDir/resources/$name
如build/resources/main		 源集产生的资源目录
java-只读 SourceSetOutput ${project.projectDir}/src/
${sourceSet.name}/java/		 源集的java源代码，只包含.java,会排除其他类型
java.srcDirs Set src/$name/java，如src/main/java 源集的java源文件的源目录，是一个集合，可以设置多个源代码目录，更改源代码目录就是更改这个属性
java.outputDirs File $buildDir/classes/java/$name
如build/classes/java/main/		 源代码编译的class文件输出目录
resources-只读 SourceSetOutput ${project.projectDir}/src/
${sourceSet.name}/resources/		 源集的资源，只包含资源
resources.srcDirs Set src/$name/resources，如src/main/resources 源集的资源目录，是一个集合，可以指定多个

sourceSets DSL
sourceSets API

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// 不用嵌套在任何方法里，直接放到build.gradle即可
sourceSets {
    // 这里执行源集为other2，相当于main
    other2 {
        // 指定资源输出文件夹
        output.resourcesDir = file('out/bin')
        // 指定java文件编译后存放的文件夹
        java.outputDir = file('out/bin')
        // 指定java文件的根路径
		// 可以放ml/lightly/demo/Test.java的目录和文件
        // 大括号里的相当于属性，也就相当于是java.srcDirs()
        java {
            srcDirs = ['src/other2/other3/java']
        }
        // 指定资源的根路径
        resources {
            srcDirs = ['src/other2/other3/resources']
        }
    }
}

// 设置一个任务来访问源集
task outSourceSet {
    doLast {
        // 输出所有的源集名称
        sourceSets.all {
            println("$name")
        }
        // 通过各自的源集输出自己源集的名称
        println ("${sourceSets.main.name}")
        println ("${sourceSets.other2.name}")
        println ("${sourceSets.test.name}")
        // 输出一些属性
        println ("${sourceSets.main.java.srcDirs}")
        println ("${sourceSets.main.resources.srcDirs}")
        println ("${sourceSets.other2.java.srcDirs}")
        println ("${sourceSets.other2.resources.srcDirs}")
    }
}

为源集添加依赖

GROOVY 
1
2
3
4
5
6
7
8
9
dependencies {
    // 在单词前边加上源集名称就表示依赖用在哪个源集
    // 默认添加到main的源集
    implementation group: 'com.alibaba', name: 'fastjson', version: '1.2.79'
    // 添加到test源集
    testImplementation group: 'com.alibaba', name: 'fastjson', version: '1.2.79'
    // 添加到other2源集
    other2Implementation group: 'com.alibaba', name: 'fastjson', version: '1.2.79'
}

将源集打jar包

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
task otherJar(type: Jar) {
    // 打包的包名
    archiveBaseName = sourceSets.other2.name
    // 打包的版本
    archiveVersion = '0.1.0'
    // 目标文件夹
    destinationDirectory = file("${project.projectDir}/jar")
    // 从output属性找编译文件
    from sourceSets.other2.output
}
// 如果编码失败，有字符集问题，则设置一下java文件编码格式
tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
}
// 打包出来的jar不能直接执行，还必须要在MANIFEST.MF指定main方法的类
// 要是报错可以不加这个也能打包
jar {
    mainfest {
        attributes "Manifest-Version": 1.0,
                    "Main-Class": "ml.lightly.demo.Test"
    }
}

为源集生成doc

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
task otherDoc(type: Javadoc) {
    // 目标文件夹
    destinationDir = file("${project.projectDir}/doc")
    // 源文件目录来源
    source sourceSets.other2.allJava
    // doc标题
    title sourceSets.other2.name
}
// 如果因为字符集问题生成javadoc失败，则添加下边的任务字符集设置
tasks.withType(Javadoc) {
    options.encoding = 'UTF-8'
}

groovy编码失败

GROOVY 
1
2
3
4
// 添加groovy编码的字符集
tasks.withType(GroovyCompile) {
    groovyOptions.encoding = 'MacRoman'
}

其他常用属性解释

GROOVY 
1
2
3
4
5
6
7
8
9
10
// 自己包的groupId
group = 'ml.lightly.demo'
// artifactId，可以不加，工程名称
archivesBaseName="hello"
// 自己包的version
version = '0.0.1-SNAPSHOT'
// 编译的兼容最低版本
sourceCompatibility = '8'
// 运行的兼容最低版本
targetCompatibility = '8'

gradle运行构建

执行多个任务

依赖多个任务用[]

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 4依赖1，3，排序为134
// 3依赖1，2，1有了，排序为1234
// 2依赖1，1有了，排序为1234
// 所以输出为1234，因为任务重复就只执行一次
task task1 {
    doLast {
        println("1")
    }
}
task task2(dependsOn: task1) {
    doLast {
        println("2")
    }
}
task task3(dependsOn: [task1, task2]) {
    doLast {
        println("3")
    }
}
task task4(dependsOn: [task1, task3]) {
    doLast {
        println("4")
    }
}

排除任务

BASH 
1
2
3
4
# -x 排除执行某任务
# 这里就是执行任务4，但是排除执行任务3
# 任务3所依赖任务2不被任务4依赖，所以任务2也不会执行
gradle task4 -x task3

查看任务流程

选择执行哪些构建

默认找的是当前目录下的xx.gradle文件
通过-b参数指定运行其他目录的构建的任务

BASH 
1
gradle -q -b otherdir/test.gradle hello

文件结构

1
2
3
├── build.gradle
└── otherdir
    └── test.gradle

test.gradle内容

GROOVY 
1
2
3
4
5
6
task hello {
    doLast {
        // 输出test.gradle和otherdir
        println "${buildFile.name}, ${buildFile.parentFile.name}"
    }
}

获取构建信息

BASH 
1
2
# 可以在build.gradle顶部加一个描述：description "asdfasdf"
gradle -q projects

列出任务

BASH 
1
gradle -q tasks --all

其他常用命令

BASH 
1
2
3
4
5
6
7
8
9
10
# 提供有关指定任务或多个任务的使用信息（路径，类型，描述，组）
gradle -q help -task
# 提供所选项目的依赖关系的列表
gradle -q dependencies
# 提供有关配置的有限依赖项的列表
gradle -q api:dependencies --configuration
# 提供一个洞察到一个特定的依赖
gradle -q dependencyInsight
# 所选项目的属性列表
gradle -q properties

gradle构建java项目

  • 目录结构

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    ├── gradle
    │   └── wrapper     
    │           ├── gradle-wrapper.java    gradle的wrapper
    │           └── gradle-wrapper.properties    可以修改里边的distributionUrl为本地路径
    ├── app    自己创建的名为app的模块
    │       ├── build.gradle
    │       └── src
    │           ├── main     
    │           │       ├── java      
    │           │       └── resources  
    │           └── test     
    │                   ├── java      
    │                   └── resources     
    ├── gradlew     gradle的执行脚本
    └── settings.gradle

  • 命令行构建

    BASH 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    gradle init
    # 选择流程按照下边的指示即可

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

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

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

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

    Project name (default: demo):
    Source package (default: demo):


    BUILD SUCCESSFUL
    2 actionable tasks: 2 executed

  • build.gradle内容

    GROOVY 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    // 添加java插件
    apply plugin: 'java'
    // springboot相关插件
    apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'

    // 自己包的groupId
    group = 'ml.lightly.demo'
    // artifactId，可以不加，工程名称
    // archivesBaseName="hello"
    // 自己包的version
    version = '0.0.1-SNAPSHOT'

    // 仓库，如果在buildscript中添加了仓库，这里可以不写
    repositories {
        mavenLocal()
        mavenCentral()
    }

    // 用于多模块的配置，对所有工程都有效
    // allprojects {
    //     group 'ml.lightly.demo'
    //     version  '0.0.1-SNAPSHOT'
    //     repositories {
    //         mavenLocal()
    //         // 外部依赖仓库
    //         maven {
    //             url 'https://maven.aliyun.com/nexus/content/groups/public/'
    //         }
    //         maven {
    //             url 'https://maven.aliyun.com/nexus/content/repositories/jcenter'
    //         }
    //         mavenCentral()
    //     }
    // }

    // 第三方库所需要的东西
    buildscript {
        // 定义一个变量，相当于脚本插件
        ext {
            springBootVersion = ‘2.3.2.RELEASE’
        }

        // 第三方库
        repositories {
            mavenLocal()
            // 外部依赖仓库
            maven {
                url 'https://maven.aliyun.com/nexus/content/groups/public'
            }
            maven {
                url 'https://maven.aliyun.com/nexus/content/repositories/jcenter'
            }
            maven {
                url 'https://repo.spring.io/plugins-release'
            }
            mavenCentral()
        }

        // 编译发布所依赖的插件
        dependencies {
            classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        }
    }

    // 源集
    sourceSets {
        main {
            java {
                srcDir 'src'
            }
        }
        test {
            java {
                srcDir 'test'
            }
        }
    }


    // 依赖
    // 依赖完整格式：group: 'xx', name: 'xxx', version: '4.0.1'
    // 依赖简略格式：'xx:xxx:4.0.1'
    // 依赖包生命周期
    // ----complie                           该参数引入的依赖包编译时期和运行时期都需要
    // ----providedCompile                   该参数引入的依赖包仅编译时期使用
    // ----runtime                           该参数引入的依赖包仅在运行和测试时使用，编译时不需要
    // ----testCompile                       该参数引入的依赖包仅用于测试时编译
    // ----testRuntime                       该参数引入的依赖包引用于测试时运行
    dependencies {
        compile "org.springframework.boot:spring-boot-starter-web"
        implementation group: 'com.alibaba', name: 'fastjson', version: '1.2.79'
        // 引入工程中自己的类库
        // 因为属于一个工程，groupId就不用写了，接着写模块名即可
        compile project(":module-name")
    }

    // 源码编译时的字符集
    tasks.withType(JavaCompile) {
        options.encoding = 'UTF-8'
    }


    // 编译的兼容最低版本
    sourceCompatibility = '8'
    // 运行的兼容最低版本
    targetCompatibility = '8'

    // 如果构建为可执行的java应用程序，MANIFEST.MF要指定main方法的类
    // 要是报错可以不加这个也能打包
    jar {
        mainfest {
            attributes "Manifest-Version": 1.0,
                        "Main-Class": "ml.lightly.demo.Test"
        }
    }

  • settings.gradle内容

    GROOVY 
    1
    2
    3
    4
    // settings.gradle只有一个设置就是根项目名称
    rootProject.name = 'gradle'
    // 添加的自己的模块，一个项目看做一个模块，可以添加多个
    include('app')

  • 编译jar包

    BASH 
    1
    gradle build

gradle构建groovy项目

构建出来后的build.gradle内容

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
apply plugin: 'groovy'

// 仓库，如果在buildscript中添加了仓库，这里可以不写
repositories {
    mavenLocal()
    mavenCentral()
}

// 依赖
dependencies {
    compile 'org.codehaus.groovy:groovy-all:2.4.5'
}

gradle测试

可以使用JUnit或JUnit Jupiter(后者更好)

跳过测试用例

GROOVY 
1
2
3
test {
    enabled = false
}

指定测试用例可被测试

GROOVY 
1
2
3
4
test {
    // 可以用正则来指定目录
    include("ml/lightly/demo/gradle/*")
}

排除测试用例让其不被测试

GROOVY 
1
2
3
4
test {
    // 可以用正则来指定目录
    exclude("ml/lightly/demo/gradle/*")
}

gradle多项目构建

例如微服务中，service，entry，dao各自都是一个模块，就需要多模块构建
一个项目(project)有多个模块(module) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
├── gradle
│   └── wrapper     
│           ├── gradle-wrapper.java    gradle的wrapper
│           └── gradle-wrapper.properties    可以修改里边的distributionUrl为本地路径
├── app    自己创建的名为app的模块
│       ├── build.gradle
│       └── src
│           ├── main     
│           │       ├── java      
│           │       └── resources  
│           └── test     
│                   ├── java      
│                   └── resources     
├── sercive    自己创建的service模块
│       ├── build.gradle
│       └── src
│           ├── main     
│           │       ├── java      
│           │       └── resources  
│           └── test     
│                   ├── java      
│                   └── resources     
├── gradlew     gradle的执行脚本
├── build.gradle
└── settings.gradle

默认创建了app模块，可以自己复制这个文件夹，然后改名添加一个新的模块，如service
settings.gradle再添加include('service')
每个模块可以在xx.gradle加上description
最外层也可以添加一个build.gradle，用于指定所有子模块的的配置

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
description "root project" 

// 为所有工程配置
allprojects {
    // 配置基本信息
    group 'ml.lightly.demo'
    version  '0.0.1-SNAPSHOT'
    repositories {
        mavenLocal()
        // 外部依赖仓库
        maven {
            url 'https://maven.aliyun.com/nexus/content/groups/public/'
        }
        maven {
            url 'https://maven.aliyun.com/nexus/content/repositories/jcenter'
        }
    }

    // 打印所有工程名
    // 使用gradle -q hello打印即可
    task hello {
        doLast {
            task -> println("${task.project.name}")
        }
    }
}

// 只给子工程的配置，root工程不配置
// 子工程中就可以不配置这些项了
subprojects {
    apply plugin: 'java'
    // 这个任务只有子工程执行，root工程不执行
    // 子工程的任务名和root工程任务名相同，不能加task
    hello {
        doLast {
            task -> println("subproject + ${task.project.name}")
        }
    }
}

// 给指定模块指定任务
project(':service').hello {
    doLast {
        task -> println("service + ${task.project.name}")
    }
}

// 同样的，任务也可以加到子模块的gradle文件

子工程各自的依赖包可以自行配置，不需要在顶层统一配置

settings.gradle配置

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
// 根项目名称
rootProject.name = 'gradle'
// 定义每个模块的gradle文件名称
rootProject.children.each {project ->
    // 每个模块的文件名称都是项目名，不是默认的build.gradle
    project.buildFileName = "${project.name}.gradle"
}

// 添加的自己的模块，一个项目看做一个模块，可以添加多个
// 这里app看成一个模块，可以再添加entry，service等模块
include('app')
include('service')

Gradle部署

使用maven插件发布

在子模块，如service,添加如下发布命令

GROOVY 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 添加插件
apply plugin: 'maven-publish'

publishing {
    publications {
        maven(MavenPublication) {
            from(components.java)
        }
    }

    // 发布到本地的目录
    repositories {
        maven {
            url "$buildDir/repo"
        }
    }

    // 发布到远程仓库
    // repositories {
    //     maven {
    //         default credentials for a nexus repository manager
    //         credentials {
    //             username 'name'
    //             password 'password'
    //         }
    //         url "http://localhost:8080/nexus/content/repositories/releases/"
    //     }
    // }
}

在命令行执行

BASH 
1
2
3
4
5
6
# 编译
# 用wrapper的那个gradlew脚本构建也可以
# ./gradlew build -q -b service/build.gradle
gradle build -q -b service/build.gradle
# 发布
gradle publish -q -b service/build.gradle

将项目从Maven转换为Gradle

直接转换pom.xml即可

BASH 
1
2
3
# 会自动搜索当前目录下的pom文件
# 然后转换并生成为gradle相关的配置
gradle init --type pom

其他

GROOVY 
1
2
3
4
5
rootProject.name = 'gradle'
// 可以写成下边这样，用大括号代替了.
rootProject {
    name = 'gradle'
}

讲解视频

  • 本文标题：gradle基本知识
  • 本文作者：Easul
  • 创建时间：2022-03-11 23:42:26
  • 本文链接：https://blog.212490197.xyz/article/tools/gradle/basic-knowledge/
  • 版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
 评论
  1. 1. 三种构建工具的比较
  2. 2. 安装配置
  3. 3. 构建脚本编写
  4. 4. build的三个阶段
  5. 5. 任务构建
    1. 5.1. 普通任务
    2. 5.2. 任务依赖
    3. 5.3. 定位任务
    4. 5.4. 将任务看成数组
    5. 5.5. 在任务中添加描述
    6. 5.6. 跳过任务
  6. 6. 依赖管理
    1. 6.1. 声明依赖关系
    2. 6.2. 依赖关系配置
    3. 6.3. 发布文件
  7. 7. gradle插件
    1. 7.1. 插件类型
    2. 7.2. 应用插件
    3. 7.3. 脚本插件
    4. 7.4. 二进制插件
    5. 7.5. 编写自定义插件
    6. 7.6. 自定义插件扩展
    7. 7.7. 标准gradle插件
    8. 7.8. source sets(源集)
    9. 7.9. 为源集添加依赖
    10. 7.10. 将源集打jar包
    11. 7.11. 为源集生成doc
    12. 7.12. groovy编码失败
    13. 7.13. 其他常用属性解释
  8. 8. gradle运行构建
    1. 8.1. 执行多个任务
    2. 8.2. 排除任务
    3. 8.3. 选择执行哪些构建
    4. 8.4. 获取构建信息
    5. 8.5. 列出任务
    6. 8.6. 其他常用命令
  9. 9. gradle构建java项目
  10. 10. gradle构建groovy项目
  11. 11. gradle测试
    1. 11.1. 跳过测试用例
    2. 11.2. 指定测试用例可被测试
    3. 11.3. 排除测试用例让其不被测试
  12. 12. gradle多项目构建
  13. 13. Gradle部署
    1. 13.1. 使用maven插件发布
    2. 13.2. 将项目从Maven转换为Gradle
  14. 14. 其他