1、Gradle 入门
1.1、Gradle 简介
Gradle 是一款Google 推出的基于 JVM、通用灵活的项目构建工具,支持 Maven,JCenter 多种第三方仓库;支持传递性依赖管理、废弃了繁杂的xml 文件,转而使用简洁的、支持多种语言(例如:java、groovy 等)的 build 脚本文件。
官网地址: https://gradle.org/
1.2、常见的项目构建工具
Ant: 2000 年 Apache 推出的纯Java 编写构建工具,通过 xml[build.xml]文件管理项目优点:使用灵活,速度快(快于 gradle 和 maven),
缺点:Ant 没有强加任何编码约定的项目目录结构,开发人员需编写繁杂XML 文件构建指令,对开发人员是一个挑战。
Maven: 2004 年Apache 组织推出的再次使用xml 文件[pom.xml]管理项目的构建工具。
优点: 遵循一套约定大于配置的项目目录结构,使用统一的GAV 坐标进行依赖管理,侧重于包管理。缺点:项目构建过程僵化,配置文件编写不够灵活、不方便自定义组件,构建速度慢于 gradle。
Gradle: 2012 年Google 推出的基于Groovy 语言的全新项目构建工具,集合了Ant 和 Maven 各自的优势。
优点:集 Ant 脚本的灵活性+Maven 约定大于配置的项目目录优势,支持多种远程仓库和插件,侧重于大项目构建。缺点:学习成本高、资料少、脚本灵活、版本兼容性差等。
1.3、Gradle 安装
Gradle官网:Gradle Build Tool
Gradle官方下载安装教程页面:Gradle | Installation
Gradle官方用户手册:Gradle User Manual
其中SpringBoot 与Gradle 存在版本兼容问题,Gradle 与Idea 也存在兼容问题,所以考虑到 java 程序员会使用SpringBoot,所以要选择 6.8 版本及高于 6.8 版本的Gradle,那么相应的idea 版本也要升级,不能太老哦。
具体参考文档: https://docs.spring.io/spring-boot/docs/2.5.0/gradle-plugin/reference/htmlsingle/#getting-started
1.4、Gradle 项目目录结构
Gradle 项目默认目录结构和Maven 项目的目录结构一致,都是基于约定大于配置【Convention Over Configuration】。其完整项目目录结构如下所示:
Tips:
1. 只有war工程才有webapp目录,对于普通的jar工程并没有webapp目录
2. gradlew与gradlew.bat执行的指定wrapper版本中的gradle指令,不是本地安装的gradle指令哦。
1.5、Gradle 创建第一个项目
借助于 spring 脚手架创建gradle 第一个项目:https://start.spring.io/
1.5.1、Gradle 中的常用指令
需要注意的是:gradle 的指令要在含有build.gradle 的目录执行。
1.5.2、Wrapper 包装器
Gradle Wrapper 实际上就是对 Gradle 的一层包装,用于解决实际开发中可能会遇到的不同的项目需要不同版本的 Gradle
问题。例如:把自己的代码共享给其他人使用,可能出现如下情况:
1. 对方电脑没有安装 gradle
2. 对方电脑安装过 gradle,但是版本太旧了
这时候,我们就可以考虑使用 Gradle Wrapper 了。这也是官方建议使用 Gradle Wrapper 的原因。实际上有了 Gradle Wrapper 之后,我们本地是可以不配置 Gradle 的,下载Gradle 项目后,使用 gradle 项目自带的wrapper 操作也是可以的。
那如何使用Gradle Wrapper 呢?
项目中的gradlew、gradlew.cmd脚本用的就是wrapper中规定的gradle版本。参见源码
而我们上面提到的gradle指令用的是本地gradle,所以gradle指令和gradlew指令所使用的gradle版本有可能是不一样的。
gradlew、gradlew.cmd的使用方式与gradle使用方式完全一致,只不过把gradle指令换成了gradlew指令。
当然,我们也可在终端执行 gradlew 指令时,指定指定一些参数,来控制 Wrapper 的生成,比如依赖的版本等,如下:
具体操作如下所示 :
gradle wrapper --gradle-version=4.4:升级wrapper版本号,只是修改gradle.properties中wrapper版本,未实际下载
gradle wrapper --gradle-version 5.2.1 --distribution-type all :关联源码用
GradleWrapper 的执行流程:
1. 当我们第一次执行 ./gradlew build 命令的时候,gradlew 会读取 gradle-wrapper.properties 文件的配置信息
2. 准确的将指定版本的 gradle 下载并解压到指定的位置(GRADLE_USER_HOME目录下的wrapper/dists目录中)
3. 并构建本地缓存(GRADLE_USER_HOME目录下的caches目录中),下载再使用相同版本的gradle就不用下载了4.之后执行的 ./gradlew 所有命令都是使用指定的 gradle 版本
gradle-wrapper.properties 文件解读:
注意:前面提到的 GRALE_USER_HOME 环境变量用于这里的Gradle Wrapper 下载的特定版本的gradle 存储目录。如果我们没有配置过GRALE_USER_HOME 环境变量,默认在当前用户家目录下的.gradle 文件夹中。
那什么时候选择使用 gradle wrapper、什么时候选择使用本地gradle?
下载别人的项目或者使用操作以前自己写的不同版本的gradle项目时:用Gradle wrapper,也即:gradlew
什么时候使用本地gradle?新建一个项目时: 使用gradle指令即可。
2、Gradle 与 Idea 整合
2.1、Groovy 简介
在某种程度上,Groovy 可以被视为Java 的一种脚本化改良版,Groovy 也是运行在 JVM 上,它可以很好地与 Java 代码及其相关库进行交互操作。它是一种成熟的面向对象编程语言,既可以面向对象编程,又可以用作纯粹的脚本语言。大多数有效的 Java 代码也可以转换为有效的 Groovy 代码,Groovy 和 Java 语言的主要区别是:完成同样的任务所需的Groovy 代码比 Java 代码更少。其特点为:
● 功能强大,例如提供了动态类型转换、闭包和元编程(metaprogramming)支持
● 支持函数式编程,不需要main 函数
● 默认导入常用的包
● 类不支持 default 作用域,且默认作用域为public。
● Groovy 中基本类型也是对象,可以直接调用对象的方法。
● 支持DSL(Domain Specific Languages 领域特定语言)和其它简洁的语法,让代码变得易于阅读和维护。
● Groovy 是基于Java 语言的,所以完全兼容Java 语法,所以对于java 程序员学习成本较低。详细了解请参考:http://www.groovy-lang.org/documentation.html
2.2、Groovy 安装
下载地址: The Apache Groovy programming language - Download
2.3、创建 Groovy 项目
2.4、Groovy 基本语法
类型转换:当需要时,类型之间会自动发生类型转换: 字符串(String)、基本类型(如int) 和类型的包装类 (如Integer)
类说明:如果在一个groovy 文件中没有任何类定义,它将被当做 script 来处理,也就意味着这个文件将被透明的转换为一个 Script 类型的类,这个自动转换得到的类将使用原始的 groovy 文件名作为类的名字。groovy 文件的内容被打包进run 方法,另外在新产生的类中被加入一个main 方法以进行外部执行该脚本。
2.4.1、案例 1:基本注意点
提示:方法调用时,在不含有歧义的地方可以省略方法调用时的括号。这类似于使用${变量名}时,括号在不引起歧义的地方可以省略是一样的:如
def num1=1;
def num2= 2;
println "$num1 + $num2 = ${num1+num2}"
2.4.2、案例 2:引号说明
def num1=1;
def num2=2;
def str1="1d"; //双引号
def str2='dsd'; //单引号
//双引号运算能力,单引号用于常量字符串,三引号相当于模板字符串,可以支持换行
println "$num1 + $num2 = ${num1 + num2}"
//基本数据类型也可以作为对象使用,可以调用对象的方法
println(num1.getClass().toString())
println(str1.getClass().toString())
println(str2.getClass().toString())
2.4.3、案例 3:三个语句结构
Groovy 支持顺序结构从上向下依次解析、分支结构(if..else、if..else if ..else..、switch..case、for、while、do..while)
具体参考官网:http://www.groovy-lang.org/semantics.html#_conditional_structures
2.4.4、案例 4:类型及权限修饰符
Groovy 中的类型有:
1. 原生数据类型及包装类
2. 类、内部类、抽象类、接口
3. 注解
4. Trait: 可以看成是带有方法实现的接口
权限修饰符: public、protected、private
拓展:Groovy 类与 Java 类之间的主要区别是:
1. 没有可见性修饰符的类或方法自动是公共的(可以使用一个特殊的注释来实现包的私有可见性)。
2. 没有可见性修饰符的字段将自动转换为属性,不需要显式的 getter 和 setter 方法。
3. 如果属性声明为 final,则不会生成 setter。
4. 一个源文件可能包含一个或多个类(但是如果一个文件不包含类定义的代码,则将其视为脚本)。脚本只是具有一些特殊约定的类,它们的名称与源文件相同(所以不要在脚本中包含与脚本源文件名相同的类定义)。
http://www.groovy-lang.org/objectorientation.html#_modifiers_on_a_property
2.4.5、案例 5:集合操作
Groovy 支持List、Map 集合操作,并且拓展了 Java 中的API,具体参考如下方法:
List:
● add():添加某个元素plus():添加某个list 集合
● remove():删除指定下标的元素removeElement():删除某个指定的元素removeAll(): 移除某个集合中的元素
● pop():弹出list 集合中最后一个元素putAt():修改指定下标的元素
● each():遍历
● size(): 获取list 列表中元素的个数
● contains(): 判断列表中是否包含指定的值,则返回 true
Map:
● put():向map 中添加元素
● remove():根据某个键做移除,或者移除某个键值对
● +、-:支持 map 集合的加减操作
● each():遍历map 集合
请参考官网:http://www.groovy-lang.org/syntax.html#_number_type_suffixes
提示:可以把不同的基本类型添加到同一集合中。
2.4.6、案例 6:类导入
Groovy 遵循 Java 允许 import 语句解析类引用的概念。
import groovy.xml.MarkupBuilder
def xml = new MarkupBuilder()
assert xml != null
Groovy 语言默认提供的导入
import java.lang.*
import java.util.*
import java.io.*
import java.net.*
import groovy.lang.*
import groovy.util.*
import java.math.BigInteger
import java.math.BigDecimal
2.4.7、案例 7:异常处理
Groovy 中的异常处理和 java 中的异常处理是一样的。
def z
try {
def i = 7, j = 0
try {
def k = i / j
assert false
} finally {
z = 'reached here'
}
} catch ( e ) {
assert e in ArithmeticException
assert z == 'reached here'
}
参考官网地址: http://www.groovy-lang.org/semantics.html#_try_catch_finally
2.4.8、案例 8:闭包
闭包:Groovy 中的闭包是一个开放的、匿名的代码块,它可以接受参数、也可以有返回值。闭包可以引用其周围作用域中声明的变量。
语法:{ [closureParameters -> ] statements }
其中[ closureParameters-> ]是一个可选的逗号分隔的参数列表,参数后面是 Groovy 语句。参数类似于方法参数列表, 这些参数可以是类型化的,也可以是非类型化的。当指定参数列表时,需要使用-> 字符,用于将参数与闭包体分离。
参考:http://www.groovy-lang.org/closures.html
//闭包体完成变量自增操作
{ item++ }
//闭包使用 空参数列表 明确规定这是无参的
{ -> item++ }
//闭包中有一个默认的参数[it],写不写无所谓
{ println it }
{ it -> println it }
//如果不想使用默认的闭包参数it,那需要显示自定义参数的名称
{ name -> println name }
//闭包也可以接受多个参数
{ String x, int y ->
println "hey ${x} the value is ${y}"
}
//闭包参数也可是一个对象
{ reader ->
def line = reader.readLine()
line.trim()
}
闭包调用方式: 闭包是 groovy.lang.Closure 的实例。它可以像任何其他变量一样分配给一个变量或字段。
闭包对象(参数)
闭包对象.call(参数)
def isOdd = { int i -> i%2 != 0 }
assert isOdd(3) == true
assert isOdd.call(2) == false
def isEven = { it%2 == 0 }
assert isEven(3) == false
assert isEven.call(2) == true
特殊说明: 可以把闭包当作一个对象,作为参数传递给方法使用
//无参闭包
def run(Closure closure){
println("run start...")
closure() println("run end...")
}
run {
println "running......"
}
//有参闭包
def caculate(Closure closure){
def num1=1;
def num2=3;
println("caculate start...")
closure(num1,num2)
println("caculate end...")
}
caculate {x,y -> println "计算结果为:$x+$y=${x+y}"} //在build.gradle文件中我们见到的很多都是闭包格式的。
3、Gradle 进阶说明
3.1、项目的生命周期
Gradle 项目的生命周期分为三大阶段: Initialization -> Configuration -> Execution. 每个阶段都有自己的职责,具体如下图所示:
● Initialization 阶段主要目的是初始化构建, 它又分为两个子过程,一个是执行 Init Script,另一个是执行 Setting Script。
● init.gradle 文件会在每个项目 build 之前被调用,用于做一些初始化的操作,它主要有如下作用:
○ 配置内部的仓库信息(如公司的 maven 仓库信息);
○ 配置一些全局属性;
○ 配置用户名及密码信息(如公司仓库的用户名和密码信息)。
● Setting Script 则更重要, 它初始化了一次构建所参与的所有模块。
● Configuration 阶段:这个阶段开始加载项目中所有模块的 Build Script。所谓 "加载" 就是执行 build.gradle 中的语句, 根据脚本代码创建对应的 task, 最终根据所有 task 生成由 Task 组成的有向无环图(Directed Acyclic Graphs),如下:
从而构成如下有向无环树:
● Execution 阶段:这个阶段会根据上个阶段构建好的有向无环图,按着顺序执行 Task【Action 动作】。
3.2、settings 文件
首先对 settings 文件的几点说明:
1、作用:主要是在项目初始化阶段确定一下引入哪些工程需要加入到项目构建中,为构建项目工程树做准备。
2、工程树:gradle 中有工程树的概念,类似于 maven 中的project 与module。
3、内容:里面主要定义了当前 gradle 项目及子 project 的项目名称
4、位置:必须放在根工程目录下。
5、名字:为settings.gradle 文件,不能发生变化
6、对应实例:与 org.gradle.api.initialization.Settings 实例是一一对应的关系。每个项目只有一个settings 文件。
7、关注:作为开发者我们只需要关注该文件中的include 方法即可。使用相对路径【 : 】引入子工程。
8.一个子工程只有在setting 文件中配置了才会被 gradle 识别,这样在构建的时候才会被包含进去。案例如下所示:
//根工程项目名
rootProject.name = 'root'
//包含的子工程名称
include 'subject01'
include 'subject02'
include 'subject03'
//包含的子工程下的子工程名称
include 'subject01:subproject011'
include 'subject01:subproject012'
项目名称中 ":" 代表项目的分隔符, 类似路径中的 "/". 如果以 ":" 开头则表示相对于 root project 。然后 Gradle 会为每个带有 build.gradle 脚本文件的工程构建一个与之对应的 Project 对象。
3.3、Task
项目实质上是 Task 对象的集合。一个 Task 表示一个逻辑上较为独立的执行过程,比如编译Java 源代码,拷贝文件, 打包Jar 文件,甚至可以是执行一个系统命令。另外,一个 Task 可以读取和设置Project 的Property 以完成特定的操作。
3.3.1、任务入门
可参考官方文档:https://docs.gradle.org/current/userguide/tutorial_using_tasks.html
让我们来先看一个例子:
task A {
println "root taskA"
doFirst(){
println "root taskA doFirst"
}
doLast(){
println "root taskA doLast"
}
}
在文件所在的目录执行命令: gradle A。
提示 1 :task 的配置段是在配置阶段完成
提示 2 :task 的doFirst、doLast 方法是执行阶段完成,并且doFirst 在doLast 执行之前执行。
提示 3:区分任务的配置段和任务的行为,任务的配置段在配置阶段执行,任务的行为在执行阶段执行
3.3.2、任务的行为
案例如下:doFirst、doLast 两个方法可以在任务内部定义,也可以在任务外部定义
def map=new HashMap<String,Object>();
//action属性可以设置为闭包,设置task自身的行为
map.put("action",{println "taskD.."})
task(map,"a"){
description 'taskA description '
group "atguigu"
//在task内部定义doFirst、doLast行为
doFirst {
def name = 'doFirst..'
println name
}
doLast {
def name = 'doLast..'
println name
}
}
//在task外部定义doFirst、doLast行为
a.doFirst {
println it.description
}
a.doLast {
println it.group
}
底层原理分析:无论是定义任务自身的 action,还是添加的doLast、doFirst 方法,其实底层都被放入到一个Action 的List 中了,最初这个 action List 是空的,当我们设置了 action【任务自身的行为】,它先将action 添加到列表中,此时列表中只有一个action,后续执行doFirst 的时候doFirst 在action 前面添加,执行 doLast 的时候doLast 在action 后面添加。doFirst 永远添加在actions List 的第一位,保证添加的Action 在现有的 action List 元素的最前面;doLast 永远都是在action List 末尾添加,保证其添加的Action 在现有的action List 元素的最后面。一个往前面添加,一个往后面添加,最后这个action List 就按顺序形成了doFirst、doSelf、doLast 三部分的 Actions,就达到 doFirst、doSelf、doLast 三部分的 Actions 顺序执行的目的。
3.3.3、任务的依赖方式
Task 之间的依赖关系可以在以下几部分设置:
1. 参数依赖
2. 内部依赖
3. 外部依赖
方式一:参数方式依赖
task A {
doLast {
println "TaskA.."
}
}
task 'B' {
doLast {
println "TaskB.."
}
}
//参数方式依赖: dependsOn后面用冒号
task 'C'(dependsOn: ['A', 'B']) {
doLast {
println "TaskC.."
}
}}
方式二:内部依赖
//参数方式依赖
task 'C' {
//内部依赖:dependsOn后面用 = 号
dependsOn= [A,B]
doLast {
println "TaskC.."
}
}
方式三:外部依赖
//外部依赖:可变参数,引号可加可不加
C.dependsOn(B,'A')
当然:task 也支持跨项目依赖
在subproject01 工程的 build.gradle 文件中定义:
task A {
doLast {
println "TaskA.."
}
}
在subproject02 工程的 build.gradle 文件中定义:
task B{
dependsOn(":subproject01:A") //依赖根工程下的subject01中的任务A :跨项目依赖。
doLast {
println "TaskB.."
}
}
拓展 1:当一个 Task 依赖多个Task 的时候,被依赖的Task 之间如果没有依赖关系,那么它们的执行顺序是随机的,并无影响。
拓展 2:重复依赖的任务只会执行一次,比如:
A->B、C
B->C
任务A 依赖任务 B 和任务 C、任务 B 依赖C 任务。执行任务A 的时候,显然任务C 被重复依赖了,C 只会执行一次。
3.3.4、任务执行
任务执行语法:gradle [taskName...] [--option-name...]。