Gradle_com.fasterxml.jackson.core gradle

Gradle入门

Gradle介绍

常用的项目构建工具有 Ant、Maven、Gradle 三种。
Ant 相对于另外两者较为灵活，速度也快，但是编写XML文件来构建指令，比较繁杂。
Maven 有一套约定大于配置的项目目录结构，使用了GAV左标进行管理依赖，侧重于包管理
Gradle 集成了Ant的脚本的灵活性和Maven的约定大于配置的优点，支持多种远程仓库和插件，侧重于大项目构建。但是学习成本高、资料少、脚本灵活、兼容性差。

Gradle安装

查看当前IDEA对应的Gradle版本 路径 IntelliJ IDEA 2020.3.2\plugins\gradle\lib
安装网址https://gradle.org/install/ 下载后解压再配置环境变量即可

Gradle项目创建

1. 可以去Spring官网创建
2. IDEA插件进行创建
3. gradle命令创建 ： gradle init

Gradle常用命令

gradle clean     		 清空build目录
gradle build      		 构建项目/生成build文件
gradle build -x test 	 跳过测试代码的构建
gradle test      		 执行测试代码、生成测试报告
gradle classes    		 编译class文件以及resource下的文件
1
2
3
4
5

修改Maven源

找到 init.d 文件，在里面创建.gradle结尾的文件，文件中配置云仓库数据源。
例：

allprojects {
    buildscript {
        repositories {
            maven { url 'https://maven.aliyun.com/repository/public/' }
            maven { url 'https://maven.aliyun.com/repository/google/' }
        }
    }

    repositories {
        maven { url 'https://maven.aliyun.com/repository/public/' }
        maven { url 'https://maven.aliyun.com/repository/google/' }
    }

    println "${it.name}: Aliyun maven mirror injected"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

阿里云仓库查看地址

Gradle整合IDEA

Groovy 简介

在某种程度上，Groovy被看做Java的一种脚本化改良版，Groovy也是运行在JVM上的，可以很好的与Java代码以及其相关的库进行交互操作。它是一种成熟的面向对象的编程语言，可以面向对象编程，也可以当做纯粹的脚本语言，大多数有效的Java代码也可以转化为有效的Groovy代码。Groovy和Java的主要区别是：完成同样的任务所需的Groovy代码比Java代码更少。

特点：

• 功能强大、提供了动态类型转化、闭包和元编程支持
• 支持函数式编程、不要用main函数
• 默认导入常用包
• 类不支持default作用域、默认为public
• 基本类型也是对象、可以直接调用对象方法
• 支持DSL和其他简洁语法、让代码变的易于阅读和维护
• 基于Java语言的，完全兼容Java语法

Groovy官方文档

Groovy安装

在官网下载groovy，解压后配置环境变量即可

Groovy基本语法

• 因为是基于Java语言的，所以完全兼容Java语法。可以作为面向对对象的语言（编译后继承了GroovyObject类），也可以作为脚本语言（编译后继承了Script类），同时Groovy中脚本语言和类可以混合定义，但是混合使用类名不可与文件名相同。
• Groovy中最好使用def来定义变量、方法。不建议使用具体的数据类型。
• Groovy中的语句末尾可以不加分号，换行即结束。
• Groovy中默认方法、字段、类等都是public定义的。
• 给对象属性赋值时，可以使用 对象.属性名 = ？ 、 对象的setter方法 、具名构造器(Groovy类自带的)
• 读取对象的属性时，可以使用对象.属性名 、 对象["属性名"] 、 对象.getter方法
• 对类属性的基本操作的本质上都是通过属性对应的getter和setter来完成的
• Groovy中声明方法时，参数类型、返回值、都可省略，return时默认使用方法最后一句的返回值作为方法的返回值，调用方法时()可以省略
• 支持顺序、分支、循环结构、支持各种运算符
• 基本类型也是对象，可以直接调用对象的方法
• Groovy中字符串有单引号：作为字符常量，没有运算能力、双引号：可引用变量${}，有运算能力、三引号：模板字符串，支持换行
• 变量、属性、方法、闭包的参数和返回值类型都是可有可无的，都是再给变量赋值的时候才决定类型。

Gradle搭建SSM项目

1. 构建基本的Gradle项目
2. 将相关依赖导入到build.gradle文件中
   例：

implementation 'org.springframework:spring-beans:4.1.7.RELEASE'
    implementation 'org.springframework:spring-web:4.1.7.RELEASE'
    implementation 'org.springframework:spring-webmvc:4.1.7.RELEASE'
    implementation 'org.springframework:spring-tx:4.1.7.RELEASE'
    implementation 'org.springframework:spring-test:4.0.5.RELEASE'
    implementation 'org.springframework:spring-jdbc:4.1.7.RELEASE'

    implementation 'org.mybatis:mybatis-spring:1.2.3'
    implementation 'org.mybatis:mybatis:3.3.0'

    implementation 'mysql:mysql-connector-java:5.1.36'
    implementation 'com.alibaba:druid:1.0.15'

    implementation "com.fasterxml.jackson.core:jackson-databind:2.2.3"
    implementation "com.fasterxml.jackson.core:jackson-annotations:2.2.3"
    implementation "com.fasterxml.jackson.core:jackson-core:2.2.3"

    implementation 'org.aspectj:aspectjweaver:1.8.6'
    implementation 'log4j:log4j:1.2.17'
    implementation 'org.slf4j:slf4j-api:1.7.25'
    implementation 'jstl:jstl:1.2'
    compileOnly 'javax.servlet:servlet-api:2.5'
    testImplementation group: 'junit' ,name: 'junit', version: '4.12'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. 创建webapp目录和WEB-INF，并添加web.xml文件，后添加或编辑SSM相关配置文件

Gradle使用Junit测试

Junit4

dependencies {
    testImplementation group: 'junit' ,name: 'junit', version: '4.12'
}
test {
    useJUnit()
}
1
2
3
4
5
6

Juint5

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' 
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}
test {
    useJUnitPlatform()
}
1
2
3
4
5
6
7

执行gradle test 或 gradle build 时， 会在build/reports/tests/test目录下，生成相关的测试报告

test {
    enabled(true)  //开启测试，打包时会生成测试报告 false为关闭
    useJUnit()    
    include ('com/**') 	   //指定的目录下的测试会执行并生成报告
    exclude ('com/abc/**')   //排除指定的目录下的测试
}
1
2
3
4
5
6

整合SpringBoot

	//添加插件
   id 'org.springframework.boot' version '2.3.7.RELEASE'
   id 'io.spring.dependency-management' version '1.0.10.RELEASE'
   //添加依赖
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
    exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}
1
2
3
4
5
6
7
8
9

Gradle进阶

Gradle生命周期

• 初始化：加载初始化脚本init.gradle文件，即 init.d目录下的文件，后执行当前目录的settings.gradle文件
• 配置文件：根据setting.gradle中的项目名，来对项目的build.gradle文件进行加载(会按照层级关系依次加载)，生成task有向无环树。
• 执行 ： 根据task有向无环树按照顺序来依次执行task

settings.gradle

• 主要作用是在项目初始化阶段确定一下引入哪些工程需要加入到项目构建中，为构建项目工程树做准备。
• gradle中有工程树的概念，类似于maven中的project与model。
• 文件里面主要定义了当前gradle项目和子project项目
• settings.gradle文件只有一个，且需要放到根工程目录下
• 文件名不可更改
• 一般只需关注文件中的include方法即可。使用相对路径[ : ] 来引入子工程
• 子工程只有在setting文件中配置了才会被gradle识别，这样在构建项目的时候才能被包含进去
  例：

rootProject.name = 'xxx'
//子工程名称
include 'xxxx'
include 'xxxx'
//子工程下的子工程
include 'xxxx : xxxx'
1
2
3
4
5
6

：类似于路径的 / ,是相对于 rootProject而言的。之后Gradle会为每个带有build.gradle的脚本文件的工程构建一个与之对应的Project对象。

Task

项目实质上是Task对象的集合，一个Task表示一个逻辑上较为独立的执行过程，比如编译Java源代码、拷贝文件、打包Jar文件，甚至可以是执行一个系统命令。一个Task可以读取和设置Project的Property以完成特定的操作。

Task的使用：

task "task1"{
    println("root Task1=====")
    doFirst {
        println("Do Frist =========")
    }
    doLast {
        println("Do Last ======================")
    }
}
1
2
3
4
5
6
7
8
9

可使用 gradle -i “task名称” 来执行指定的Task。其中Task的配置是在配置阶段完成的，Task的doFirst和doLast是在执行阶段完成的。即任务的配置在配置阶段完成，任务的执行是在执行阶段完成。

Task之间的依赖方式(例A、B 被 C 依赖)：

1.  task C (dependsOn:['A' , 'B'])
2.  task C {
		dependsOn = ['A', 'B']
		}
3. task C {
	
	}
	C.dependsOn = ['A', 'B']

跨项目依赖，加上相应的项目名即可，如 B 依赖 projectz中的A：
 task B{
 dependsOn = (":project:A")
 }
1
2
3
4
5
6
7
8
9
10
11
12
13

依赖

依赖方式：

• 本地依赖 : 依赖本地的构建jar包，具体可通过文件集合、文件数的方式去指定implementation files (‘路径’)
• 项目依赖：依赖某个 project implementation project(': 项目名') ，该项目需要在settings.gradle文件中被引用
• 直接依赖：依赖的类型 ： 依赖的组名： 依赖的名称：依赖的版本号 (引入的maven依赖一般都是)

依赖冲突：

• 默认会选择较新版本的jar包
• exclude排除某个依赖 : implementation('xxxx'){exclude group:'xxxx组名' || exclude module 'xxxx模块名' || exclude group:'xxxx组名' ，module 'xxxx模块名'}
• 取消依赖传递 implementation('xxxx'){ transitive(false)} 不建议使用
• 强制使用某版本号implementation('xxxx'){version{structly("xxx版本")}} || implementation('xxxx !!')
• 查看jar包冲突

configurations.all() {
    Configuration configuration ->
    configuration.resolutionStrategy.failOnVersionConflict()
}

1
2
3
4
5

• 将版本号换为 + 号 或 latest.integration ，获取最新的版本依赖，动态获取，不建议使用

发布

1. 添加插件

id 'java-library' //如果发布war包，需要war插件,java-library支持带源码、文档发布
id 'maven-publish'
1
2

2. 添加代码

publishing {
    publications {
        myLibrary(MavenPublication) {
            groupId = 'org.gradle.sample' //指定GAV坐标信息artifactId = 'library'
            version = '1.1'
            from components.java//发布jar包
            //from components.web ///引入war插件，发布war包
        }
    }
    repositories {
        //本地仓库位于USER_HOME/.m2/repository mavenLocal()
        mavenLocal()
        //发布项目到私服中
        maven {
            name = 'myRepo' //name属性可选,表示仓库名称，url必填
            //发布地址:可以是本地仓库或者maven私服
            //url = layout.buildDirectory.dir("repo")
            // change URLs to point to your repos, e.g. http://my.org/repo
            def releasesRepoUrl = layout.buildDirectory.dir('repos/releases')
            def snapshotsRepoUrl = layout.buildDirectory.dir('repos/snapshots')
            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
            //认证信息:用户名和密码
            //	credentials {
            //	username = 'joe'
            //	password = 'secret'
            //	}
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30