初识构建工具-gradle

时间:2022-02-08 08:54:02

构建工具的作用

  • 依赖管理

  • 测试,打包,发布

主流的构建工具

  • Ant:提供编译,测试,打包

  • Maven:在Ant的基础上提供了依赖管理和发布的功能

  • Gradle:在Maven的基础上使用Groovy管理构建脚本,不再使用XML来管理

Gradle

一个开源的项目自动化构建工具,建立在Apache Ant 和Apache Maven概念的基础上,并引入了基于Groovy的特定邻域语言(DSL),而不在使用XML形式管理构建脚本。

Gradle的下载与安装

下载地址:https://gradle.org/releases

初识构建工具-gradle

  • 配置环境变量,GRADLE_HOME

  • 添加到path,%GRADLE_HOME%\bin;

  • 验证是否安装成功, gradle -v

初识构建工具-gradle


Groovy

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

与Java相比较,Groovy完全兼容Java语法,分号是可选的,类和方法默认都是public,编译器给属性自动添加getter/setter方法,属性可以直接用点号获取,不再需要通过方法来获取,同时最后一个表达式的值会被作为返回值,==等同于equals(),不会有NullPointerException。

Groovy的高效特性中,自带了assert语句,它是弱类型的编程语言,直接通过def来定义类型;同时它的括号是可选的,字符串有多种写法。

功能演示

IDE:idea

初识构建工具-gradle

初识构建工具-gradle

初识构建工具-gradle

初识构建工具-gradle

打开Groovy的控制台,Tools -> Groovy Console

初识构建工具-gradle

可选的定义类型

def version = 1

def不是一个明确的类型,它类似于javascript里面的var,定义一个变量,变量的类型是自动推断出来的,在这里version就是int类型。

assert

assert version == 2

这是一个失败的断言,因为version是等于1,执行后返回false

括号可选

println version

执行结果任然是1

字符串

def s1 = 'zzh'//单纯的字符串
def s2 = "gradle version is ${version}"//可以插入变量
def s3 = '''zzh
is
handsome'''
println s1
println s2
println s3

s1表示单纯字符串,s2可以插入变量,s3则是可以换行

初识构建工具-gradle

集合api -> List

buildTools的默认类型是ArrayList,向里面追加一个元素buildTools << 'gradle'。

def buildTools = ['ant','maven']
buildTools << 'gradle'
println buildTools.getClass()
assert buildTools.getClass() == ArrayList
assert buildTools.size() == 3

初识构建工具-gradle

集合api -> Map

buildYears的默认类型为LinkedHashMap,在Map上添加一个元素直接用点号就行,元素的访问有两种类型,可以用点号也可以用字符串

def buildYears = ['ant':2000,'maven':2004]
buildYears.gradle = 2009

println buildYears.ant
println buildYears['gradle']
println buildYears.getClass()

初识构建工具-gradle

闭包

简单来说就是一个代码块,跟方法一样可以有参数也可以没有,还可以被赋值给一个变量,也可以当作一个参数传递给一个方法。

//包含参数的闭包,参数v省略了类型,“->”后面是方法体
def c1 = {
    v ->
        println v
}

//不包含参数的闭包
def c2 = {
    println 'hello'
}

//使用闭包作为参数,Closure是groovy自带的,不要导入java里面的包
def method1(Closure closure){
    closure('param')    //带参数的闭包
}

def method2(Closure closure){
    closure()    //不带参数的闭包
}

def method3(Closure closure) {
    closure()
}

method1(c1)
method2(c2)

method3 {
    println '省略方法参数括号直接传入闭包'
}

初识构建工具-gradle


快速实现添加待办事项应用程序

先进行实例演示,之后再讲解具体步骤功能。

Java应用程序版

Gradle管理jar包,通过在控制台输入代办事项的名称在控制台显示代办事项。

创建todo应用程序

先手动创建src相关目录:

初识构建工具-gradle

代办事项的bean:TodoItem.java

package com.zzh.gradle.todo;

public class TodoItem {

    //代办事项的名称
    private String name;

    //已完成
    private boolean hasDone;

    public TodoItem(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isHasDone() {
        return hasDone;
    }

    public void setHasDone(boolean hasDone) {
        this.hasDone = hasDone;
    }

    @Override
    public String toString() {
        return name + (hasDone ? " hasDone" : " need to do") + "!";
    }
}

从控制台读取代办事项的名称并打印:App.java

package com.zzh.gradle.todo;

import java.util.Scanner;


public class App {
    public static void main(String[] args) {
        int i = 0;
        Scanner scanner = new Scanner(System.in);
        while (++i > 0) {
            System.out.println(i + ". please input todo item name:");
            TodoItem item = new TodoItem(scanner.nextLine());
            System.out.println(item);
        }
    }
}       

打开右侧Gradle projects

初识构建工具-gradle

jar:把当前的源文件编译完后打包成jar包

build:根据项目中的build.gradle构建脚本,脚本中的语句apply plugin: 'java'即使用java构建插件,所以构建完后也是jar包的形式。

clean:清楚之前的构建。

点击jar后,及进行编译java,处理资源文件,生成字节码,打包成jar包

初识构建工具-gradle

执行jar包

因为这个jar包里面有包含main方法的类,所以可以直接执行,而没有main方法的jar包一般会作为依赖被其他的工程引用。

初识构建工具-gradle

在终端执行

初识构建工具-gradle

Web版

Gradle管理Web应用程序的功能

添加webapp目录:

初识构建工具-gradle

其中log.properties只是用于演示打包之后这个配置文件会在压缩包什么位置。

index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>todo</title>
    <script type="text/javascript">
        function addTodo() {
            var name = document.getElementById("name").value;
            var list = document.getElementById("list");
            list.innerHTML = list.innerHTML + "<p>" + name + "</p>";
        }
    </script>
</head>
<body>
<h1>TODO-web版</h1>
<label>请输入代办事项名称:</label><input id="name" type="text"/>
<button onclick="addTodo()">添加</button>
<h3>代办事项列表:</h3>
<div id="list"></div>
</body>
</html>

build.gradle添加war插件

加上apply plugin: 'war' 之后刷新,看到build下面多出了war构建功能,点击之后,找到war包:

初识构建工具-gradle

初识构建工具-gradle

将war包放在本机Tomcat的webapp文件夹下,启动tomcat:

初识构建工具-gradle

war包自动解压缩后的文件夹中,可以看到配置文件和字节码是同级目录,路径是正确的。

初识构建工具-gradle


基本原理

构建脚本介绍

构建块:
Gradle中的两个基本概念是项目(Project)和任务(task),每个构建至少包含一个项目,项目中包含一个或多个任务。在多项目构建中,一个项目可以依赖于其他项目;类似的,任务可以形成一个依赖关系图来确保他们的执行顺序。

初识构建工具-gradle

项目1依赖于项目2,任务A依赖于任务B和C,所以B和C要在A之前执行完。


项目:
一个项目代表一个正在构建的组件(比如一个jar文件),当构建启动后,Gradle会基于build.gradle实例化一个org.gradle.api.Project类,并且能够通过project变量使其隐式可用。

项目的主要属性:

  • group:组
  • name:名称,等同于maven里的ArtifactId
  • version:版本号

项目的主要方法:

  • apply:应用一个插件

  • dependencies:声明项目依赖于哪些jar或者是其他项目

  • repositories:指定仓库,根据group,name,version唯一确定一个组件

  • task: 声明项目里的任务


任务(task)

任务对应org.gradle.api.Task,主要包括任务动作和任务依赖。任务动作定义了一个最小的工作单元。可以定义依赖于其他任务,动作序列和执行条件。

任务的主要方法:

  • dependsOn:声明任务依赖

  • doFirst:在任务列表的最前面添加一个动作。

  • doLast:在任务列表的末尾添加一个动作。


自定义任务

在前面创建目录结构的时候都是手动创建,现在用自定义任务来完成自动创建目录结构的功能。

创建有参闭包用于创建目录

传进的参数是字符串路径:

def createDir = {
    path ->
        File dir = new File(path)
        if (!dir.exists()) {
            dir.mkdirs()
        }
}

在build.gradle中声明任务并给任务添加动作

定义一个数组,里面存放目录路径,同时给任务添加一个动作doFirst

task makeJavaDir() {
    def paths = ['src/main/java', 'src/main/resources', 'src/test/java', 'src/test/resources']
    doFirst{
        paths.forEach(createDir)
    }
}

执行自定义任务

初识构建工具-gradle

执行makeJavaDir后目录被创建:

初识构建工具-gradle

定义任务创建Web的目录

因为java工程有的目录Web工程都有,只是Web工程多了webapp目录,可以使用web工程依赖java工程,这样web只用创建特有的目录即可.添加doLast动作:

task makeWebDir(){
    dependsOn 'makeJavaDir'
    def paths = ['src/main/webapp','src/test/webapp']
    doLast {
        paths.forEach(createDir)
    }
}

初识构建工具-gradle

先将test文件夹删除,测试是否会先执行makeJavaDir:

初识构建工具-gradle

先执行makeJavaDir,在执行makeWebDir,目录也被创建好了:

初识构建工具-gradle


构建生命周期

第一阶段:初始化

Gradle会根据构建脚本创造一个Project类,并在构建脚本中隐式可用。

第二阶段:配置

生成task的依赖顺序和执行顺序,并初始化任务。比如:

task loadVersion{
    project.version='1.0'
}

第三阶段:执行

执行动作代码。例如doLast:

task loadVersion <<{
    print 'success'
}

依赖管理

几乎所有的基于JVM的软件项目都需要依赖外部类库来重用现有的功能。自动化的依赖管理可以明确依赖的版本,可以解决因传递性依赖带来的版本冲突。

工件坐标

group,name,version三个属性可以唯一确定一个jar包。

仓库

仓库用来存放jar包

依赖阶段关系

初识构建工具-gradle

编译时依赖的jar包在运行时都会依赖,在运行时依赖的在编译阶段不会依赖。源代码依赖的测试代码都会依赖,反之则不一定。

比如在build.gradle里的

dependencies {
    compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.1'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

testCompile就是测试编译阶段依赖的jar包,compile则是编译阶段依赖的jar包logback。

在App.java里面添加日志:

初识构建工具-gradle

修改仓库配置

repositories可以配置多个仓库,除了默认的*仓库mavenCertral,还可以配置mavenLocal()本地仓库,当有多个仓库的时候是按仓库的顺序去查找jar包。
还可以配置私服仓库,地址就写在url里面。

repositories {
    mavenLocal()
    mavenCentral()
    maven{
        url ''
    }
}

解决版本冲突

  • 查看依赖报告

  • 排除传递性依赖

  • 强制一个版本

Gradle会自动依赖最高版本的jar包,这是gradle的默认处理方式。

比如现在添加hibernate-core的依赖:

dependencies {
    compile group: 'org.hibernate',name: 'hibernate-core', version: '3.6.3.Final'
    compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.1'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

hibernate-core对slf4j-api有依赖,依赖的版本是1.6.11,而之前的logback-classic对slf4-api也有依赖,版本是1.7.22,现在加入之后被强制依赖最高的版本1.7.22:

初识构建工具-gradle

执行 Tasks -> help -> dependencies 任务看到详细的依赖转变:

初识构建工具-gradle

  • 修改默认解决策略:

当出现版本冲突的时候,不使用最新的包,直接让它构建失败,这样就能知道哪些出现了版本冲突。

configurations.all{
    resolutionStrategy{
        failOnVersionConflict()
    }
}

加入之后报错:

初识构建工具-gradle

  • 解决冲突:强制指定
configurations.all{
    resolutionStrategy{
        force 'org.slf4j:slf4j-api:1.7.22'
    }
}

多项目构建

项目模块化

在企业项目中,包层次和类关系比较复杂,把代码拆分成模块通常是最佳实践,这需要清晰的划分功能边界,比如把业务逻辑和数据持久化划分开来。项目符合高内聚低耦合时,模块化就变得很容易,这是一条非常好的软件开发实践。

TODO模块依赖关系

初识构建工具-gradle

配置子项目

创建模块repository,model,web;通过右键todo项目 -> New -> Module;
将原来的src拖进web子模块中。

初识构建工具-gradle

打开settings.gradle生成目录结构:可以看到根项目是todo,剩下三个项目都是子模块要include进来的。

现在让repository模块依赖model模块,web模块依赖repository模块,这样web模块也能依赖model模块了。

  • repository的build.gradle:
dependencies {
    compile project(":model")
    testCompile group: 'junit', name: 'junit', version: '4.12'
}
  • web的build.gradle:
dependencies {
    compile project(":repository")
    compile group: 'org.hibernate',name: 'hibernate-core', version: '3.6.3.Final'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

查看依赖关系可以看到web模块依赖于repository模块,repository模块有依赖于modle模块:

初识构建工具-gradle


多项目构建实战

先把原来的自定义任务删除

配置要求

  • 所有项目应用Java插件

  • web子项目打包成WAR

  • 所有项目添加logback日志功能

  • 统一配置公共属性

所有项目应用Java插件

现在存在一个问题,项目和子项目中都有apply plugin: 'java',可以进行统一处理,将子项目中的apply plugin: 'java'和sourceCompatibility = 1.8都删除,在根项目的build.gradle下通过allprojects进行配置:

group 'com.zzh.gradle'
version '1.0-SNAPSHOT'

apply plugin: 'war'

allprojects{
    apply plugin: 'java'
    sourceCompatibility = 1.8
}

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.1'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

web子项目打包成WAR

将根项目下的apply plugin: 'war' 删除,在web子项目的build.gradle中加上就行。

所有项目添加logback日志功能

使用subprojects来演示配置logback的功能,用allprojects也能达到同样效果。将根项目中的repositories和dependencies放入subprojects中,这样子项目中依赖就不用配置junit

root下的build.gradle:

group 'com.zzh.gradle'
version '1.0-SNAPSHOT'


allprojects{
    apply plugin: 'java'
    sourceCompatibility = 1.8
}

subprojects{
    repositories {
        mavenLocal()
        mavenCentral()
    }
    dependencies {
        compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.1'
        testCompile group: 'junit', name: 'junit', version: '4.12'
    }
}

repositories {
    mavenLocal()
    mavenCentral()
}

多项目构建小结:

当多项目构建的时候,每个子项目的build.gradle只是对其他子项目的依赖或者其他的个性化配置,共同的都会放在根项目下进行配置。


Gradle测试

自动化测试

一些开源的测试框架比如JUnit,TestNG可以编写可复用的结构化的测试,为了运行这些测试,需要先编译。测试代码的作用仅仅用于测试的情况,不应该被发布到生产环境中,需要把源代码和测试代码分开来。

TodoRepository.java

package com.zzh.gradle.todo.repository;


import com.zzh.gradle.todo.model.TodoItem;

import java.util.HashMap;
import java.util.Map;

public class TodoRepository {
    private static Map<String, TodoItem> items = new HashMap<>();


    public void save(TodoItem item) {
        System.out.println("" + item);
        items.put(item.getName(), item);
    }

    public TodoItem query(String name) {
        return items.get(name);
    }
}

测试类

package com.zzh.gradle.todo.repository;

import com.zzh.gradle.todo.model.TodoItem;
import org.junit.Assert;
import org.junit.Test;

import static org.junit.Assert.*;


public class TodoRepositoryTest {

    private TodoRepository repository = new TodoRepository();

    @Test
    public void save() throws Exception {
        TodoItem item = new TodoItem("zzh");
        repository.save(item);
        Assert.assertNotNull(repository.query(item.getName()));

    }

}

执行repository子模块的build任务,查看结果:

初识构建工具-gradle

初识构建工具-gradle


发布

根项目的build.gradle中使用插件“maven-publish”

group 'com.zzh.gradle'
version '1.0-SNAPSHOT'

allprojects{
    apply plugin: 'java'
    sourceCompatibility = 1.8
    apply plugin: 'maven-publish'

    publishing{
        publications{
            myPublish(MavenPublication){
                from components.java
            }
        }
    }
    repositories{
            maven{
                name "myRepo"
                url ""
            }
        }

}

subprojects{
    repositories {
        mavenCentral()
    }
    dependencies {
        compile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.1'
        testCompile group: 'junit', name: 'junit', version: '4.12'
    }
}

myPublish是自己定义的方法名字,component.java表示把java产生的输出发布到仓库里面。repositories里的仓库名字可以自己定义,url地址一般来说就是私服地址。应用插件之后gradle的tasks增加了publishing:

初识构建工具-gradle

执行所有的MavenLocal任务:publishToMavenLocal

打开本地仓库(根据自己配置的地址):

初识构建工具-gradle

发布的步骤

  • 使用maven-publish插件

  • 配置要发布的内容和仓库地址

  • 执行发布任务


总体流程

初识构建工具-gradle

GitHub地址:

learning_gradle