关于gradle你应该知道的一些小事

前言

gradle的定义（来自*）

gradle是一个基于apache ant和apache maven概念的项目自动化建构工具。它使用一种基于groovy的特定领域语言来声明项目设置，而不是传统的xml。当前其支持的语言限于java、groovy和scala，计划未来将支持更多的语言。

通俗的理解：gradle是一种构建工具，我们可以用他来对多工程进行各种管理(依赖,打包,部署,发布,各种渠道的差异管理）；

有些时候，我们会有一些个性化的构建需求，比如我们引入了第三方库，或者我们想要在通用构建过程中做一些其他的事情，这时我们就要自己在系统默认构建规则上做一些修改。这时候我们就要自己向gradle”下命令“了，这时候我们就需要用gradle能听懂的话了，也就是groovy。

我们在开头处提到“gradle是一种构建工具”。实际上，当我们想要更灵活的构建过程时，gradle就成为了一个编程框架——我们可以通过编程让构建过程按我们的意愿进行。也就是说，当我们把gradle作为构建工具使用时，我们只需要掌握它的配置脚本的基本写法就ok了；而当我们需要对构建流程进行高度定制时，就务必要掌握groovy等相关知识了。

遭遇的问题

我们在实时多项目构建的时候经常遇到以下这些问题：

1、同时依赖了不同版本的某个库，编译时出现duplicate class错误；

2、gradle 不同版本api报错；

3、不会写gradle配置，看不懂gradle语法，不知道从何学起；

4、对编译过程中gradle的报错无从下手；

等等…

我们接下来将从实际项目出发一步一步来学习gradle的这些事，本文主旨在于学习gradle的思路，深度细节将会忽略；

揭开gradle的面纱

一、理解打包命令 gradle clean assembledebug/assemblerelease

以上这条命令可以分解为三个部分，gradle,clean, assembledebug;实际上就和我们执行脚本一样，gradle是执行器，而clean 和 assembledebug是入参， 在这里它们两个代表不同的task，就类似gradle task1 task2 这样。

二、什么是task？

在build.gradle写上

task task1 {
 println "===>task 1"
}
task task2 {
 println "===>task 2"
}

这样就定义了两个task;当我们执行gradle task1 task2 -q的时候（-q是设置日志级别），理论上会看到日志输出：

===>task 1
===>task 2

task的关系有dependson,mustrunafter等等，由于项目中用的比较少这里先跳过这部分；

这里我们简单讲一下闭包的概念：

闭包在groovy中是一个处于代码上下文中的开放的，匿名代码块。它可以访问到其外部的变量或方法，
更详细的请自行google

然而，当我们在项目里执行gradle task1 task2 -q的时候，我们发现输出是这样的：

 seeyouclient git:(seeyouclient-dev) ✗ gradle task1 task2 -q
dopackage value:false
configuration 'compile' in project ':app' is deprecated. use 'implementation' instead.
==============anna apply start==================
configuration do:
include
**  onclick 
**  onitemclick 
**  oncheckedchanged 
**  onitemselected 
**  onswitchbuttoncheck 
**  onitemlongclick 
**  onlongclick 
**  onpullrefresh 
**  onrefresh 
configuration do:
exclude
org/conscrypt/ 
configuration do:
exceptions
java/lang/exception 
java/lang/nullpointerexception 
configuration do:
switch
custom 
need inject=false
==============anna apply end==================
configuration 'provided' in project ':app' is deprecated. use 'compileonly' instead.
configuration 'debugcompile' in project ':app' is deprecated. use 'debugimplementation' instead.
===>task 1
===>task 2
dexknife: processing variant
dexknife: processsplitdex true
dexknife: processing task
----------------------tinker build warning ------------------------------------
tinker auto operation:
excluding annotation processor and source template from app packaging. enable dx jumbomode to reduce package size.
enable dx jumbomode to reduce package size.
disable predexlibraries to prevent classdefnotfoundexception when your app is booting.
disable archive dex mode so far for keeping dex apply.
tinker will change your build configs:
we will add tinker_id=117 in your build output manifest file build/intermediates/manifests/full/*
if minifyenabled is true
you will find the gen proguard rule file at build/intermediates/tinker_intermediates/tinker_proguard.pro
and we will help you to put it in the proguardfiles.
if multidexenabled is true
you will find the gen multidexkeepproguard file at build/intermediates/tinker_intermediates/tinker_multidexkeep.pro
and we will help you to put it in the multidexkeepproguardfile.
if applyresourcemapping file is exist
we will build app apk with resource r.txt file
if resources.arsc has changed, you should use applyresource mode to build the new apk!
-----------------------------------------------------------------
task spend time:

这是为什么呢？原因是gradle具有自己的生命周期:

初始化阶段：负责判断有多少个projects参与构建:
 先执行settings.gradle
配置阶段：负责对初始化阶段创建的projects完成配置:
 比如添加task，修改task的行为,闭包的内容会被执行，执行build.gradle的内容；
执行阶段：根据配置阶段的配置执行任务:
 执行task对应的内容，如dolast,dofirst之类的

因此gradle task1 task2 -q的输出日志就可以理解了，其实按照task1和task2的写法，执行gradle task1 task2 -q和gradle -q实际上效果是一样的。

三、gradle clean assmebledebug到底做了什么？（源码追踪和依赖分析出编译流程）

1、打开gradle-4.5.1/bin/gradle文件可以看到执行了代码：

 eval set -- $default_jvm_opts $java_opts $gradle_opts "\"-dorg.gradle.appname=$app_base_name\"" -classpath "\"$classpath\"" org.gradle.launcher.gradlemain "$app_args"

 最终调用exec "$javacmd" "$@"来执行；所以入口就是：org.gradle.launcher.gradlemain

 具体细节可以参照：https://blog.csdn.net/yanbober/article/details/60584621

2，最终会调用defaultgradlelauncher里，我们可以很明确的看到它的生命周期：

这边最需要注意的时候，当我们只执行gradle -q这样的时候，实际上每一次都会执行到taskgraph的阶段；也就是所有的tasks都已经梳理完成；

public class defaultgradlelauncher implements gradlelauncher {
 //（这里是4.5.1的版本，生命周期更细致化）
 private enum stage {
  load, loadbuild, configure, taskgraph, build, finished
 }
 //2.14.1的版本则是： 
 private enum stage {
  load, configure, build
 }
//核心方法
private void dobuildstages(stage upto) {
  try {
   loadsettings();
   if (upto == stage.load) {
    return;
   }
   configurebuild();
   if (upto == stage.configure) {
    return;
   }
   constructtaskgraph();
   if (upto == stage.taskgraph) {
    return;
   }
   runtasks();
   finishbuild();
  } catch (throwable t) {
   throwable failure = exceptionanalyser.transform(t);
   finishbuild(new buildresult(upto.name(), gradle, failure));
   throw new reportedexception(failure);
  }
 }
 
 //调用时机
  @override
 public settingsinternal getloadedsettings() {
  dobuildstages(stage.load);
  return settings;
 }
 @override
 public gradleinternal getconfiguredbuild() {
  dobuildstages(stage.configure);
  return gradle;
 }
 public gradleinternal executetasks() {
  dobuildstages(stage.build);
  return gradle;
 }

四、知道编译流程后有什么用呢？

1、我们经常在app/build.gradle看到这样的代码：

project.afterevaluate {...}
android.applicationvariants.all {...}
gradle.addlistener(new tasklistener())
apply from '../mvn.gradle'
...

这里我们介绍几个概念：

project

对应gradle源码的project.java(按住control点击project会自动跳转)，里边提供一些对外的方法，如afterevalute，beforeevalue； 在理解编译流程后，才能灵活的使用这些api;

android

对应gradle插件的appextension.java文件，提供了一些对外的参数和方法，我们可以使用android.xxx来访问app/build.gradle里的任意参数和方法；

gradle

对应的gradle源码里的gradle.java对象，也是提供了一系列的方法给外部使用；

那么接下来假设我们有这样一个需求：找到一个叫cleanbuildcache的task,找到之后添加一个action，打印一行字； 要实现这个需求，首先我们如何遍历这个app的所有task:

有很多种写法：

gradle.gettaskgraph().whenready {
 project.tasks.each {
  task->
   println "taskname:"+task.getname()
 }
}
project.afterevaluate {
 project.tasks.each {
  task->
   println "taskname:"+task.getname()
 }
}

执行gradle -q 感受一下。

接下看看如何添加action

project.afterevaluate {
 project.tasks.each {
  task->
   // println "taskname:"+task.getname()
   if(task.getname().equals("cleanbuildcache")){
    println "find cleanbuildcache!!!!!!"
    list<action<? super task>> list = new arraylist<>()
    list.add(new action<task>() {
     @override
     void execute(task task1) {
      println 'excute cleanbuildcache action !!!!!!'
     }
    })
    task.setactions(list)
   }
 }
}

执行gradle cleanbuildcache感受一下，

你会看到‘excute cleanbuildcache action !!!!!!'的打印字样；

那为什么一定要放在afterevaluate之后呢，因为这样tasksgrap完成才有那么多task让你遍历，这就是理解生命周期所带来的好处。

2、现在回顾我们之前主app写的代码：

processproductdebugmanifest；

project.tasks.each {
  task->
   if(task.getname().equals("processzrotestdebugmanifest")){
    println '!!!!!find processzrotestdebugmanifest task:'
    task.outputs.files.each {
     file ->
      println 'file.getabsolutepath():'+ file.getabsolutepath()
      //file.getabsolutepath():/users/mu/meiyoucode/periodproject/seeyouclient/app/build/intermediates/manifests/instant-run/zrotest/debug
      //file.getabsolutepath():/users/mu/meiyoucode/periodproject/seeyouclient/app/build/intermediates/manifests/full/zrotest/debug
      //file.getabsolutepath():/users/mu/meiyoucode/periodproject/seeyouclient/app/build/outputs/logs/manifest-merger-zrotest-debug-report.txt
    }
    task.dolast {
     println '!!!!!excute processzrotestdebugmanifest task'
     def dated = new date().format("mmdd hh:mm")
     def manifestfile = "${builddir}/intermediates/manifests/full/zrotest/debug/androidmanifest.xml"
     def updatedcontent = new file(manifestfile).gettext('utf-8')
       .replaceall("my_app_pkgname", "${my_app_pkgname}")
       .replaceall("my_jpush_appkey", "${jpush_appkey}")
       .replaceall("my_huawei_appkey", "${huawei_appkey}")
       .replaceall("my_meizu_appkey", "${meizu_appkey}")
       .replaceall("my_meizu_appid", "${meizu_appid}")
     // .replaceall("my_xiaomi_appkey", "${xiaomi_appkey}")
     // .replaceall("my_xiaomi_appid", "${xiaomi_appid}")
     //.replaceall("cn.jpush.android.service.pluginxiaomiplatformsreceiver","com.meiyou.message.mipush.xiaomireceiver")
       .replaceall("my_apk_version", "${archivesbasename}-${dated}")
     new file(manifestfile).write(updatedcontent, 'utf-8')
    }
   }
 }

实际上也可以写成这样(但是这样因为变种不确定，写死成zrotest/debug,所以还是用上面的方法比较好，直接替换所有的变种)：

project.tasks.each {
  task->
   if(task.getname().equals("processzrotestdebugmanifest")){
    println '!!!!!find processzrotestdebugmanifest task:'+task.outputs.files.each {
     file ->
      file.getabsolutepath();
    }
    task.dolast {
     println '!!!!!excute processzrotestdebugmanifest task'
     def dated = new date().format("mmdd hh:mm")
     def manifestfile = "${builddir}/intermediates/manifests/full/zrotest/debug/androidmanifest.xml"
     def updatedcontent = new file(manifestfile).gettext('utf-8')
       .replaceall("my_app_pkgname", "${my_app_pkgname}")
       .replaceall("my_jpush_appkey", "${jpush_appkey}")
       .replaceall("my_huawei_appkey", "${huawei_appkey}")
       .replaceall("my_meizu_appkey", "${meizu_appkey}")
       .replaceall("my_meizu_appid", "${meizu_appid}")
     // .replaceall("my_xiaomi_appkey", "${xiaomi_appkey}")
     // .replaceall("my_xiaomi_appid", "${xiaomi_appid}")
     //.replaceall("cn.jpush.android.service.pluginxiaomiplatformsreceiver","com.meiyou.message.mipush.xiaomireceiver")
       .replaceall("my_apk_version", "${archivesbasename}-${dated}")
     new file(manifestfile).write(updatedcontent, 'utf-8')
    }
   }
 }

3、如何知道某个task干了什么呢，比如processzrotestdebugmanifest或者clean：

这些是com.android.tools.build到源码里寻找或者直接compile ‘com.android.tools.build:gradle:3.0.1'直接从依赖库里看源码； 或者直接下载源码(大概30g左右)：

$ mkdir gradle_2.3.0
$ cd gradle_2.3.0
$ repo init -u https://android.googlesource.com/platform/manifest -b gradle_2.3.0
$ repo sync

大部分tasks都在com.android.build.gradle.tasks文件夹下，比如:manifestprocessortask和cleanbuildcache

具体可以:https://fucknmb.com/2017/06/01/android-gradle-plugin源码阅读与编译/

4、如何查找某个task的依赖呢，比如我想知道assmeblezrotestdebug执行后最终执行了哪些task;

1、编译后打印；

gradle.addlistener(new tasklistener())
class tasklistener implements buildlistener,taskexecutionlistener {
 private list<string> tasks = new arraylist<>();
 @override
 void buildstarted(gradle gradle) {
 }
 @override
 void settingsevaluated(settings settings) {
 }
 @override
 void projectsloaded(gradle gradle) {
 }
 @override
 void projectsevaluated(gradle gradle) {
 }
 @override
 void buildfinished(buildresult result) {
  stringbuilder stringbuilder = new stringbuilder();
  for(string taskname:tasks){
   stringbuilder.append(taskname).append("\n")
  }
  println("任务列表：\n"+stringbuilder.tostring())
 }
 @override
 void beforeexecute(task task) {
 }
 @override
 void afterexecute(task task, taskstate state) {
  //println("===>task:"+task.getname())
  tasks.add(task.getname())
 }
}

2、不用编译直接打印；

void printtaskdependency(task task, string divider) {
 divider += "-------"
 task.gettaskdependencies().getdependencies(task).any() {
  println(divider+ it.getpath())
  if (it.getpath().contains(":app")) {
   printtaskdependency(it,divider)
  }
 }
}
gradle.gettaskgraph().whenready {
 project.tasks.all {
  //println("!!!!!!!!!! it:"+it.getname()+"==>it.getpath:"+it.getpath())
  if (it.getpath().equals(":app:assemblezrotestdebug")) {
   //println(it.getpath())
   printtaskdependency(it,"")
  }
 }
}

5、常用技能

1、gradle :app:dependencies > 1.txt 分析整个app的aar依赖

可以用于排查依赖库异常的问题；

请注意！：对工程依赖无效；

2、productflavors和buildtype概念，组合成变种 如：

productflavors {
 branchone {
  applicationid "com.example.branchone"
  buildconfigfield "string", "config_endpoint", "http://branchone.com/android"
 }
 branchtwo {
  applicationid "com.example.branchtwo"
  buildconfigfield "string", "config_endpoint", "http://branchtwo.org"
 }
}
dependencies {
 compile 'com.android.support:support-v4:22.2.0'
 branchonecompile 'com.android.support:appcompat-v7:22.2.0'//只为branchone添加这个依赖
}

3、排除依赖和强制使用某个版本和强制排除某个库：

configurations.all {
  resolutionstrategy {
//   force 'org.javassist:javassist:3.18.2-ga'
   // don't cache changing modules at all
   cachechangingmodulesfor 0, 'seconds'
//   //强制模块使用指定版本号(防止其他模块使用、跟主工程不匹配的版本：
   forcedmodules = [
     "com.meiyou:peroid.base:${period_base_version}",
     'org.javassist:javassist:3.18.2-ga'//"org.javassist:javassist:3.20.0-ga"//
     , 'com.google.guava:guava:18.0'//'com.google.guava:guava:19.0-rc2'//
   ]
   exclude group: 'com.squareup.okhttp3'
   exclude group: 'com.google.code.findbugs', module: 'annotations'
  }
 }

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。