Gradle

Posted 2020-11-01 kz2017

概念：开源的项目自动化构建工具，在Ant和Maven的基础上，引入了基于Groovy的特定领域语言(DSL)，不再使用XML形式管理构建脚本。

Tools-->groovy Console-->打开groovy视图

Groovy与Java比较：

// 类、方法默认是public的 完全兼容Java的语法 
public class ProjectVersion{ 
// 大版本 private int major; 
// 小版本 private int minor; 
ProjectVersion(int major, int minor) { 
this.major = major this.minor = minor 
} 
int getMajor() { 
// 最后一个表达式的值会被作为返回值(最后一个方法的return可以不写) major 
} 
void setMajor(int major) {
this.major = major 
}
} 
// 分号是可选的 
ProjectVersion v1=new ProjectVersion(1,1) 
// 编译器给属性自定添加getter/setter方法 属性可以直接用点号获取 println v1.minor 
ProjectVersion v2=null 
// == 等同于equals()，不会有NullPlinterExceptions 
println v2==v1

 

高效Groovy特性：

//1 可选的类型定义 
//def version=1 
//2 assert 失败的断言 因为version上面为1 
//assert version==2 
//3 括号是可选的 
//println version 
//4 字符串 
/*def s1=‘imooc‘ 
//仅仅是字符串 def s2="gradle version is ${version}" 
//可以插入变量 def s3=‘‘‘my name is imooc‘‘‘ 
//可以换行 println s1 println s2 println s3*/ 
//5 集合api 
//list 
/*def buildTools=[‘ant‘,‘maven‘] buildTools << ‘gradle‘ 
//添加元素 assert buildTools.getClass() == ArrayList 
//默认是ArrayList assert buildTools.size() ==3 
//断言size
*/ 
//map 
/*def buildYears=[‘ant‘:2000,‘maven‘:2004] buildYears.gradle=2009
//添加元素 
println buildYears.ant 
println buildYears[‘gradle‘] 
println buildYears.getClass() == LinkedHashMap 
//默认是LinkedHashMap*/ 
//6 闭包 代码块 一般用来方法传参 (不是必须的) 
/* def c1={ v -> print v } 
def c2={ print ‘hello‘ } 
def method1(Closure closure){ 
closure(‘param‘) 
//带参数的 
} 
def method2(Closure closure){ 
closure() //不带参数的 
} 
method1(c1) method2(c2)*/
 

 

最简单的例子(build.gradle)：

//构建脚本中默认都是有个Project实例的 
apply plugin:"java" 
//apply方法 
plugin:"java"命名参数 --》代表着使用java这个插件 version=‘0.1‘ 
//变量 
repositories{ 
mavenCentral() 
//闭包 无参调用repositories(仓库)方法 
} 
dependencies{ 
compile ‘commons-codec:commons-codec:1.6‘ 
//闭包 有参调用dependencies(依赖管理)方法 
}

 

TODO应用程序版：

TodoItem类：

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类：
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); 
}
}
}

 

进入构建栏目：

然后打成jar包

有main()方法 就可以直接终端启用了

 

TODO--web版：

右击项目选择add framework support --> 勾选web application（注：点击Java EE可选择java ee版本）==》添加web

编写个简单的index.html

apply plugin:‘war‘ //使用war插件

点击war进行构建 构建好后 放到tomcat的webapps下 启动tomcat进行测试

 

构建脚本概要：

构建块：

基本概念：

每个构建至少包含一个项目，项目中包含一个或多个任务。

1.项目(project)

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

group、name、version来确认仓库中的唯一坐标。

重要的方法：

1.apply(插件) 2.dependencies(依赖) 3.repositories(仓库) 4.task(任务)

属性的其他配置方式：

ext、gradle.properties

2.任务(task)

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

自定义任务(build.gradle)：

//闭包 
def createDir = { 
path -> File dir = new File(path); 
if (!dir.exists()) { 
dir.mkdirs(); 
}
} 
//自定义任务1 
task makeJavaDir() { 
def paths = [‘src/main/java‘, ‘src/main/resources‘, ‘src/test/java‘, ‘src/test/resources‘] 
//在动作列表之前插入 
doFirst { 
paths.forEach(createDir); 
}
} 
//自定义任务2 
task makeWebDir(){ 
//任务依赖 
dependsOn ‘makeJavaDir‘ 
def paths=[‘src/main/webapp‘,‘src/test/webapp‘] 
//在动作列表之后插入 
doLast { 
paths.forEach(createDir) 
}
}

 

 

进入构建栏目：

 

 

自定义任务在other这里。

 

构建生命周期：

初始化(项目)-->配置(依赖关系和执行图)-->执行(动作 如：doFirst doLast )

 

依赖管理：

常用仓库：

mavenLocal/mavenCentral/jcenter==》第一个是本地仓库 后两个是公共仓库

自定义maven仓库==》maven私服

写法：

repositories{ maven{ url ‘私服仓库地址‘ }}

 

阶段配置：

源代码阶段：

1.compile(编译阶段) 2.runtime(运行时阶段)

测试阶段：

1.testCompile(编译阶段) 2.testRuntime(运行时阶段)

一般都使用编译极端的依赖。

如：compile ‘group、name、version‘

解决版本冲突：

1.查看依赖报告

先修改默认解决策略(gradle默认依赖最新版本)

 

//发现版本冲突就自动构建失败 configurations.all{ resolutionStrategy{ failOnVersionConflict() }}

2.排除传递性依赖

compile(‘org.hibernate:hibernate-core:3.6.3.Final‘){ exclude group:"org.slf4j",module:"slf4j-api" }

3.强制一个版本

configurations.all{ resolutionStrategy{ force ‘org.slf4j:slf4j-api:1.7.24‘ }}

 

多项目构建：

发布：

allprojects{ 
apply plugin: ‘java‘ sourceCompatibility=1.8 
//插件发布 
apply plugin: ‘maven-publish‘ publishing{ 
publications{ 
//可以定义多个发布包 
myPublish(MavenPublication){ 
//发布java from components.java 
}
} 
repositories{ 
maven{ 
name "自定义名称" url "私服仓库地址" 
}
}
}
}