Gradle：Gradle的具体介绍与使用

Posted 2022-01-14 ABin-阿斌

我是 ABin-阿斌：写一生代码，创一世佳话，筑一览芳华。 如果小伙伴们觉得我的文章有点 feel ，那就点个赞再走哦。

文章目录

• • 一、简介
  • • 1. 开发的早期构建演变历程
    • • 1.1 从依赖管理分析：
      • 1.2 从测试角度分析：
      • 1.3 新生的萌芽：
    • 2. 构建工具带来的便利
    • • 2.1 从依赖管理分析：
      • 2.2 自动化管理：
      • 2.3 自动化的好处：
    • 3. 主流的构建工具
    • • 3.1 Ant（Apache Ant）
      • • 3.1.1 不足之处：
      • 3.2 Maven
      • • 3.2.1 不足之处：
      • 3.3 Gradle
      • • 3.3.1 什么是Gradle
        • 3.3.2 什么是Groovy
        • 3.3.3 Groovy语言与Java相比有何不同或优势
        • • 优势：
        • 3.3.4 Groovy的高级特性
  • 二、Gradle的安装
  • • 1、Gradle的安装
  • 三、创建使用Gradle来管理的项目
  • • • 1、 创建步骤如下：
      • 2、项目目录结构介绍
  • 四、Gradle相关理论疏导
  • • 1、gradle配置文件介绍
    • 2、Gradle构建脚本理论
    • 3、编写任务测试
    • 4、自定义任务
    • • 4.1、定义任务的基本语法
      • 4.2、任务的常见定义方式
    • 5、任务的依赖配置：dependsOn
    • 6、动态任务(了解)
    • 7、给任务自定义属性
  • 五、Gradle生命周期与钩子方法
  • • 生命周期的概念
  • 六、依赖管理
  • • 关键点：
    • 依赖阶段配置：
  • 七、版本冲突问题
  • • Gradle解决冲突的方案
  • 八、多项目构建
  • 未完待续....

一、简介

1. 开发的早期构建演变历程

1.1 从依赖管理分析：

• 从项目的构建历史上追溯，我们可以看到在最开始的时候，我们如果想要去依赖我们的一个第三方 jar 包，我们就需要把 jar 放到lib目录中。
• 一旦我们的 jar 变多了之后很难管理，而且还特别容易出现版本冲突问题。每个项目需要使用到同一个 jar 包都需要我们拷贝一份到新的项目中去，这样极大地阻碍了我们的开发效率，同时也非常的占用我们磁盘的存储空间。

1.2 从测试角度分析：

• 在我们开发人员开发前，往往我们需要去做一些功能点的测试（Mock）。这个过程我们往往需要书写大量的测试类，这样一步一步的操作其实是非常耗时的一个举措。
• 当我们早期时，开发完一期功能我们会通过 Eclipse 打包，然后上传到我们的服务器上或者放入我们说依赖的项目中，这个操作也是非常的麻烦且繁琐。

1.3 新生的萌芽：

• 以上这几个例子我们可以看出，这些琐碎的操作都是比较平凡且耗时的，但是这些琐碎的操作在我们开发中往往是缺一不可的。那么我们有没有一种更好的方法去将这些操作简单化或一体化呢？于是，我们就演变出了：构建工具。

2. 构建工具带来的便利

2.1 从依赖管理分析：

• 有了构建工具，我们可以很方便的将我们的依赖进行统一的管理，使得我们操作起来更加的方便，同时我们只需要依赖管理就可以，再不用进行拷贝 jar 包到项目中的操作了。

2.2 自动化管理：

• 有了一体自动化管理，我们仅仅需要关心一步的操作即可，其余的琐碎操作均由程序去执行帮我们进行测试、打包、发布。

2.3 自动化的好处：

• 大大提高了我们的整体的开发效率

3. 主流的构建工具

3.1 Ant（Apache Ant）

• Apache Ant 是一个基于 Java 的生成工具，据最初的创始人 James Duncan Davidson 的介绍，这个工具的名称是 another neat tool(另一个整洁的工具)的首字母的缩写。

• ant 的思想和 makefile 比较像。定义一个任务，规定它的依赖，然后就可以通过 ant 来执行这个任务了。

• 举例： 我们通过例子看一下。下面列出一个 ant 工具所使用的 build.xml

  • <?xml version="1.0" encoding="UTF-8" ?>  
    <project name="HelloWorld" default="run" basedir=".">  
    <property name="src" value="src"/>  
    <property name="dest" value="classes"/>  
    <property name="jarfile" value="hello.jar"/>  
    <target name="init">  
       <mkdir dir="$dest"/>  
    </target>  
    <target name="compile" depends="init">  
       <javac srcdir="$src" destdir="$dest"/>  
    </target>  
    <target name="build" depends="compile">  
       <jar jarfile="$jarfile" basedir="$dest"/>  
    </target>  
    <target name="test" depends="build">  
       <java classname="test.ant.HelloWorld" classpath="$hello_jar"/>  
    </target>  
    <target name="clean">  
       <delete dir="$dest" />  
       <delete file="$hello_jar" />  
    </target>  
    </project>  
    

• 可以看到 ant 的构建脚本还是比较清楚的，ant 定义了五个任务，init, compile, build, test, clean。每个任务做什么都定义清楚了。打包之前要先编译，所以通过 depends 来指定依赖的路径。

• 如果在命令行里执行 ant build，那就会先执行 compile，而 compile 又依赖于 init，所以就会先执行 init。看起来很合理，对吧？

• 有了这个东西以后，我们只要一条命令：ant test，就可以执行编程，打包，测试了。为开发者带来了很大的便利。

3.1.1 不足之处：

• ant 有一个很致命的缺陷，那就是没办法管理依赖。我们一个工程，要使用很多第三方工具，不同的工具，不同的版本。每次打包都要自己手动去把正确的版本拷到 lib下面去，不用说，这个工作既枯燥还特别容易出错。为了解决这个问题，maven 闪亮登场。

3.2 Maven

• 对于我们 Java 开发人员来说 Maven 一定是再熟悉不过的了，Maven 最核心的改进就在于提出——【仓库】，这个概念。

• 我可以把所有依赖的包，都放到仓库里去，在我的工程管理文件里，标明我需要什么什么包，什么什么版本。在构建的时候，Maven 就自动帮我把这些包打到我的包里来了。我们再也不用操心着自己去管理几十上百个 jar 文件了。

• 达到这个目标，maven 提出，要给每个包都标上坐标，这样，便于在仓库里进行查找。所以，使用 maven 构建和发布的包都会按照这个约定定义自己的坐标。

• 举例：

  • <?xml version="1.0" encoding="utf-8"?>
    <project ...xmlns...>
        <groupId>cn.hinus.recruit</groupId>
        <artifactId>Example</artifactId>
        <version>0.1.0-SNAPSHOT</version>
    		 
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.10</version>
            </dependency>
        </dependencies>
    </project>
    

  • 这样，我就定义了我自己的包的坐标是 cn.hinus.recruit:Example:0.1.0-SNAPSHOT，而我的工程要依赖 junit:junit:4.10

  • 那么 maven 就会自动去帮我把 junit 打包进来。如果我本地没有 junit，maven 还会帮我去网上下载。下载的地方就是远程仓库，我们可以通过 repository 标签来指定远程仓库。

• maven 里抛弃了 ant 中通过 targe t定义任务的做法，而是引入了——【生命周期】的概念。

3.2.1 不足之处：

• maven 已经很好了，可以满足绝大多数工程的构建。那为什么我们还需要新的构建工具呢？
• 第一：maven 是使用 xml 进行配置的，语法不简洁。
• 第二：最关键的，maven 在约定优于配置这条路上走太远了。就是说，maven 不鼓励你自己定义任务，它要求用户在 maven 的生命周期中使用插件的方式去工作。这有点像设计模式中的模板方法模式，说通俗一点，就是我使用 maven 的话，想灵活地定义自己的任务是不行的。基于这个原因，又出了一款新的构建工具，那就是——Gradle，Gradle在这一方面做了很多改进。

3.3 Gradle

• Gradle 并不是另起炉灶，它充分地使用了 maven 的现有资源。继承了 maven 中仓库，坐标，依赖这些核心概念。文件的布局也和 maven 相同。但同时，它又继承了 Ant 中 target 的概念。在 gradle 中我们可以以任务的方法来执行我们的代码，我们又可以重新定义自己的任务了。

3.3.1 什么是Gradle

• 一个开源的项目自动化构建工具，建立在 Apache Ant 和 Apache Maven 概念的基础上，并引入了基于 Groovy 的特定领域语言 (DsL)。使用 Groovy 语言构建脚本，不再像 Maven 一样使用 XML 而不再使用 XML 形式管理构建脚本。
• DsL (Domain Specific Language）定义：针对某一领域，具有受限表达性的一种计算机程序设计语言。只针对一个领域做出来的简洁语言,而非为了通用而设计。

3.3.2 什么是Groovy

• Groovy 是基于 Java 虚拟机的一种敏捷的动态语言，它是一种成熟的 OOP (面向对象) 编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。使用该种语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。

3.3.3 Groovy语言与Java相比有何不同或优势

优势：

• Groovy 完全兼容 Java 语法，可做脚本也可做类

• 分号是可选的，一般不加分号，以换行作为结束

• 类，方法字段都是公共的，没有访问权限限制

• 默认生成具名(名值对)参数构造器 key:value

• 字段不定义访问权限时，编译器自动给字段添加 getter/setter方法

• 字段可使用点来获取，无访问权限的也可使用 getter/setter 来操作

• 方法可省略 return 关键字，自动检索最后一行的结果作为返回值

• 空值比较不会有 NullPointerException 异常抛出

3.3.4 Groovy的高级特性

• assert断言：可以用 assert 代替之前 Java 的断言语句
• 可选类型：可使用类 javascript 的弱类型，可使用 def 来表示任意类型
• 方法调用：调用带参方法时可省略括号
• 字符串定义：字符串定义有三种方式，单引号，双引号，三个单引号
• 集合API：集合的定义和使用更加简单 API 和 Java 有所不同，但兼容 Java API
• 闭包：Groovy 的一大特性，跟方法类似的代码块，可赋给一个变量也可以做为参数传递给一个方法,像普通方法一样调用

二、Gradle的安装

1、Gradle的安装

• Gradle的安装与环境配置教学

三、创建使用Gradle来管理的项目

1、 创建步骤如下：

1. file-----》new project ------》Gradle --------》勾选 Java

2. 输入： Groupld : xxx.xxx.gradle

   • Artifactld: gradleJava
   • Version : 1.O-SNAPSHO

3. Use local graedle distribution 选择 Gradle home

4. 创建类 App：

   • 在 src/main/java 下创建包 xx.xxx 创建 App 类

5. 打包：

   • 点击左右 Gradle------》 gradleJava -------》 Tasks-------》 build------》 jar
   • 生成 jar位置：build/libs/gradleJave-1.O-SNAPSHOT.jar

6. 执行jar：

   • 左下 Terminal，java -classpath build\\libs\\gradleJave-1.O-SNAPSHOT.jar， xxx.xxx.App

2、项目目录结构介绍

• src/main/java：主要放置正式的代码
• src/main/resouces：主要放置配置文件
• src/test/java：主要放置单元测试代码
• src/test/resources：主要放置测试配置文件
• src/main/webapp：主要放置前端页面的一些元素，比如：js，css，img，jsp，html等等

四、Gradle相关理论疏导

1、gradle配置文件介绍

• build.gradle，这个文件类似于我们 Maven 中的 pom.xml 文件

/**
 * 表示我们当前的运行环境，我这里是java开发，所以显示的java
 */
plugins  id 'java' 

group 'com.mangobin'
version '1.0-SNAPSHOT'

/**
 * 使用的JDK版本号，我这里用的是 JDK_open11
 */
sourceCompatibility = 11

/**
 * 指定我们所使用的一个仓库，mavenCentral()：表示使用磨人的中央厂库，当我们使用jar时，它会默认去中央厂库下载
 */
repositories 
    //这里我给他配置了一个阿里云的，放在首位表示优先从阿里云去找，如果阿里没有再到中央仓库去找
    maven  url "http://maven.aliyun.com/nexus/content/groups/public/" 
    mavenCentral()


/**
 * 该属性中放置了 gradle工程所有的jar包坐标，每个jar包坐标都有三个基本元素组成：group name version
 * testCompile：表示jar包在测试时候生效，该属性作为jar包的作用域
 * 当我们在gradle里面添加新的jar时，我们都需要带上jar的作用域
 */
dependencies 
    testCompile group: 'junit', name: 'junit', version: '4.12'
    implementation group: 'org.springframework', name: 'spring-context', version: '5.3.6'

2、Gradle构建脚本理论

• 

3、编写任务测试

• 在 build.gradle 文件中编写代码即可

//测试如何编写任务
task t1 
    println("t1")


task t2(dependsOn: "t1") 
    //t2 执行前的操作
    doFirst 
        println("t2,First")
    
    println("t2")
    //t2 执行之后的操作
    doLast 
        println("t2,second")
    

• 操作步骤：

• 执行结果：
  
  
  

• 结论：直接定义在任务下的代码会在配置 project 时执行，其他时候不执行就算依赖也不执行。只有在 doFirst 或 doLast 中配置的操作才会在调用任务或者依赖执行时调用。所以以后自定义任务执行代码需要写在 doFirst 或 doLast 中，除非先在构建 Project 时就执行。

4、自定义任务

• 任务是Gradle构建中的两个基本概念之一，而任务的定义和使用有多重形式

4.1、定义任务的基本语法

• 注意事项： 下方代码只会在构建 Project 时执行，gradle build，其他方式不执行。如果需要在任务调用时执行动作代码，需要将代码定义到 doFirst 或 doLast 中

task t1
    println "直接带闭包的方式"


task t2()
    println "带括号的定义方式"

4.2、任务的常见定义方式

//
task t1 
    //任务调用前执行
     doFirst 
        println 't1'
    

task t2 
    //任务调用后执行
     doFirst 
        println 't2'
    

//doFirst的简写，任务调用后执行。实际开发中这种简写方式用的比较少
task t3<<
    println 't3'

5、任务的依赖配置：dependsOn

• 定义任务时参数依赖：(dependsOn:‘taskName’)
• 任务内部依赖：dependsOn ‘taskName’
• 外部添加依赖： taskName1.dependsOn taskName2

一//任务的依赖配置dependsOn
//内部设置依赖
task t1 
	doFirst 
        println ' he11o t1'
    

//方法参数设置依赖
task t2(depends0n:t1)
    doLast 
		println ' he11o t2'
    

//内部设置依赖
task t3 
	dependson 't1'
	doFirst 
		println ' he11o t3'
    

task t4
	doFirst 
		print1n ' he11o t4'
	

//外部设置依赖
t4.dependson t1

6、动态任务(了解)

times  val->
task "tk$val" <<
printIn "The task is task$fval"
	

7、给任务自定义属性

• ext.myProperty = "The property value"

• 相当于我们 Java 当中变量声明，将 “ ”当中的值赋值给=======》myProperty，可以直接通过调用：myProperty 而获取到我们想要的值。

五、Gradle生命周期与钩子方法

生命周期的概念

• 

六、依赖管理

关键点：

依赖阶段配置：

七、版本冲突问题

Gradle解决冲突的方案

八、多项目构建

未完待续…

• 源码和剩余部分，有时间补上