文章目录

• Gradle
• • Gradle项目管理工具
  • Gradle安装（Windows）
  • • 1.下载解压版
    • 2.配置环境变量
    • 3.配置init.gradle
    • 4.验证是否配置成功
  • Gradle工程目录
  • Gradle在idea中使用
  • groovy编程语言
  • • 输出
    • 断言 assert
    • 定义变量
    • 闭包（无参数）
    • 闭包（有参数）
    • 总结
  • gradle构建脚本介绍
  • Gradle管理jar包
  • • build.gradle文件的基本内容
    • 配置使用的仓库repositories
    • • 使用maven本地仓库
      • 使用远程仓库
    • 其它可用的远程仓库地址
    • 关于gradle中jar包引用的说明
    • gradle中jar包的依赖配置
    • • jar包依赖方式
      • jar包的依赖范围（作用域）
      • jar包依赖版本冲突默认解决方式
      • 修改jar包依赖的配置策略
      • 依赖的排除
  • 任务（Task）的编写
  • Gradle项目构建生命周期
  • Gradle创建多模块项目
  • 参考

Gradle

Gradle项目管理工具

基于Groovy的特定领域语言来声明项目设置

Gradle安装（Windows）

1.下载解压版

• 版本列表：Gradle Distributions

• v6.5：https://downloads.gradle-dn.com/distributions/gradle-6.5-bin.zip（用迅雷下载可能会快些）

2.配置环境变量

1. gradle_home
   • 变量名：GRADLE_HOME
   • 变量值：D:\work\gradle-6.5（gradle安装目录）
2. path（编辑）
   • 变量名：Path（编辑）
   • 变量值：%GRADLE_HOME%\bin（增加）
3. gradle_user_home（在远程仓库下载的jar包保存到该路径下）
   • 变量名：GRADLE_USER_HOME
   • 变量值：D:\work\gradleCK

3.配置init.gradle

	`allprojects {
	repositories {
	mavenLocal()
	maven { name "Alibaba" ; url "https://maven.aliyun.com/repository/public" }
	}
	buildscript {
	repositories {
	maven { name "Alibaba" ; url 'https://maven.aliyun.com/repository/public' }
	}
	}
	}`

• 在gradle安装目录\init.d目录下，创建init.gradle文件，初始化基本配置：配置远程仓库地址（gradle没有自己的仓库，使用的是maven的仓库）

4.验证是否配置成功

cmd输入命令：gradle -v

Gradle工程目录

	`gradle-demo
	|---src
	|---|---main
	|---|---|---java（放置正式代码目录）
	|---|---|---resources（放置正式配置文件目录）
	|---|---|---webapp（放置页面元素）
	|---|---test
	|---|---|---java（放置单元测试代码目录）
	|---|---|---resources（放置测试配置文件目录）
	|---build.gradle
	|---settings.gradle`

Gradle在idea中使用

1. 创建gradle项目
2. 创建完成后更改gradle配置（Settings），选择自己安装的gradle
3. groovy语言编辑器，Tools - Groovy Console

groovy编程语言

输出

	`//介绍groovy编程语言
	println("hello groovy"); // idea快捷键sout
	println("hello groovy") // 可以省略最后的分号
	println "hello groovy" // 可以省略括号
	println 12 + ":" + 24`

断言 assert

	`age = 18
	assert age == 19`
	* 1
	* 2

定义变量

	`// groovy 中定义变量
	// def 是弱类型，groovy会自动根据情况来给变量赋予对应的类型
	def i = 18;
	println i;
	// 字符串定义
	str1 = 'xiaoming' // 定义普通字符串
	str2 = "name:${str1}" //可以引用变量
	str3 = '''name:xiaoming
	age:18''' //按格式定义字符串
	println str1
	println str2
	println str3
	// 定义一个集合类型
	def list = ['a','b']
	// 往list中添加元素
	list.add("xiaoming")
	list << 'c'
	// 取出list中第3个元素
	println list.get(2)
	// 定义一个map
	def map = ['key1':'value1','key2':'value2']
	// 向map中添加键值对
	map.key3 = 'value3'
	// 打印出key3的值
	println map.get('key3')` 

闭包（无参数）

	`// groovy 中的闭包
	// 什么是闭包？闭包其实就是一段代码块。在gradle中，我们主要是把闭包当参数来使用
	// 闭包省略()
	//plugins({
	// id('java')
	//})
	//相当于
	//plugins {
	// id 'java'
	//}
	// 定义一个闭包
	def b1 = {
	println "hello b1"
	}
	// 定义一个方法，方法里面需要闭包类型的参数
	def method1(Closure closure) {
	//closure()
	closure.call()
	}
	// 调用方法method1
	method1(b1)
	method1 b1
	method1({
	println "xiaoming"
	})
	method1 {
	println "xiaoming"
	}` 

闭包（有参数）

	`//定义一个闭包，带参数
	def b2 = {
	v ->
	println "hello ${v}"
	}
	// 定义一个方法，方法里面需要闭包类型的参数
	def method2(Closure closure){
	//closure("xiaoma")
	closure.call("xiaoma")
	}
	// 调用方法method2
	method2 b2
	method2 {
	v ->
	println "hello ${v}"
	}` 

总结

1. idea中，使用groovy语言编辑器，Tools - Groovy Console
2. 方法调用，省略分号，小括号
3. 定义字符串，单引号定义普通字符串，双引号可以引用变量，三引号按格式定义字符串

gradle构建脚本介绍

gradle构建脚本介绍（build.gradle）
两个重要的概念 project 和 task
任何一个Gradle构建都由一个或多个project组成，每个project包括许多的构建部分
每个project由一个或多个Task组成，每个Task表示在构建执行过程中的一个原子操作
构建Project完成后会生成一个jar或者war文件，构建过程中Gradle基于build.gradle实例化一个org.gradle.api.Project对象，并通过project变量来隐式的调用其成员变量
Project对象属性：project（隐式使用）、group、name、version、path、description、projectDir、buildDir、ant
其它常用配置：plugins（apply plugin）、dependencies、repositories、task、ext（gradle.properties 属性配置）

Gradle管理jar包

build.gradle文件的基本内容

	`plugins {
	id 'java'
	// web工程需要的插件
	id 'war'
	}
	version '1.0-SNAPSHOT'
	group 'xin.yangshuai'
	sourceCompatibility = 1.8
	/*
	* 指定所使用的仓库
	*/
	repositories {
	// Gradle没有自己的中央仓库
	// 先从本地maven仓库寻找依赖的jar包，存在则直接使用本地maven仓库的jar
	mavenLocal()
	// 本地maven仓库没有则从远程仓库下载jar包，并保存到 环境变量GRADLE_USER_HOME 配置的路径下
	// 设置maven仓库阿里镜像地址
	maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
	// 配置使用Maven的中央仓库
	mavenCentral()
	}
	/**
	* 配置依赖的jar包
	*/
	dependencies {
	testCompile group: 'junit', name: 'junit', version: '4.12'
	/* web工程需要的jar包 */
	compile group: 'org.springframework', name: 'spring-context', version: '5.0.2.RELEASE'
	compile group: 'org.springframework', name: 'spring-web', version: '5.0.2.RELEASE'
	compile group: 'org.springframework', name: 'spring-webmvc', version: '5.0.2.RELEASE'
	providedCompile group: 'javax.servlet', name: 'javax.servlet-api', version: '3.0.1'
	providedCompile group: 'javax.servlet', name: 'jsp-api', version: '2.0'
	}` 

配置使用的仓库repositories

使用maven本地仓库

1. 修改build.gradle文件，配置maven本地仓库mavenLocal()

	`repositories {
	mavenLocal()
	}`

1. 使用maven本地仓库，需要告知gradle本地maven仓库的地址，配置M2_HOME环境变量，M2_HOME/conf/settings.xml中指定我们本地仓库的位置
   • 变量名：M2_HOME
   • 变量值：D:\work\apache-maven-3.6.3（maven安装路径）

当我们使用maven本地仓库（mavenLocal()）时，jar包会直接利用本地maven仓库，而不会去下载

参考：gradle的依赖包的存储位置_gradle依赖目录-CSDN博客

注意： gradle寻找本地maven仓库位置的策略

USER_HOME/.m2/settings.xml >> M2_HOME/conf/settings.xml >> USER_HOME/.m2/repository

1、我们一般在maven的安装目录/conf/settings.xml（也就是我们配置的maven环境变量）中配置本地仓库位置，所以我们需要让gradle选择该路径，从而使用我们配置的maven本地仓库

2、gradle先寻找USER_HOME/.m2/settings.xml，所以我们要删掉该文件（其实也可以将安装目录下的settings.xml复制过来）

3、maven环境变量我们习惯配置成MAVEN_HOME，但是gradle寻找的是M2_HOME，所以我们需要配置M2_HOME环境变量

参考：Gradle使用mavenLocal()以及自定义jar包缓存路径-CSDN博客

验证： 切换使用mavenCentral()和mavenLocal()，查看jar包引用地址

使用远程仓库

1. 修改build.gradle文件，配置maven中央仓库

	`repositories {
	mavenCentral()
	}`

1. 当需要在远程仓库下载jar包时，会将jar包保存到GRADLE_USER_HOME\caches\modules-2\files-2.1\文件夹下，配置 GRADLE_USER_HOME 环境变量，也可以直接在idea中指定位置

   • 变量名：GRADLE_USER_HOME

   • 变量值：D:\work\gradleCK

其它可用的远程仓库地址

	`repositories {
	mavenLocal()
	// 阿里
	maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
	mavenCentral()
	}`

关于gradle中jar包引用的说明

如果我们在repositories{}中先配置mavenLocal()（maven本地仓库），再配置mavenCentral()（远程仓库），那么gradle引用jar的位置就会出现两个，如果本地maven仓库中存在则直接引用本地maven仓库中的jar包，如果本地maven仓库中不存在，则会连接远程仓库地址，将jar包下载到gradle本地缓存地址，并且引用该地址下的jar包。

注意： gradle并不会向本地maven仓库中下载jar包，gradle缓存路径下的jar包与maven本地仓库中的jar包的格式也有区别。

参考：gradle能否将下载的jar存储到maven本地仓库而不是缓存目录_gradle如何让下载的依赖放入固定位置而不是缓存-CSDN博客

验证： 查看项目中不同jar包的引用地址（maven仓库中存在的jar包和不存在的jar包，观看其引用的地址）

gradle中jar包的依赖配置

jar包依赖方式

	`/**
	* 配置依赖的jar包
	* gradle工程所有的jar包的坐标都在dependencies属性内放置
	* 每一个jar包的坐标都有三个基本元素组成 group，name,version
	* 添加坐标的时候都要带上jar包的作用域
	*/
	dependencies {
	testCompile group: 'junit', name: 'junit', version: '4.12'
	}`

jar包的依赖范围（作用域）

jar包的依赖范围（作用域）：
compile：编译阶段：主程序、测试程序均有效；运行阶段：均有效
providedCompile：编译阶段：主程序、测试程序均有效；运行阶段：均无效（依靠运行时环境提供的jar包）
runtime：编译阶段：主程序、测试程序均无效（无需依赖）；运行阶段：均有效
testCompile：编译阶段：主程序无效，测试程序有效；运行阶段：均有效
testRuntime：编译阶段：主程序、测试程序均无效（无需依赖）；运行阶段：测试程序有效

jar包依赖版本冲突默认解决方式

jar包依赖具有传递性
依赖jar包版本存在冲突解决方案：
maven：最短路径原则，先声明原则
gradle：选择最高版本

修改jar包依赖的配置策略

	`configurations.all {
	resolutionStrategy {
	// 配置后将不自动处理jar包版本冲突，可以与依赖的排除配合使用
	failOnVersionConflict()
	// 强制使用某个版本的jar包，覆盖依照gradle默认策略引用的jar包
	force 'org.slf4j:slf4j-api:1.7.24'
	}
	}`

• 直接在build.gradle中配置configurations.all{}

依赖的排除

	`dependencies {
	compile(group: 'org.hibernate', name: 'hibernate-core', version: '3.6.3.Final') {
	// 排除某个依赖，其中 module 相当于 jar包坐标中的 name
	exclude(group: 'org.slf4j', module: 'slf4j-api')
	}
	}`
	* 1
	* 2
	* 3
	* 4
	* 5
	* 6

任务（Task）的编写

	`// 任务（task）的主要操作动作
	// dependsOn：依赖相关操作，定义任务时参数依赖、任务内部依赖、外部添加依赖
	// doFirst：任务执行之前执行的方法
	// doLast（<<（旧功能，不提倡））：任务执行之后执行的
	task t1 {
	doFirst {
	println 't1 do first'
	}
	println 'hello t1'
	doLast {
	println 't1 do last'
	}
	}
	// 参数依赖
	task t2(dependsOn: 't1') {
	// t2执行前操作
	doFirst {
	println 't2 do first'
	}
	println 'hello t2'
	// t2 执行后操作
	doLast {
	println 't2 do last'
	}
	}
	// 结论：在构建Project时，只执行直接定义在task下（非doFirst和doLast闭包中）的代码，有依赖也不会再次执行依赖的task
	// 直接调用task时，只执行在doFirst或doLast闭包中的代码，并且会优先执行依赖的task的doFirst或doLast闭包中的代码
	task t3 {
	// 任务内部依赖
	dependsOn 't1'
	println 'hello t3'
	doLast {
	println 't3 do last'
	}
	}
	task t4 {
	doFirst {
	println 't4 do first'
	}
	println 'hello t4'
	}
	// 外部添加依赖
	t4.dependsOn 't1'
	//动态任务
	4.times {
	val ->
	task "task${val}" {
	doFirst {
	println "The task is task${val}"
	}
	println "hello task${val}"
	}
	}
	task t5 {
	// 给任务添加自定义属性
	ext.myProperty = 'The property value'
	doFirst {
	println "t5 ${myProperty}"
	}
	println 'hello t5'
	}` 

Gradle项目构建生命周期

Gradle项目构建生命周期
初始化阶段：通过settings.gradle判断哪些项目需要初始化，加载所有需要初始化的项目的build.gradle文件并为每个项目创建project对象
配置阶段：执行各项目下的build.gradle脚本，完成project的配置，并且构造task任务关系图以便在执行阶段按照依赖关系执行task中的配置代码（直接定义在task下的代码，配置阶段就需要执行）
执行阶段：通过配置阶段的task图，按顺序执行需要执行的任务中的动作代码（任务调用才会执行的代码，定义在doFirst或doLast中的代码）

Gradle项目构建过程中的钩子方法（我们可以直接覆写这些方法，在方法中加入我们自己的逻辑）（写在build.gradle或者settings.gradle中）

	`// 项目构建之前
	gradle.settingsEvaluated {
	println "初始化阶段0 settingsEvaluated"
	}
	gradle.projectsLoaded {
	println "初始化阶段1 projectsLoaded"
	}
	// 配置阶段
	gradle.beforeProject {
	println "配置阶段0 beforeProject"
	}
	gradle.afterProject {
	println "配置阶段1 afterProject"
	}
	gradle.projectsEvaluated {
	println "配置阶段2 projectsEvaluated"
	}
	gradle.taskGraph.whenReady {
	println "配置阶段3 taskGraph.whenReady"
	}
	// 执行阶段
	gradle.taskGraph.beforeTask {
	println "执行阶段0 taskGraph.beforeTask"
	}
	gradle.taskGraph.afterTask {
	println "执行阶段1 taskGraph.afterTask"
	}
	gradle.buildFinished {
	println "执行阶段2 buildFinished"
	}` 

Gradle创建多模块项目

1. 父模块有settings.gradle文件，子模块没有，settings中配置所拥有的子模块

	`rootProject.name = 'gradle-demo-comment'
	include 'model'
	include 'core'
	include 'web'
	include 'admin'`

1. 父模块build.gradle中配置公用的信息，插件、依赖等

	`// 配置统一信息，包括root模块
	allprojects {
	// 统一引入 java 插件，并指定版本（注：不能将plugins {id 'java'} 直接挪到 allprojects 里面，变换一下形式）
	apply plugin: 'java'
	sourceCompatibility = 1.8
	// 统一配置公共属性，例如：group、version
	group 'xin.yangshuai'
	version '1.0-SNAPSHOT'
	}
	// 子模块配置统一信息
	subprojects {
	// 配置公用的资源库
	repositories {
	mavenCentral()
	}
	// 配置公用的依赖
	dependencies {
	compile 'ch.qos.logback:logback-classic:1.2.2'
	}
	}
	dependencies {
	}` 

1. 子模块build.gradle中配置特有的信息

	`apply plugin: 'war'
	//如果使用plugins引用插件，则buildscript必须放到plugins前面
	buildscript {
	repositories {
	maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
	jcenter()
	}
	dependencies {
	classpath 'com.bmuschko:gradle-tomcat-plugin:2.5'
	}
	}
	dependencies {
	compile project(':core')
	// providedCompile：只在编译时依赖，运行环境下不需要
	providedCompile 'javax.servlet:javax.servlet-api:3.1.0'
	}` 

参考

黑马程序员精品教程|Java进阶教程之Gradle入门到精通_哔哩哔哩_bilibili

【叩丁狼】Gradle系统详解_哔哩哔哩_bilibili