Gradle：Gradle的具体介绍与使用

怼烎@ 2023-10-05 22:01 46阅读 0赞

> **我是 ABin-阿斌：写一生代码，创一世佳话，筑一览芳华。 如果小伙伴们觉得我的文章有点 feel ，那就点个赞再走哦。**  
> ![在这里插入图片描述][01244a35a05f9070bf77418374331efc.png_pic_center]

#### 文章目录 ####

*   *  一、简介
     *   *  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构建脚本理论 ####

*  ![在这里插入图片描述][fa69b5902f09171f61bb22bc44b51dba.png_pic_center]

#### 3、编写任务测试 ####

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

//测试如何编写任务
    task t1 {
        
        println("t1")
    }
    
    task t2(dependsOn: "t1") {
        
        //t2 执行前的操作
        doFirst {
        
            println("t2,First")
        }
        println("t2")
        //t2 执行之后的操作
        doLast {
        
            println("t2,second")
        }
    }

*  **操作步骤：**

![在这里插入图片描述][df02d82b3032ff169d308cafa1b1cf17.png_pic_center]

*  **执行结果：**  
    ![在这里插入图片描述][6abd32e627f92df389de7a176fca149e.png_pic_center]  
    ![在这里插入图片描述][47fcda4b90a934892155a9d0e43be66c.png_pic_center]  
    ![在这里插入图片描述][d71ca3a487cc8705b7b321eedba28d03.png_pic_center]
 *  **结论：**直接定义在任务下的代码会在配置 **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** 而获取到我们想要的值。

![在这里插入图片描述][1390f2fd67aa21e67f92d2ca8ab3f3d6.png_pic_center]

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

#### 生命周期的概念 ####

*  ![在这里插入图片描述][267a71bd06c132fb8bafca20bfd43b90.png_pic_center]

### 六、依赖管理 ###

#### 关键点： ####

![在这里插入图片描述][e5b2d65b2e44ca6028149cdb30c91f0a.png_pic_center]![在这里插入图片描述][83369506a97aa0c8deb8a28402dcaf60.png_pic_center]

#### 依赖阶段配置： ####

![在这里插入图片描述][47eb3f82ef39fd0891f875c6abd9df36.png_pic_center]

### 七、版本冲突问题 ###

![在这里插入图片描述][3d55467ffaf724ed9dc999cd02571aaf.png_pic_center]  
![在这里插入图片描述][710597ee8cddac1deaa84db7262cdaa3.png_pic_center]

#### Gradle解决冲突的方案 ####

![在这里插入图片描述][a217d4e5094bfa1ba7d6a6a5ab658ca6.png_pic_center]![在这里插入图片描述][85c438cecf8e295f4429460e66acb750.png_pic_center]

### 八、多项目构建 ###

![在这里插入图片描述][4df1f61924feb759b90e04acb577eb02.png_pic_center]

### 未完待续… ###

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

[01244a35a05f9070bf77418374331efc.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/01244a35a05f9070bf77418374331efc.png#pic_center
[fa69b5902f09171f61bb22bc44b51dba.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/fa69b5902f09171f61bb22bc44b51dba.png#pic_center
[df02d82b3032ff169d308cafa1b1cf17.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/df02d82b3032ff169d308cafa1b1cf17.png#pic_center
[6abd32e627f92df389de7a176fca149e.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/6abd32e627f92df389de7a176fca149e.png#pic_center
[47fcda4b90a934892155a9d0e43be66c.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/47fcda4b90a934892155a9d0e43be66c.png#pic_center
[d71ca3a487cc8705b7b321eedba28d03.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/d71ca3a487cc8705b7b321eedba28d03.png#pic_center
[1390f2fd67aa21e67f92d2ca8ab3f3d6.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/1390f2fd67aa21e67f92d2ca8ab3f3d6.png#pic_center
[267a71bd06c132fb8bafca20bfd43b90.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/267a71bd06c132fb8bafca20bfd43b90.png#pic_center
[e5b2d65b2e44ca6028149cdb30c91f0a.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/e5b2d65b2e44ca6028149cdb30c91f0a.png#pic_center
[83369506a97aa0c8deb8a28402dcaf60.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/83369506a97aa0c8deb8a28402dcaf60.png#pic_center
[47eb3f82ef39fd0891f875c6abd9df36.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/47eb3f82ef39fd0891f875c6abd9df36.png#pic_center
[3d55467ffaf724ed9dc999cd02571aaf.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/3d55467ffaf724ed9dc999cd02571aaf.png#pic_center
[710597ee8cddac1deaa84db7262cdaa3.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/710597ee8cddac1deaa84db7262cdaa3.png#pic_center
[a217d4e5094bfa1ba7d6a6a5ab658ca6.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/a217d4e5094bfa1ba7d6a6a5ab658ca6.png#pic_center
[85c438cecf8e295f4429460e66acb750.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/85c438cecf8e295f4429460e66acb750.png#pic_center
[4df1f61924feb759b90e04acb577eb02.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/4df1f61924feb759b90e04acb577eb02.png#pic_center