Gradle 自动化构建开源工具_fastjson gradle

写在前面

Gradle是一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具。
面向Java应用为主。当前其支持的语言C++、Java、Groovy、Kotlin、Scala和Swift，计划未来将支持更多的语言。

1、下载与安装（windows）

1、gradle官网下载：https://gradle.org/releases/

2、解压下载Gradle包，配置环境变量
新建系统环境 GRADLE_HOME，值为gradle解压后的目录
找到path变量，后面添加 %GRADLE_HOME%\bin
3、打开cmd,输入gradle -v ，测试是否配置完成

1.1、idea中配置gradle

在IDEA中创建Gradle项目时，会自动生成gradle文件夹，其中就包括 gradle-wrapper.properties ，IDEA默认使用gradle wrapper来创建项目，所以无需安装gradle也可以正常运行。

下面是配置gradle的仓库

2、基础知识（Gradle 6.9为例）

1、Projects 和 tasks
任何一个 Gradle 构建都是由一个或多个 projects 组成。一个projects 由多个project构成，每个 project 都由多个 tasks 组成。每个 task 都代表了构建执行过程中的一个原子性操作。

2、Gradle 脚本采用 Groovy 书写
脚本示例：build.gradle

task hello {
    doLast {
        println 'Hello world!'
    }
}
1
2
3
4
5

在该文件目录下执行：gradle -q hello​

以上代码可简写为

task hello {
    println 'Hello world!'
}
1
2
3

<<在Gradle4.x中被弃用，在Gradle 5.0中被移除。
弃用以前写法：

task hello << {
    println 'Hello world!'
}
1
2
3

2.1、Gradle 脚本语法

2.1.1、dependsOn

dependsOn 指定依赖关系

task hello {
    println 'Hello world!'
}
task intro(dependsOn: hello) {
    println "I'm Gradle"
}
1
2
3
4
5
6

延迟依赖：依赖在定义之前使用，该依赖会在后面执行

task taskX(dependsOn: 'taskY') {
    println 'taskX'
}
task taskY {
    println 'taskY'
}
1
2
3
4
5
6

运行结果

 \> gradle -q taskX
taskY
taskX
1
2
3

2.1.2、创建动态任务

\> gradle -q task1
I'm task number 1
1
2

2.1.3、增加任务行为

为已存在的任务增加行为。

4.times { counter ->
    task "task$counter" {
        println "I'm task number $counter"
    }
}
task0.dependsOn task2, task3
1
2
3
4
5
6

为任务增加多个行为

task hello {
    println 'Hello Earth'
}
hello.doFirst {
    println 'Hello Venus'
}
hello.doLast {
    println 'Hello Mars'
}
hello {
    println 'Hello Jupiter'
}
1
2
3
4
5
6
7
8
9
10
11
12

2.1.4、参数

$hello.name 可以调用任务hello的名字

task hello {
    println 'Hello world!'
}
hello.doLast {
    println "Greetings from the $hello.name task."
}
1
2
3
4
5
6

新增一个叫做 myProperty 的属性，用 ext.myProperty 的方式给他一个初始值。

task myTask {
    ext.myProperty = "myValue"
}

task printTaskProperties {
    println myTask.myProperty
}
1
2
3
4
5
6
7

2.1.5、Ant 任务

对 Ant 任务进行了的整合

task loadfile {
    def files = file('../antLoadfileResources').listFiles().sort()
    files.each { File file ->
        if (file.isFile()) {
            ant.loadfile(srcFile: file, property: file.name)
            println " *** $file.name ***"
            println "${ant.properties[file.name]}"
        }
    }
}
1
2
3
4
5
6
7
8
9
10

2.1.6、方法

写一个方法fileList()

task checksum {
    fileList('../antLoadfileResources').each {File file ->
        ant.checksum(file: file, property: "cs_$file.name")
        println "$file.name Checksum: ${ant.properties["cs_$file.name"]}"
    }
}
task loadfile {
    fileList('../antLoadfileResources').each {File file ->
        ant.loadfile(srcFile: file, property: file.name)
        println "I'm fond of $file.name"
    }
}
File[] fileList(String dir) {
    file(dir).listFiles({file -> file.isFile() } as FileFilter).sort()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.1.7、默认任务

定义默认任务

defaultTasks 'clean', 'run'
task clean {
    println '默认任务1'
}
task run {
    println '默认任务2'
}
task other {
    println "这个不是默认任务"
}
1
2
3
4
5
6
7
8
9
10

执行

\> gradle -q
默认任务1
默认任务2
1
2
3

2.1.6、依赖任务的不同输出

依赖任务的不同输出

task distribution << {
    println "We build the zip with version=$version"
}
task release(dependsOn: 'distribution') << {
    println 'We release now'
}
gradle.taskGraph.whenReady {taskGraph ->
    if (taskGraph.hasTask(release)) {
        version = '1.0'
    } else {
        version = '1.0-SNAPSHOT'
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出

\> gradle -q distribution
We build the zip with version=1.0-SNAPSHOT

\> gradle -q release
We build the zip with version=1.0
We release now
1
2
3
4
5
6

3、java项目中使用

3.1、在已有项目中构建gradle

在项目目录下：gradle init

构建完成会生成相关文件

3.2、在新建项目时构建gradle（idea）

在idea中新建Gradle项目

新建一个项目gradleDemo1,如下是项目目录结构

3.3、gradle项目目录结构

├─.gradle                           
├─.idea
├─gradle                            // 为包装文件生成的文件夹
│  └─wrapper
│    ├── gradle-wrapper.jar
│    └── gradle-wrapper.properties
├── gradlew                          // Gradle 包装器启动脚本
├── gradlew.bat                      // Gradle 包装器启动脚本
├── settings.gradle                  // 用于定义构建名称和子项目的设置文件
├── build.gradle                     // gradle 配置内容
└─src                                // 项目代码
    ├─main
    │  ├─java
    │  └─resources
    └─test
        ├─java
        └─resources

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.4、build.gradle

3.4.1、plugins

plugins 中配置的是gradle脚本使用到的插件。如果使用的是核心插件如 ‘java’无需指定版本，使用的是“社区插件”则必须指定version。

plugins {
    id 'java'
    id 'application'
    id 'org.springframework.boot' version '2.3.4.RELEASE'
}
1
2
3
4
5

3.4.2、repositories

repositories 配置各种仓库示例

repositories {
    mavenLocal()
    maven { url 'http://192.168.1.1:80/content/groups/public' }
    maven { url 'http://192.168.1.1:80/content/groups/public-snapshots' }
    mavenCentral()
}
1
2
3
4
5
6

3.4.3、dependencies

dependencies 项目依赖项示例

dependencies {
    //单个依赖
    implementation group: 'com.alibaba', name: 'fastjson', version: '1.2.73'
    //单个依赖简写
    implementation 'com.alibaba:fastjson:1.2.73'
    //多个依赖
    implementation 'com.alibaba:fastjson:1.2.73', 'log4j:log4j:1.2.17'
    //闭包依赖，为了添加额外配置
    implementation("org.mybatis:mybatis:3.5.6"){
        exclude group :"org.springframework",module:"spring"
        exclude group :"org.javassist",module:"javassist"
        exclude group :"org.jboss.netty",module:"netty"
    }
    //双引号方式使用变量，在ext中声明或 def 关键字声明变量 lombok_version=具体版本
    annotationProcessor "org.projectlombok:lombok:$lombok_version"
    compileOnly "org.projectlombok:lombok:${lombok_version}"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.4.4、configurations

configurations 配置全局排除依赖示例

configurations {
    all{
        exclude group :"org.springframework.boot",module:"spring-boot-starter-logging"
    }
    //编译期排除
    //compile.exclude module: 'spring-boot-starter-logging'
    //在构建过程中排除
    //all*.exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
}
//简写
configurations.all*.exclude module: "spring-boot-starter-logging"
1
2
3
4
5
6
7
8
9
10
11

3.4.5、buildscript

buildscript 中声明的是gradle脚本自身需要使用的资源。可以声明包括变量、任务、依赖项、第三方插件、maven仓库地址等。gradle在执行脚本时会优先执行该代码块中的内容，而后执行其它脚本。

buildscript {
  //变量
  ext {
    spring_boot_version = '2.3.4.RELEASE'
    spring_dependency_management_version = '1.0.10.RELEASE'
  }
  
  //maven仓库
  repositories {
    mavenLocal()
    maven { url 'http://192.168.1.1:80/content/groups/public' }
    maven { url 'http://192.168.1.1:80/content/groups/public-snapshots' }
    mavenCentral()
  }
  
  //依赖项
  dependencies {
    classpath "io.spring.gradle:dependency-management-plugin:${spring_dependency_management_version}"
    classpath "org.springframework.boot:spring-boot-gradle-plugin:${spring_boot_version}"
  }
  
  //任务
  task myTask(){
  	//处理任务
  }
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

3.4.6、依赖版本管理

在gradle官方文档中明确指出，如果想使用依赖关系管理，那就需要使用的gradle版本大于4.4。

方式一，使用插件：

plugins {
    id 'java'
    //指定版本
    id 'org.springframework.boot' version "2.3.4.RELEASE"
    //配置依赖管理插件，自定义托管版本
    id 'io.spring.dependency-management' version "1.0.10.RELEASE"
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    testImplementation "org.springframework.boot:spring-boot-starter-test"
}
1
2
3
4
5
6
7
8
9
10
11
12
13

方式二，使用插件，自动追加版本

plugins {
    id 'java'
    //指定版本
    id 'org.springframework.boot' version "2.3.4.RELEASE"
}

//应用依赖管理插件，自动给插件追加版本号
apply plugin: "io.spring.dependency-management"

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    testImplementation "org.springframework.boot:spring-boot-starter-test"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

使用 BOM 方式管理 spring-cloud依赖版本

plugins {
    id 'java'
    id 'org.springframework.boot' version "2.3.4.RELEASE"
    id 'io.spring.dependency-management' version "1.0.10.RELEASE"
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
	implementation "org.springframework.cloud:spring-cloud-starter-config"
	implementation "org.springframework.cloud:spring-cloud-starter-openfeign"
}

dependencyManagement {
    imports {
    	mavenBom "org.springframework.cloud:spring-cloud-dependencies:${spring_cloud_version}"
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.4.7、乱码与测试编译

编译乱码处理

//在 build.gradle 增加以下配置
tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
}
1
2
3
4

跳过测试编译

//在 build.gradle 增加以下配置
gradle.taskGraph.whenReady {
    tasks.each { task ->
        if (task.name.contains("test")) {
            task.enabled = false
        }
    }
}
1
2
3
4
5
6
7
8

3.4.8、发布私服配置

// 1.私服账号密码
buildscript {
    ext {
        nexusUsername = 'admin'
        nexusPassword = '12345'
    }
}
// 2.配置分组，版本号
group 'com.alone.demo'
version '0.0.1-SNAPSHOT'
// 3.配置maven插件
plugins {
    id 'maven'
}

//发布私服，包名为文件 settings.gradle 中 rootProject.name 配置的名称，版本为上文配置的 verison 版本号
uploadArchives {
    repositories {
        mavenDeployer {
        	//这里配置自己的私服地址
            repository(url: "http://192.168.1.1:80/content/repositories/releases/") {
                authentication(userName: nexusUsername, password: nexusPassword)
            }
            //这里配置自己的私服地址
            snapshotRepository(url: "http://192.168.1.1:80/content/repositories/snapshots/") {
                authentication(userName: nexusUsername, password: nexusPassword)
            }
        }
    }
}
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

执行发布

gradle uploadArchives
1

发布本地

// 1.配置分组，版本号
group 'com.alone.demo'
version '0.0.1-SNAPSHOT'
// 3.配置maven插件
plugins {
    id 'maven-publish'
}

//发布本地，包名为文件 settings.gradle 中 rootProject.name 配置的名称，版本为上文配置的 verison 版本号
publishing {
    publications {
        maven(MavenPublication) {
            from(components.java)
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.4.9、依赖冲突

1.通过配置全局排除冲突包（全局封杀）

//方式一
configurations {
    all{
        exclude group :"org.springframework.boot",module:"spring-boot-starter-logging"
    }
}

//方式二 简写
configurations.all*.exclude module: "spring-boot-starter-logging"
1
2
3
4
5
6
7
8
9

2.诊断出具体依赖项冲突可以排除具体包

dependencies {
    implementation("org.mybatis:mybatis:3.5.6"){
        exclude group :"org.springframework",module:"spring"
        exclude group :"org.jboss.netty",module:"netty"
    }
}
1
2
3
4
5
6

3.强制指定版本策略，即在发生冲突时使用指定的版本

//冲突失败策略设置
configurations.all {
    resolutionStrategy {  failOnVersionConflict() }
}
//强制指定版本策略设置
dependencies {
	//方式一 闭包
    implementation ("io.netty:netty-all:4.0.44.Final"){
        force true
    }
    //方式二 简写
    implementation group: 'io.netty', name: 'netty-all', version: '4.0.44.Final', force: true
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4.在平时使用动态依赖来减小发生版本冲突的几率

dependencies {
    //方式一：指定某个版本以上，减小发生版本冲突的几率。如以下依赖选择 3 以上任意一个版本
    implementation 'cn.afterturn:easypoi-base:3.+'
    // 方式二：选择最新的版本
    implementation 'cn.afterturn:easypoi-base:latest.integration'
}
1
2
3
4
5
6

3.5、相关指令

gradle clean              // 清理
gradle clean build        // 构建打包
gradle dependencies       // 查看依赖
gradle dependencies -configuration compile        // 查看编译时依赖
gradle clean build -x test                        // 编译时跳过测试，使用 -x,-x 参数用来排除不需要执行的任务
1
2
3
4
5

idea可以在界面上操作