gradle相关api以及使用

1. Gradle项目，每一个Gradle都是一个独立的项目，最外层的项目是Root Project， 其他在此模块种的，都属于 Sub Project

2. Gradle 的Project相关的API

　　

// 可以在 .gradle中编写
this.getAllprojects()    // 获取所有的项目， 索引为0的为Root Project
this.getSubprojects()  // 获取所有的子项目
ex:
    this.getSubprojects().eachWithIndex { Project project, int index ->
         println "+----- project: ${project.name}"          
    }
　　
// 获取父项目的相关内容  -- > 需要在子项目中使用
def name = this.getParent().name
println "parent'name ${name}"
// 获取根目录下的项目相关内容
def rootName = this.getRootProject().name
println "root project' name ${rootName}"

 

// Project 详解
// .gradle  文件的编写
// 给子项目对应配置，原函数  project(String path, Close close)
project('子项目名称') {
      Project project -> 
          println project.name    
          // 给项目配置相关依赖
          apply plugin 'com.android.lib'
          group 'com.android'
          version '1.0.0'
          dependencies {
          
          }
}    

// 给所有项目增加配置
// 原函数 ： allprojects(Close close)
allprojects {
    group 'com.android'
    version '1.0.0'
}

// 给子工程添加配置，不包含当前工程
subprojects {
    // 引入一个文件
    if (project.plugins.hasPlugin('com.andriod')) {
        // 引入一个公用的gradle文件
        apply from : '../publisMaven.gradle'
    }
}

3. 属性相关的api

　　

def versionSdk = '1.8'
// ext 添加扩展属性，和def定义一样，使用时，this.extVersionSdk
// 可以用于多个项目中
ext {
   extVersionSdk = '1.8'
}
// 使用方式：
ex: 给所有子工程添加固定值
subprojects {
    ext {
        versionSdk = 1.8
    }
}
// ex2: 引用根项目中的ext,调用方式：this.versionSdk即可
ext {
    versionSdk = 1.8
}
// 最终方案：独立一个文件，管理相关常量
// ex3: 声明一个   common.gradle,内容如下：
ext {
     java = ["jdk" : 1.9, "spring": '1.0.0'],
     android = ["jdk": 1.8]
}
// 在根项目中，引用ext ，this.file -> 将引用本目录下的文件
apply from : this.file('common.gradle')
// 在子项目中引用方式
jdkVersion rootProject.ext.java.jdk // 即可

扩展属性的第二种方式：

// 声明一个gradle.properties文件
// 在这个文件中定义属性
gradle.properties
isLoadTest=false
// 在settings.gradle中设置,如果有这个属性，那么就引入Test模块，否则不引入Test模块
// 注意：在配置中，不要和方法名重复，不然会提示找不到对应的属性
if (hasProperty('isLoadTest') ? isLoadTest.toBoolean() : false) {
    include ':Test'
}

4. 文件路径问题

// 获取根目录的绝对路径
getRootDir().absolutePath
// 获取build构建成class项目，编译后的绝对路径
getBuildDir().absolutePath
// 获取项目所在目录的绝对路径
getProjectDir().absolutePath

5. buildscript的定义及使用

buildscript {
    ScriptHandler scriptHandler -> 
     
     // 配置仓库
     repositories {
        // 
        jcenter()

        mavenCentral()
        
        mavenLocal()
        // 私有的maven仓库
        maven{
            // 自定义名称
            name 'personal'
            // 仓库url
            url 'http://localhost:8888:'
            credentials {
                   username = 'admin'
                   password = 'admin'
            }
        }

        ivy{}
     }

     // 配置工程的插件依赖地址， 即： gradle对三方的依赖
     dependencies {
         classpath: ''
         classpath: ''
     }
}

6. dependencies 依赖

// 在根目录下，建立dependencies闭包
dependencies {
   // compile 编译，会打到包中
    // 依赖某个目录下的jar包
    compile fileTree(include: ['*.jar'], dir: 'libs')
    // 正常的依赖关系
    compile rootProject.ext.dependence.jdk
    // 依赖源码工程, 本项目中的工程
    compile project(rootProject.ext.dependence.jdk)
   // 排除某个依赖
   compile(rootProject.ext.dependence.jdk) {
       exclude module: 'support-v4'
       // 排除整个组
       exclude group: 'com.android.support'
       // false禁止依赖传递,默认值为false，A依赖B，B依赖C，那么A依赖C，不依赖，A不再依赖C
       transitive false 
   }
   // 只是参与编译，不进行打到包中
   provided()
}

7. task的定义

// 增加group，可以在idea工具中，右侧，统一管理
// task的定义1
task helloTask(group: "hello", description: 'hello task') {
     println 'hello Task'
}
// 通过TaskContainer 进行创建task的定义2
this.tasks.create(name: 'helloTask2') {
    setGroup('h2')
    setDescription('hello2')
    println 'hello Task2'
}

8. task中的doFirst和doLast

// doFirst, doFirst可以多次调用,执行时：执行阶段
// dofirst是为gradle中已经有的task之前执行，dolast是为gradle之后执行
task helloTask {
    doFirst {
       println 'dofirst'
    }
    doFirst {
       println 'dofirst2'
    }
}
// 还可以
helloTask.doFirst {
   println 'doFirst3'
}

// task依赖
task taskA {
   doLast{

   }
}

task taskB {
   doLast{

  }
}
// 建议使用这种，添加依赖
task taskC (dependsOn: [taskA, taskB]) {
     doLast {println 'AAAA'}
}

// 或者使用下面的方式进行调用
taskC.dependsOn(taskA, taskB)

// 追加符号，相当于doLast, 相当于给taskX增加一个doLast方法
task taskX << {
    println 'taskX'
}
// 指定task运行顺序
task taskD {
  println 'taskD'
}

// 在taskD执行完成后执行
task taskE {
    mustRunAfter taskD
}