入职新公司，构建项目的工具用的gradle，以前没用过，看到一个build.gradle，点进去，心里一句我曹，这写的都是些什么玩意，方得一批，赶紧去补了下课。 

        好吧，先学点语法，这时我从屏幕倒影看到背后新来的老哥电脑屏幕上显示了在百度groovy，马萨卡？？

Grooy篇

Groovy安装

        这玩意和安装java差不多啊，先找到官方下载页：groovy官方下载地址

        找了个现在的稳定版本就开始熟悉基础语法

         配置一下系统变量，这简单，win11点击开始，去找到设置

 接着点呗

 

建一个 GROOVY_HOME=本地路径安装路径  的变量 ，再找到Path变量，编辑它，追尾（呸），在尾部添加一个变量，像这样

好了，到此为止，去cmd验证一下吧，win+R，输入cmd

在控制台输入groovy -v

显示版本信息就安装完成啦！

Groovy基础语法

先建个groovy项目，这就不介绍了吧。这有点不搞基（输入法好像泄露了什么），groovy是基于JVM的，所以很多语法学起来没啥压力，确实groovy提供了一些比java更好用的方法

现在假装我们项目建好了，直接开整，写个hello world吧

package com.zab.groovytestprintln 'hello world'

 啊这，好像挺简单的

Groovy常用数据类型

简单，直接上代码

package com.zab.groovytestint a = 111
println a.classdouble b = 1.1
println b.classdef c = 200
println c.class
//弱类型定义，后续可更改类型
def d = 1.122
println d.class
d = 1
println d.class//单引号定义字符串，格式需要自己用转义字符定义
def s1 = 'za\nb1'
println s1
println s1.class//双引号定义字符串，用于可扩展字符串
def s2 = "zab2"
def s22 = "zab2${s2}"
def s222 = "zab2${100+100}"
println s2
println s2.class
println s22.class
println s222.class//三引号定义字符串，格式直接换行都行，加个反斜杠输出就和实际一致，不加会多一个空行
def s3 = '''\
za
b3'''
println s3
println s3.classdef s4 = "higroovy"
println s4.center(12)println s4.center(12, 'ab')
println s4.padRight(11, 'ab')
println s4.reverse()
//首字母大写
println s4.capitalize()
def s5 = "123"
//转换类型
println s5.toInteger().class//截取
def s6 = "groovy"
println s6[2]
println s6[2..5]//字符串减法
def s7 = "groovyhello"
println s7.minus("hello")
println s7 - "groovy"

 代码挺简单，大家拷过去，跑一下，就假装自己会了吧，反正我们要学的是gradle，这jb简单得抠脚的基础语法，看看就行。

Groovy类、方法定义

定义类同时也可以定义方法，也是很简单，可以直接通过代码看懂

package com.zab.groovytestclass Student {String name;Integer age;Student(String name, Integer age){this.name = name;this.age = age;}Student(){}//方法的定义def sayHello(){println "hello ${name}"}//默认返回最后一行def sayHello2(param1, param2){"hello ${param1} ----- ${param2}"}//静态方法static def sayHello3(){println "hello static"}//默认方法，当调用方法不存在时，会调用该方法//有该方法就不会调用 invokeMethoddef methodMissing(String name, args){println "method missing ${name}"}//invokeMethod的使用，当methodMissing方法不存在时，会调用该方法@Overridedef invokeMethod(String name, args){println "invokeMethod ${name}"}
}

然后我们看看如何去new这个类

package com.zab.groovytest//定义类的方法
//无参构造
def zhangsan = new Student(name: "zhangsan", age: 10)
def lisi = new Student(name: "lisi")//有参构造
def wangwu = new Student("wangwu", 20)
def zhaoliu = [name: "zhaoliu", age: 30] as Student
Student tianqi = ["tianqi", 20]//属性的取值
println "名字：${zhangsan.name}, 年龄：${zhangsan.age}"
println "名字：${zhangsan.getName()}, 年龄：${zhangsan.getAge()}"tianqi.sayHelloo()

这里注意，我调用了一个sayHelloo方法，这个方法不存在，会调用到methodMissing，如果类里面没定义methodMissing，会调用invokeMethod

Groovy集合

package com.zab.groovytest//定义集合
def list = [1,2,3,4,5]
println list.class
println list.size()//定义数组
def array = [1,2,3,4,5] as int[]
println array.class
println array.size()//列表的使用
//添加元素
list.add(6)
println list
list.leftShift(7)
println list
list << 8
println list
def newList = list + 9
println newList//按照索引删除元素
newList.remove(0)
println newList//按照元素删除元素
newList.remove((Object)8)
println newList
newList.removeElement(4)
println newList//按照条件删除元素
newList.removeAll({it % 2 == 0})
newList.removeIf({it > 5})
println newList
def newList1 = newList - [3, 5]
println newList1//排序
newList = [1,-3,5,2,-4]
newList.sort()
println newList
//按照绝对值排序
newList.sort({Math.abs(it)})
println newList
//按照长度排序
def listStr = ["abc","ddef","12f3","45ddd6"]
listStr.sort({it.length()})
println listStr//查找
println newList.findAll({it > 0})
println newList.find({it > 0})
//判断是否存在
println newList.any({it > 0})
//判断是否全部满足
println newList.every({it > 0})
//统计
println newList.count({it > 0})

 一句话点评groovy的集合，很灵活，很脚本（一个功能，这样写也可以，那样写也可以）

Groovy Map

package com.zab.groovytest
//定义map
def map = ['张三':18, '李四':20, '王五':22]
println map.class
println map//添加元素
map.put('赵六', 24)
println map
map['田七'] = 26
println map
map.'newMap' = ['x':1, 'y':2]
println map
//map单引号可以不写
def map2 = [张三:18, 李四:20, 王五:22]
println map2
println map2.getClass()//遍历map
println "--------遍历map--------"
for (i in map2) {println iprintln i.keyprintln i.value
}
map2.each{println itprintln it.keyprintln it.value
}
//带下标的遍历
println "--------带下标的遍历--------"
map2.eachWithIndex{ key,value,index ->println keyprintln valueprintln index
}//查找map3
println "--------查找map3--------"
def map3 = [张三:['score':88,'sex':'男'],李四:['score':78,'sex':'女'],王五:['score':68,'sex':'女'],赵六:['score':58,'sex':'男']
]
//查找score大于60的
println map3.findAll{it.value.score > 60}
println map3.find{it.value.score > 60}
//查找score大于60的，sex为女的数量
println map3.count{it.value.score > 60 && it.value.sex == '女'}
//分组，低于60分的为不及格，60-80为中等，80以上为优秀
println map3.groupBy{if (it.value.score < 60) {'不及格'} else if (it.value.score < 80) {'中等'} else {'优秀'}
}
//排序，按照成绩从高到低
println map3.sort{it.value.score}
//排序，按照成绩从低到高
println map3.sort{it.value.score}.reverse()

一句话点评groovy的Map，很灵活，很脚本（一个功能，这样写也可以，那样写也可以），等等这句话我好像刚刚看到过

Groovy Range

这个是java没有的功能，有点像个集合的变种

package com.zab.groovytest//定义范围
def r = 2..5
println r.classdef r1 = 3..<8
println r1.size()//范围的基本操作，实际上范围就是一个列表的实现
println r.contains(3)
println r.from
println r.to//范围的遍历
for (i in r) {println i
}
r1.each {println it}//范围的转换
def list = r.toList()

Groovy MetaClass        

这是一个动态为class添加方法或者字段的东西，真是一些奇奇怪怪的知识

package com.zab.groovytest//动态为Student添加方法
Student.metaClass.sayHello4 = {println "hello4"
}//动态为Student添加静态方法
Student.metaClass.static.sayHello5 = {println "hello5"
}//动态为Student添加属性
Student.metaClass.sex = "女"def student = new Student("zhangsan", 18)//调用动态添加的方法
student.sayHello4()
Student.sayHello5()
println student.sex

Groovy Closure（闭包）

这个好重要，认真学习一下

package com.zab.groovytest//本质上闭包就是一个代码块，可以把闭包理解为一个匿名函数
//闭包的定义
def closure = {println "hello closure"
}
//闭包的调用
closure()
closure.call()//闭包的参数
def closure2 = {String name ->println "hello ${name}"
}
closure2("")
closure2.call("lisi")def closure3 = {String name, int i ->println "hello ${name} ${i}"
}
closure3("lisi", 10)//闭包的默认参数, it
def closure4 = {println "hello ${it}"
}
closure4("lisi")//闭包的返回值
def closure5 = {return "hello closure"
}
println closure5()//闭包的循环，直接点进去看源码
1.upto(10, closure4)
//这种写法也可以
1.upto(10){println it}//从1加到100，闭包的循环
def sum = 0
1.upto(100, {sum += it})
println sum//downto的使用
10.downto(1, {println it})//times 的使用，指定次数循环
10.times({println it})def s = "hello groovy 2023"
//each的使用
s.each({println it})
//find的使用
println s.find({it.isNumber()})
//findAll的使用
println s.findAll({it.isNumber()})
//any的使用
println s.any({it.isNumber()})
println s.any {it.isNumber()}
//every的使用
println s.every({it.isNumber()})
//collect的使用
println s.collect({it.toUpperCase()})//闭包的参数：this,owner,delegate
//this:指向当前闭包
//owner:指向当前闭包所属的对象
//delegate:指向当前闭包所属的对象，但是可以被修改
def closure6 = {println "this: ${this}"println "owner: ${owner}"println "delegate: ${delegate}"
}
closure6()
//一般这三个参数都是一样的，只有当闭包中包含闭包的时候，不一样
/*** c1 this: com.zab.groovytest.GroovyClosure@162be91c* c1 owner: com.zab.groovytest.GroovyClosure@162be91c* c1 delegate: com.zab.groovytest.GroovyClosure@162be91c* c2 this:com.zab.groovytest.GroovyClosure@162be91c* c2 owner:com.zab.groovytest.GroovyClosure$_run_closure18@31e3250d* c2 delegate:xxx*/
def c1 = {println "c1 this: ${this}"println "c1 owner: ${owner}"println "c1 delegate: ${delegate}"def c2 = {println "c2 this:"+ thisprintln "c2 owner:"+ ownerprintln "c2 delegate:"+ delegate}c2.delegate = "xxx"c2()
}
c1.call()

Groovy switch和for

package com.zab.groovytest
//groovy的switch非常灵活
def a = 10switch (a){case Integer:println "a is Integer"breakcase "abc":println "a is abc"breakcase [100,10]:println "a in 10,100"breakcase 1.1:println "a is 1.1"breakcase 1..100:println "a in 1-100"breakdefault:println "a is nothing"break
}
//普通范围
println "--------普通范围循环--------"
for (i in 0..5) {println i
}
println "--------普通范围小于--------"
for (i in 0..<5) {println i
}
println "--------列表循环--------"
for (i in [10,20,30,40,50]) {println i
}
println "--------map循环--------"
for (i in [10:"hh",20:"jj",30:"kk"]) {println iprintln i.value
}

Groovy 文件操作

package com.zab.groovytest//读取文件
def file = new File("d://json.txt")
//方式一，readLines
def lines = file.readLines()
println lines//方式二，eachLine
file.eachLine{println it
}
//方式三，getText
println file.getText()//写入文件
def file2 = new File("d://json2.txt")
file2.write("hello world")//定义一个方法，参数一是源文件，参数二是复制的文件，实现copy功能
def copyFile(String srcFileStr, String destFileStr){//如果目标文件不存在，则创建def destFile = new File(destFileStr)if(!destFile.exists()){destFile.createNewFile()}//读取源文件def srcFile = new File(srcFileStr)def lines = srcFile.readLines()//写入目标文件destFile.write(lines.join("\n"))
}copyFile("d://json.txt", "d://json3.txt")//读取文件部分
def file3 = new File("d://json.txt")
file3.withReader { reader ->char[] buffer = new char[9]reader.read(buffer, 0, 9)println buffer
}

Groovy JSON操作

package com.zab.groovytestimport groovy.json.JsonOutput
import groovy.json.JsonSlurper//将json字符串转换为对象
def str = '{"name":"zhangsan", "age":18}'
def student = new JsonSlurper().parseText(str)
println student//将对象转换为json字符串
def stu = new Student("lisi", 20)
println JsonOutput.prettyPrint(JsonOutput.toJson(stu))

json转对象，对象转json还是挺常见一操作，用groovy操作，也是挺简单的

Gradle篇

安装挺简单，和groovy类似

Gradle新建项目

 

新建项目，需要配置一下gradle为本地安装的版本，随便指定一下Gradle user home为常用的maven本地仓库地址

 我这边建完项目就很简单

现在加点常用目录

 

看起来正常熟悉一些了，然后build.gradle其实就相当于maven管理项目时，项目中的pom.xml文件

新项目，在配置文件中加一点防止乱码的总有用的

//加一点防止乱码的配置
tasks.withType(JavaCompile) {options.encoding = "UTF-8"
}

Gradle 学习

现在进入正题

Gradle 生命周期

Gradle的生命周期分三个阶段: 初始化阶段、配置阶段、执行阶段。

• 初始化阶段

通过settings.gradle判断有哪些项目需要初始化，加载所有需要初始化的项目的build.gradle文件并为每个项目创建project对象

• 配置阶段

执行各项目下的build.gradle脚本，完成project 的配置，并且构造Task任务依赖关系图以便在执行阶段按照依赖关系执行Task中的配置代码

• 执行阶段

通过配置阶段的Task图，按顺序执行需要执行的任务中的动作代码，就是执行任务中写在doFirst或doLast中的代码。

Gradle Project

一个project代表一个正在构建的组件（jar或者war），构建时，gradle会基于这个配置文件（build.gradle）搞个实例对象出来（org.gradle.api.Project），并且通过对象的变量来隐式调用对象的方法或者字段。

Project有哪些属性呢？

我有点好奇，键盘按住ctrl，鼠标点了一下group

就，就打开了这个project类，跳转到setGroup方法了，这根据我浑厚的java功底，我知道这个group就可以为project赋值了啊！那么version我也搞懂了。

于是，我好像慢慢能看懂这个最开始有点我曹的文件了。于是我又点了一下，repositories，它那个跳啊

这语法就是说，我需要传一个参数给repositories呗，参数是一个闭包呗，闭包就是一个代码块呗 

只要是个闭包就也能点吧，我点点点。。。

这，，看起来就像要去https://repo.maven.apache.org/maven2/仓库拉代码呀（所以，gradle是没有自己的中央仓库，用的别人的，还妄图干掉maven，做人要摸自己左咪咪呀）

属性有哪些其实Project里面set方法能看出来一些，但是有些隐式的字段没找到定义在哪

名称	类型	默认值
project	Project	Project实例
name	String	项目目录的名称。
path	String	项目的绝对路径。
description	String	项目的描述。
projectDir	File	包含生成脚本的目录。
buildDir	File	projectDir/build
group	Object	未指定
version	Object	未指定
ant	AntBuilder	AntBuilder实例

我挑了一些，用刚刚学到的groovy hello world语法，打印一下，点构建工具的build，会执行println

Gradle Task

 gradle的task在构建执行过程中，会被封装成org.gradle.api.Task对象，主要包括任务的动作和任务依赖。

task初识

我现在定义一个task

task(t1, {//分个组group("myGroup")println "t1"//动作doLast {println "doLast"}doFirst {println "doFirst"}
})

可以看到，分组和task都在右侧有显示了，并且我双击了task，它也执行了

 task新建的几种方式

//定义方式1：
task(t1,{group("mytask")//配置代码println '我是任务1'//动作代码doFirst {println '在任务t1执行前操作的动作代码'}//动作代码doLast {println '在任务t1执行后操作的动作代码'}
})
//定义方式2：
task t2 {group("mytask")//配置代码println '我是任务2'//动作代码doFirst {println '在任务t2执行前操作的动作代码'}//动作代码doLast {println '在任务t2执行后操作的动作代码'}
}//定义方式3：
tasks.create('t3'){group("mytask")//配置代码println '我是任务3'
}//定义方式4：
tasks.register('t4'){group("mytask")//配置代码println '我是任务4'
}//定义方式5：
tasks{task t5{group("mytask")//配置代码println '我是任务5'}
}//定义方式6
3.times{index ->task("task${index}"){group("mytask")//配置代码println 'task${index}'}
}

定义方式5有几个特点： 

• 在build阶段的配置过程中不执行
• 在任务的执行阶段的配置过程中是执行的
• 配置代码的执行时机是落后于用task方式配置的

task 依赖

//任务依赖，a任务是被别的任务依赖的
task a{doFirst {println '我是任务a'}
}
//表示b任务依赖a任务，a任务放入参数传递
task b(dependsOn:a){doFirst {println '我是任务b'}
}
//表示c任务依赖a任务，依赖方式在任务内部进行依赖
task c{dependsOn 'b'  doFirst {println '我是任务c'}
}task d{doFirst {println '我是任务d'}
}//d任务外部依赖c，这种方式也可以
d.dependsOn c   

Gradle 自定义jar

接下来的实例在工作中很可能用得上了，我们要实现项目A打个jar，在项目B中使用

• 搞个新gradle项目，我这里命名为gradle-plugin

细节略，前面有

• 配置插件

核心配置如下

plugins {id 'java-library'id 'maven-publish'
}
publishing {publications {mavenJava(MavenPublication) {from components.java}}repositories{mavenLocal()}
}

然后我们刷新项目，就可以看到有一个task：publishing

• 发布需要被引用的jar

我们双击一下publishToMavenLocal，由于我的配置是配置了本地maven仓库的，而不是走的默认gradle仓库地址，所以我在以下目录能看到打包好的jar

 项目没啥内容，就是定义了一个类Student，主要为了演示jar在别的项目中能引用

package com.zab.gradleplugin;public class Student {private String name;private String age;public Student(String name, String age) {this.name = name;this.age = age;}public String getName() {return this.name;}public String getAge() {return this.age;}public void setName(String name) {this.name = name;}public void setAge(String age) {this.age = age;}
}

• 其他项目引用

核心配置如下

repositories {mavenLocal()mavenCentral()
}
dependencies {testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'implementation(group: 'org.zab', name: 'gradle-plugin', version: '1.0-SNAPSHOT')
}

主要是    mavenLocal()  和   implementation(group: 'org.zab', name: 'gradle-plugin', version: '1.0-SNAPSHOT')

现在开始使用

package com.zab.test;import com.zab.gradleplugin.Student;public class Test {public static void main(String[] args) {Student student = new Student("zhangsan", "18");System.out.println(student.getName());}
}

Gradle 插件

我们用脚本自定义插件，需要在build.gradle里面编写

class MyPlugin implements Plugin<Project> {@Overridevoid apply(Project project) {project.task('myPluginTask') {doLast {println 'myPluginTask'}}}
}apply plugin: MyPlugin

然后刷一把，可以看到插件成功创建

我们也可以自己在其他目录写，这样都可以用

注意是创建目录，按照以下目录结构创建目录

build.gradle放到src下，编写如下内容：

apply plugin:'groovy'

我们在编写一个新的可以公用的插件

import org.gradle.api.Plugin;
import org.gradle.api.Project;class MyFirstPlugin implements Plugin<Project>{@Overridepublic void apply(Project project){project.task("MyFirstPlugin").doLast(task -> {System.out.println("hello MyFirstPlugin");});}
}

 然后在项目中引用一下

apply plugin: MyFirstPlugin

就可以使用了，如下图，刷新一下项目，就可以看到新插件

 Gradle 版本冲突解决

在maven管理的项目中，有两个比较重要的解决依赖冲突的原则

• 第一原则:最短路径优先原则

最短路径优先就是说项目依赖关系树中路径最短的版本会被使用。
假设A、B、C三个项目之间的依赖关系是A->B->C->D(2.0)和A->C->(D1.0)，那么D(1.0)会被使用，因为A通过C到D的路径更短

• 第二原则:最先声明原则

依赖路径长度是一样的的时候，第一原则不能解决所有问题。比如这样的依赖关系:A-B-D(1.0)，A-C-D(2.0)，D(1.0)和D (2.0)的依赖路径长度是一样的都为2，那么到底谁会被解析使用呢?

在maven 20.8及之前的版本中，这是不确定的，但是maven20.9开始，为了尽可能避免构建的不确定性，maven定义了依赖调解的第二原则:第一声明者优先。在依赖路径长度相等的前提下，在中依赖声明的顺序决定了谁会被解析使用。

gradle项目中，有一个自动解决方案，即使版本高的优先选用

做个简单实验，我们知道spring-web-mvc是依赖了spring-aop的，这样一个高低版本组合，再看看具体依赖就知道依赖的哪个版本了

    implementation(group: 'org.springframework', name: 'spring-aop', version: '5.1.3.RELEASE')implementation(group: 'org.springframework', name: 'spring-webmvc', version: '5.1.13.RELEASE')

现在我们排除掉spring-aop依赖

    implementation(group: 'org.springframework', name: 'spring-webmvc', version: '5.1.13.RELEASE', {exclude group: 'org.springframework', module: 'spring-aop'})

 可以看到，用上了老版本了

还有一些比较常用的配置，比如所有jar不做自动冲突解决

configurations.all{resolutionStrategy{failOnVersionConflict()}
}

强制覆盖某个版本

configurations.all(resolutionStrategy{force 'org.springframework:spring-beans:5.3.12}
}

Gradle 多模块构建

• 先创建两个模块

•  gradle项目下的配置文件修改配置文件

//多模块配置 1
allprojects {apply plugin: 'java'project.group = 'com.zab'version = '1.0-SNAPSHOT'
}
//多模块配置 2
subprojects {repositories {mavenLocal()mavenCentral()}dependencies {testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'implementation(group: 'org.zab', name: 'gradle-plugin', version: '1.0-SNAPSHOT')implementation(group: 'org.springframework', name: 'spring-aop', version: '5.1.3.RELEASE')implementation(group: 'org.springframework', name: 'spring-webmvc', version: '5.1.13.RELEASE', {exclude group: 'org.springframework', module: 'spring-aop'})}
}

主要是把插件、project.group、version 等字段移到了allprojects ，依赖和仓库配置移到了subprojects 

• 模块之间的依赖

例如：subproject1依赖subproject02

dependencies {implementation project(':subproject02')
}

这就可以啦，然后刷一把依赖

好了，到这里基本上遇到公司用gradle构建的项目我就没那么慌了 ~~ 我又开始了愉快的增删改查，吼吼