1. Gradle 认识
下载以后,配置gralde环境变量： D:\software\gradle-4.4\bin 【grale 需要JAVA_HOME】
目录结构：
bin : gradle 命令
docs: 手册
lib: gradle 依赖jar包
media: gradle 图标
sample: 例子
src: 源码
输入 gradle 调用gradle.bat命令 默认搜索当前目录 build.gradle, 有输出信息,安装成功
构建指定文件 ： gradle -b a.gradle
gradle --help: 查看gradle 指令
2. grale功能就是构建文件， 定义构建文件的各种任务和属性, 每个任务包含Action动作
grale 项目结构，用idea创建以后默认的项目结果,和maven项目一样：
<project>: 存放整个项目的资源
src
main
java : java 代码
resources：资源
test
java
resources
build： 编译以后class文件、资源文件
libs: 存放jar包
build.gradle
buuld.gradle 文件结构：
Project ： 表示项目，表示一份构建文件代表一个项目
TaskContainer: 任务容器
Task： gradle 要执行的一个任务
Action: Task表示要执行任务的方法[ 可以doFirst、doLast、或者Closure(闭包)]
2. Gradle 任务定义
2.1. build.gradle 编写，定义任务的第一种方式
// 定义任务的第一种方式
task hello1 {
println "configuration is first task"
// 在所有Action后面执行
doLast{
for(i in 0..<5){
println i
}
}
// 在所有Action前面执行
doFirst{
def s="do first..."
println "dofirst name:$s"
}
}
task hello2{
println "configuration is second task"
} grald构建配置过程：
配置： 配置project的所有task,看到 configura1 configura2 输出
运行阶段： 只是执行hello1
2.2. build.gradle 编写，定义任务的第二种方式
// 调用 Project的 tasks 属性的 create 方法来创建 Task
tasks.create(name: "showTasks"){
doLast{
// 查看 Project的 tasks属性的 类型
// tasks type is ： tasks attrubute type class org.gradle.api.internal.tasks.DefaultTaskContainer_Decorated
println "tasks attrubute type ${tasks.class}"
// show all task
// 遍历所有tasks 属性
tasks.each{
e-> println e
}
}
}输出:> Task :showTasks
tasks attrubute type class org.gradle.api.internal.tasks.DefaultTaskContainer_Decorated
task ':fkTask'
task ':hello1'
task ':hello2'
task ':showTasks'
2.3. dependsOn 属性和 Type 属性
创建Task 时可通过 dependsOn 属性执行依赖Task,首先执行依赖Tasks, 可以通过Type 指定 该Task的类型 ，默认类型是Gradl实现的 DefaultTask类
task hello2{
println "configuration is second task"
}
// dependsOn 指定 Task依赖 hello2 ,该 Task的 类型是 Copy (文件拷贝)
// 把当前目录下的 a.txt 拷贝到 dist 目录下
// Task type is copy , it fucntion si copy file from to into
// fkTask dependsOn hello2, so first run hello2
tasks.create(name: "fkTask",dependsOn:"hello2",type:Copy){
from "a.txt"
into "dist"
}2.4. 案例： HelloWorld 编译运行
build.gradle:
apply plugin: 'java'
// 案例： HelloWorld 编译运行
//1. 定义compile任务 类型是 JavaCompile
// point to type JavaCompile
task compile(type: JavaCompile){
// point to source path 源代码路径
source= fileTree('src/main/java')
classpath= sourceSets.main.compileClasspath
// point to byte_code output path 构建目录
destinationDir = file('build/classes/main')
options.fork= true
options.incremental= true
}
// 2. 指定运行任务类型是 JavaExec, 这些都是 java 插件提供的
// point to type JavaExec
task run(type: JavaExec, dependsOn:'compile'){
classpath = sourceSets.main.runtimeClasspath
// run program to point to main Funtion class
// 执行运行主类
main = 'lee.HelloWorld'
}\src\main\java\HelloWorld.java
package lee;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}运行结果: D:\software\gradle-4.4\bin\Hello>gradle run
> Task :run
Hello World
3. 属性定义, groovy 基础语法
1. gradle 属性 定义：
project 属性
task属性
2. 5.1. 允许运行gradle命令通过-P 添加属性, 通过如下方式访问，如果不存在属性，会出异常
5.2. 通过JVM 参数添加属性
3.groovy
定义 list
定义 map
Groovy 闭包 , 闭包就是一段代码，做作为参数
// 1. point attrubite belong to project, 定义project属性
// define a variable
version = 1.0
description = 'project attribute'
//2. define list
def list= ['a','b','c']
// list add element
list << 'd'
// get a element
println list.get(3)
// 3. define a map
def map = [ "key1":"value1" ];
// add key-value
map.key2="value2"
// output key2
println map.get("key2")
// 4. Groovy 闭包 , 闭包就是一段代码，做作为参数
def b1 = { println '4.1.output closure' }
def method1(Closure closure){
closure()
}
method1(b1)
// 带有参数闭包, 这里必须是 ""
def f2 = {
v1->
println "hello:${v1}"
}
def method2(Closure closure){
closure('xiaoming')
}
method2(f2)
task showProp {
// 定义 task属性
description = 'task attribute'
doLast{
// groovy output console function
println version
println description
println project.description
// 5. 添加属性
// 5.1. 允许运行gradle命令通过-P 添加属性, 通过如下方式访问，如果不存在属性，会出异常
// gradle -P graph=ATI showProp
// 5.2. 通过JVM 参数添加属性
// gradle -D org.gradle.project.graph=sss showProp
println "by -p add atrribute ${graph}"
}
}4. Grande 插件 ： 开发的库
使用：
apply plugin: 插件名 引入插件以后相当于包含了该插件所有的任务类型、任务、属性等
java 插件：
apply plugin: 'java'
gradle tasks --all: 查看java 下所有任务
5. 依赖管理：
5.1. 配置gradle 仓库,从哪里下载jar包
maven仓库：
repositories {
// 指定 maven 远程仓库
maven{ url 'http://maven.aliyun.com/nexus/content/groups/public/'}
// maven中央仓库
mavenCentral()
// 本地仓库
maven{
url:"e:/abc"
}
} 5.2. 组的概念：
一个 项目在 编译的时候依赖某一个组jar包, 运行的时候依赖某一组, 测试的时候有依赖其他组
JAR包配置： 和maven类似通过坐标
jar包依赖组 (group指定) + jar包名称(name指定) + jar包版本(version)
apply plugin: 'java'
apply plugin: 'application'
mainClassName = 'lee.HelloWorld'
定义仓库
repositories {
// // 使用Maven默认的中央仓库
mavenCentral()
}
// 定义仓库
//repositories {
// maven远程仓库
// maven {
// 显式指定Maven仓库的URL
// url "http://repo2.maven.org/maven2/"
// }
//}
configurations {
// 配置名为fkDependency的依赖组
fkDependency
}
dependencies {
// // 配置依赖JAR包方式1
fkDependency group:'commons-logging', name:'commons-logging', version:'1.2'
// // 简写为如下形式 ,工作中常用
// fkDependency 'commons-logging:commons-logging:1.2'
// 如果依赖库需要进行额外配置，使用{}闭包
//implementation(name: 'alipaySdk-15.6.5-20190718211159-noUtdid', ext: 'aar') {
// exclude group: 'com.squareup.okhttp3'
// }
// fkDependency (group:'commons-logging', name:'commons-logging', version:'1.2') {
// // 提供额外配置...
// }
// // 简写为如下形式
// fkDependency ('commons-logging:commons-logging:1.2') {
// // 提供额外配置...
// }
}
task showFkDependency {
doLast{
// 输出fkDependency的依赖的JAR包
// C:\Users\denganzhi\.gradle\caches\modules-2\files-2.1\commons-logging 下载路径
println configurations.fkDependency.asPath
}
}
实际项目开发中不需要自己配置依赖组, 应用 使用java 插件以后, 插件默认添加了多个依赖组
implementation: 主项目源代码所依赖组
testImplementation: 项目测试代码依赖组
archives: 项目打包依赖组
compileOnly: 编译的时候才依赖组
runtimeOnly: 运行的时候才依赖组
implementation 'com.android.support:appcompat-v7:28.0.0'
testImplementation 'junit:junit:4.12'
6. Groovy 自定义任务, 继承 DefaultTask基类
使用 @TaskAction 修饰方法，添加该类型任务以后，会自动会被调用，默认方法，
// 1. 继承DefaultTask定义自定义任务
class HelloWorldTask extends DefaultTask {
@Optional
def message = 'A'
// 使用@TaskAction修饰的方法被自动当成Action
@TaskAction
def test(){
println "test：$message"
}
def info(){
println "info：$message"
}
}
// 这里可以理解为类的一个变量
// grale hello 运行
// 输出： test A
// info B
task hello(type: HelloWorldTask){
doLast{
info()
}
}
// grale hello1 运行
// 输出 test B
task hello1(type: HelloWorldTask){
message = "B"
}
// 2. 指定 ShowTask.groovy 文件
// 命令： grale show
// 使用Groovy文件中的task
task show(type: org.fkjava.ShowTask)
// 使用Groovy文件中的task
task show1(type: org.fkjava.ShowTask) {
// 对file属性赋值
file = file("e:/hello.txt")
}
在build.gradle 同级目录下：.\buildSrc\src\main\groovy\org\fkjava\ShowTask.groovy
package org.fkjava;
import org.gradle.api.*
import org.gradle.api.tasks.*
/**
* Description:<br>
* Copyright (C), 2001-2018, Yeeku.H.Lee<br>
* This program is protected by copyright laws.<br>
* Program Name:<br>
* Date:<br>
* @author Yeeku.H.Lee [email protected]<br>
* @version 1.0
*/
class ShowTask extends DefaultTask {
@Optional
File file = new File('e:/hello.txt')
@TaskAction
def show(){
println file.text
}
// 该注解用于把该方法标注为默认执行的action
@TaskAction
def multiShow(){
println "-------------"
println file.text
println "-------------"
}
}7. 实现Plugin<Project>定义自定义插件 [插件中里面有任务、有属性]
7.1. 直接在build.grale 中 自定义插件
7.2. 引入自定义 插件类
// 实现Plugin<Project>定义自定义插件
class FirstPlugin implements Plugin<Project> {
// 重写接口中apply方法
void apply(Project project){
// 为项目额外定义一个User类型的user属性
project.extensions.create("user", User)
// 调用task方法定义showName任务
project.task('showName') {
doLast{
println '用户名:' + project.user.name
}
}
// 调用tasks对象（TaskContainer）的create方法定义showPass任务
project.tasks.create('showPass') {
doLast {
println '密码:' + project.user.pass
}
}
}
}
class User {
String name = 'fkjava'
String pass = 'leegang'
}
// 引入FirstPlugin插件
apply plugin: FirstPlugin
// 为Project的user属性的name属性赋值
user.name = "在build.gradle自定义插件name"
// 引入org.fkjava.ItemPlugin插件
apply plugin: org.fkjava.ItemPlugin
// 为org.fkjava.ItemPlugin插件所扩展的项目属性赋值
item.name='疯狂Android讲义'
item.price = 108
item.discount = 0.75\buildSrc\src\main\groovy\org\fkjava\ItemPlugin.groovy
// 实现Plugin<Project>定义自定义插件
class FirstPlugin implements Plugin<Project> {
// 重写接口中apply方法
void apply(Project project){
// 为项目额外定义一个User类型的user属性
project.extensions.create("user", User)
// 调用task方法定义showName任务
project.task('showName') {
doLast{
println '用户名:' + project.user.name
}
}
// 调用tasks对象（TaskContainer）的create方法定义showPass任务
project.tasks.create('showPass') {
doLast {
println '密码:' + project.user.pass
}
}
}
}
class User {
String name = 'fkjava'
String pass = 'leegang'
}
// 引入FirstPlugin插件
apply plugin: FirstPlugin
// 为Project的user属性的name属性赋值
user.name = "在build.gradle自定义插件name"
// 引入org.fkjava.ItemPlugin插件
apply plugin: org.fkjava.ItemPlugin
// 为org.fkjava.ItemPlugin插件所扩展的项目属性赋值
item.name='疯狂Android讲义'
item.price = 108
item.discount = 0.75\buildSrc\src\main\groovy\org\fkjava\ItemPlugin.groovy
// 实现Plugin<Project>定义自定义插件
class FirstPlugin implements Plugin<Project> {
// 重写接口中apply方法
void apply(Project project){
// 为项目额外定义一个User类型的user属性
project.extensions.create("user", User)
// 调用task方法定义showName任务
project.task('showName') {
doLast{
println '用户名:' + project.user.name
}
}
// 调用tasks对象（TaskContainer）的create方法定义showPass任务
project.tasks.create('showPass') {
doLast {
println '密码:' + project.user.pass
}
}
}
}
class User {
String name = 'fkjava'
String pass = 'leegang'
}
// 引入FirstPlugin插件
apply plugin: FirstPlugin
// 为Project的user属性的name属性赋值
user.name = "在build.gradle自定义插件name"
// 引入org.fkjava.ItemPlugin插件
apply plugin: org.fkjava.ItemPlugin
// 为org.fkjava.ItemPlugin插件所扩展的项目属性赋值
item.name='疯狂Android讲义'
item.price = 108
item.discount = 0.75\buildSrc\src\main\groovy\org\fkjava\ItemPlugin.groovy
package org.fkjava;
import org.gradle.api.*
/**
* Description:<br>
* Copyright (C), 2001-2018, Yeeku.H.Lee<br>
* This program is protected by copyright laws.<br>
* Program Name:<br>
* Date:<br>
* @author Yeeku.H.Lee [email protected]<br>
* @version 1.0
*/
class ItemPlugin implements Plugin<Project> {
// 重写接口中apply方法
void apply(Project project){
// 为项目额外定义一个Item类型的item属性
project.extensions.create("item", Item)
// 调用task方法定义showInfo任务
project.task('showItem') {
doLast{
println '商品名:' + project.item.name
println '商品销售价：' + project.item.price * project.item.discount
}
}
}
}\buildSrc\src\main\groovy\org\fkjava\Item.groovy
class Item {
String name = 'unknown item'
double price = 0
double discount = 1.0
}运行代码：
/*
运行1： >gradle showName
> Task :showName
用户名:在build.gradle自定义插件name
*/
>运行2： gradle showPass
> Task :showPass
密码:leegang
> 运行3：gradle showItem
> Task :showItem
商品名:Android讲义
商品销售价：81.0