前语

成为一名优秀的Android开发，需求一份完备的知识系统，在这儿，让咱们一同生长为自己所想的那样~。

一、Gradle 插件概述

自界说 Gradle 插件的实质便是把逻辑独立的代码进行抽取和封装，p 9 = q 9 D & r ?以便于咱们更高效地经过插件依靠这一办法进行功用复用。

而在 Android 下的 gradle 插件共分为 两大类，如K + F v 2 ( $ x下所示：

  • 1、脚本插件：同普通的 gradle 脚本编写办法相同，经过 apply from: ‘JsonChao.gradle’ 引证。
  • 2、目标U r w [ z $插件：经过插件全途径类名或 id 引证，它首要有 三种编写办法，如下所示：

    • 1）、在当时构建脚本下直接编写。
    • 2）、在 buildSrc 目录下编写。
    • 3）、在彻底独立的项目中编写。

下面，咱们就先来看看怎么编写一个脚本插件。

二、脚本插件

同普通的 gradle 脚本编写办法相同，咱们既能够写在 build.gradle 里边，也能* { [ 2够自己新建一个 gradle 脚本文件进行编写。

c4 | N (lassPluginDemoimplement7 5 FsPlugin<Project>{

@) : ( J w : ` 6 dOverride
voidapply(Projecttarget){
println'Helloauthor!'
}
}

然后，在需求运用的 gradle 脚本中经过 apply plugin： pluginName 的办法即可引证对应的插件。

applyplugin:PluginDemo

三、运用 buildSrc 默许插件目录

在完结几个自界说 Gradle 插件之后，我发现 在 buildSrc 目录下编写插件6 3 K ] I 3 Q E的办法是开发功率f Y ) G ;最高的，首先，buildSrc 是默许的插件目录* V $，其次，在 buildSrc 目录下与独立工程的插件工程相同，也能够发布插件，这儿只是只需对某些装备做一些调整即可，下面，咱们就来看看g L G l U F $怎么来创立一个自界说 G/ * = i r – | 4 Fradle 插件。

1、创立一个能运转起来的空 Plugin

首先需求了解的是，buildSrc 目录是 gradle 默许的构建目录之一，该目录下的代码会在构建时自动地进行编译打包，然后它会被增加到 buildScript 中的 classpath 下，所以不需求任何额定的装备，就能够直接被其他模块中的 gradle 脚本引证。此外，# Y [ I + 2关于 buildSrc，咱们还需求注意以下 两点J % | 5 8：

  • 1^ # e）、H p @ D W NbuildSrc 的履行时机不只早于任何⼀个 project（build.gradle）! @ / n u u C，而且也早于 settings.gradle。
  • 2）、settings.gradle 中假如装备了 ‘:b& ? H ! $uildSrc’e $ E C g 2 w t ，buildSrc ⽬录就会被当做是子 Project ， 因会它会被履行两遍。所以在 settings.gradleU – 5 e Z 里边应该删掉 ‘:buildc A L (Src’ 的装备。

插件 moudle 创立三部曲

1）、新建一个 module，并~ K A e T将其命名为 buildSrc。这样，Gradle 默许会} 9 P s C D F将其辨认会工程的插件目录。

2）、src 目录下删去仅保留一个空的 main 目录，并在 main 目录下新建 1 个 groovy 目录与 1 个 resources 目录。

3）、将 buildSrc 中的 bu t &ild.gru S : z 8 f Aadle 中的一切装备删去，并装备 groovy、resources 为源码目录与相关依靠即可。装备代码如下所示：

applyplugin:'groovy'

repositories{
google()
mavenCentral()
jcenter()
}

dependencies{
//GroovS } u 6yDSL
imf + Y p G r vplementationlocalGroovy()
//GradleDSL
implementationb a P D w t * = ~gradleApi()7 e D E

//AndroidDSL
impl? O f [ementation'com.android.tools.build:gradle:3.6.2'

//ASMV7.1
implementationgroup:'org.ow2.asm',name:'asm',version:'7.1'
implementationgro0 M = z Oup:'org.ow2.asm',nX C i # ? U Fame:'asm-commons',version:'7.1'

}

sourceSets{
main{
groovy{
srcDir'src/main/groovy'
}

resources{
srcDir'src/main/resources'
}
}
}

插件创立二部曲

1）、首先，在我的 main 目录下创立一个递归文件夹 “com.json.chao.study”，里$ 1 e @边直接新建一个名为 CustomGradlePlugin 的普通文件。然后，在文件中写入 ‘cl& e # j O m 2ass CustomGrQ M ; L 0 8 [adlePlugin’ ，这时 CustomGradlePlugin 会被自动辨认为类，接着将其完成 Plugin 接口，其间的 apply 办法便是插件被引进时要履行的办法，这样，自界说插件类就根本完结了，CustomGradlePlugin 类的代码如下所示：

/**
*自界说插件
*/
classCustomGradlePluginimplej : [ D _ v H 6mentsPlugin&lz | &t;Project&@ o I + ^ } ) 3gt;{

/**
*插件被引进时要履行的办法
*@parampV | F n U ] a sroject引进当时插件的project
*/
@Override
voidapply(Projectproject){
println f g ."Helloplugin..."+project.name
}
}

2）、接着，在 resources 目录下创立一个 META-INF.grX $ N u # v }adle-plugins 的递归目录，里边新建一个 “com.json.ch7 d 5 m B P oao.study.properties” 文件，其间 ‘.properties’ 前面的姓名即为 自界说插件的姓名，在该文件中，咱们需求标识该插件对应的插件完成类，代码如下所示：

implementation-class=com.json9 Y h ^ - j 0 e.chao.study.CustomGradlePlugin

这样，一个最简单V 5 6的自界说插件就完结了。接着，咱们直接在 app moudle 下的 bu/ f O w v Tild.gradle 文件中运用 H x R ` / _ D 2‘apply plugin: ‘com.json.chao.study’ 引进咱们界说好的插件然后同步工程即可看到如下输出：

...
>ConfigureprojectO Q w:app
Helloplugin...app
...

能够看到，经过 id 引证的办法，咱们能够隐藏类名等细节，使得插件的引证变得愈加容易。

2、运用自界说 Extension 与 Task

1、自界说 Extension

在 深度探究 Gradle 自动化构建技能（三、Gradle 中心解密） 一文中咱们解说了怎么创立一个版别信息办理的 task，这儿咱们就能够直接将它接入到 gradle 的构建流程之中。

为了能让 App 传入相关的版别信息} D [ d O F 8 _ O和生成的版别信息文件途径，咱们需求一个用于装备版I 0 ) S别信息的 E[ 0 cxtensi1 ; ? ; L b 0 on，其实质便是一个实体类，如下所示：

/*
*Description:负责Release版别办理的扩展特点区域
*
*@autho( T $ irquchC t ~ - o Q U tao
*/
classReleaseInfoExtension{

StringversionName;
StringversionCode;
StringversionInfo;
StringfileName;
}

然后，在咱们的 CuA z ? a . a x ) ]stoE u q 4 D p F ]mGradl[ 3 !ePlugin 的? Z X 9 e apply 办法中参加下面H % U D 1代码去创立用于设置版别信息的扩展特点，如下所& U A , * X 1 :示：

//创立用于设置版别信息的扩展特点
project.extensions.create("releaseInfo",R[ g  8 ?eleaseInfoExtension.class)

在 project.extensions.create 办法的F N S g内部其实质是 经过 project.extensions.create() 办法来获取在 releaseInfo 闭O f k L s ~ X ~ ^包中界说e j Q ~ F 2 q V 1的内容并经过反射将闭包的内容转化成一个 ReleaseInfoExtension 目标。

最终，) Z 2 v h咱们就能够在 app moudle 的 build.gradle 脚本中运用 releaseInfo 去装备扩展特点，代码如下所示：

releaseInfo{
versionCode="1"
versiZ S gonName="1.0.0"
versionInfo="第一个版别~ ? l"
fileName="releases.xml"
}

2、自界说 Task

运用自界说扩展特点 Extension 只是是为了让运用插件者有) r l { ; : J U 装备插件的能力。而插件还得凭借自界说 Task 来完成相应的功用，这儿咱们需求创立一个更新版别信息的 Task，咱们将其命名为 ReleaseInfoTask，其详细完成代码如下所示：

/**
*更新版别信息的Task
*/
classReleasL @ D ) D 8 l $eInfoTaskextendsDefaultTask{

ReleaseInfoTask(){
//1、在结构器中装备了该Task对应的Taskgroup，即Task组，并为其增加上了对应的描绘信息。
group='version_manager'
description='releaseinfoupdate'
}

//2、在gradle履# B 0 + B行阶段履行
@TaskAction
voiddoAction(){
updateVersionInfo();
}

private7 N s L bvoidupdateVersionInfo(){
//3、从realeaseInfoExtension特点中获取相应的版别信息
defversionCodeMsg=proq U X zject.extensions.releaseInfo.versionW 9 p h X 6 &Code;
defversionNameMsg=project.extensions.releaseInfo.versionName;
defversionInf8 v O ^ j w p 5 6oMsg=p8 % , 8 4 xroject.extensions.releaseInfo.versionInfo;
deffileNam] ~ `e=project.extensions.releaseInfo.fileName;
deffile=project.file(fileName)
//4、将实体目标写入到xml文件中
defsw=newStringWriter()
defxmlBuilder=newMarkupBuilder(sw)
if(file.text!=nuW 4 &ll&&file.textQ : ` P U i.siz_ w  t / J X I we()<=0){
//没有内容
xmlBuilder.releases{
release{
versionCode(versionCodeMsg)
versionName(vR k 7 uerL 0 u xsionNameMsg)d 0 g _
versionInfo(versionInfoMsg)
}
}
//直接写入
file.withWriter{writer->writer.append(sw.toString())
}
}else{
//已有其它版别内容
xmlBuilder.release{L d 0 b t d W D 
versionCode(versionCodeMsg)
versionName(versie $ W 8 - J GonNameMsg)
versionInfo(versionInfoMsg)
}
//刺进到最终一行前面
deflines=file.readLines()
deflengths=lines.size()-1
file.withWriter{wrn p witer->
lines.eachW} _ o 5 [ U sithIndex{line,index->
if(index!=lengths){
wri[ ; x 2 [ter.app5 F | c + Q } S qend(line+'rn')
}elseif(index==lengths){
writer.appendY v 1 ` {('rrn'+sw.toString()+'rn')
writer.appen@ o 3 : vd(lines.get(t= D ~ x 8 7 q @lengths))
}
}
}
}
}
}

首先，在注释1处，咱们 在结构器中装] T 6备了该 Task 对应的 Task group，即 Task 组，并为其增加上了对应的描绘信息。接着，在注释2处，咱们 运用了 @TaskAction 注解标3 e 9 j 9 y示了 doAction 办法，这样它就会在 gradle 履行阶段履行。在注释3处，咱们 运用了 project.extensions.releaseInfo.xxx 一系列 API 从 reale@ 7 z w W laseIT q ( hnfo Extens1 ] K F C S ]ion 特点中了获取相应的版别信息。最终，注释! l 9 n4处，便是用来 完成该 task 的中心功用，行将实体目标写入到 xml 文件中。

能够看到，一般的插件 task 都会遵循前三个进程，最终_ – j Y / ; W t一个进程便是用来完成插件的中心功用。

当然，最终别忘了在咱们的 CustomGradle0 – O / ;Plugin 的 apply 办法中参加下面代码去创立 ReleaseInfoTask 实例，代码如下所示：

//创立用于更新p ? c N w版别信息的task
project.tasks.create("releaseInfoTask",ReleaseInfoTask.cl6 ( ; jass)

四、变体（Variants）的效果

要理解 Varian` $ $ D F . = N Dts 的效果，就必须先了解 flavor、dimensiow j c z X Z 9 } Vn 与 var& c ? Miant 这三者之间的关系。在 android gradle plugin V3.x 之后，每个 flavorx v N ] { k 6 q X 必须对应一个 dimension，能够理解为 flavor 的分m U y V 4 W s @组，然后不同 dimension 里的 flavor 会组合成一个 variant。示例代码如下所示：

flavorDimensions"size","color"

productFlavors{
JsonChao{
dimension"size"
}
small{
dimension"F V c { z L gsize"
}
blue{
dimenj ( D ^ l 6 5 Y Tsion"color"
}1 s  p Z / x
r, s 9 9 ped{
dimension"color"
}
}R & i

在 Android 对 GradlK ~ c % Be 插件的扩展支撑之中，其间最常用的便是 运用变体（Variants）来对构建进程中的各个默许的 tasr z ( _ % A 0 Nk 进行 hook。关于 Variants 共有 三种类型，如下所示U % : 2 , I：

  • 1）、applica! Y y s z x AtionVariants：只适用于 app plugin。
  • 2）、libraryVariants：只适用于 library plugin。
  • 3）、testVariants：在 app plugin 与 libarary plugin 中都适用。

1、运用 applicationVariants

为了解说 applicationVariants 的效果，咱们需求先在 app moudle 的 build.gradle 文件中装备几个 flavor，代码如下所示：

pr A b  |oductFh c ) b J c , V mlavors{
douyin3 7 E ^ ) y O 5{}
weixin{}
google{}
}

1、运用 applicationVariants.all 在装备阶段之后去获取一切 varianf o W s k 2t 的 name 与 basI s E r s e h X XeName

然后，咱们能够 运用 applicationVariants.all 在装备阶段之后去获取一切 variant 的 name 与 baseName。代码如下所示：

this.afterEvaluate{
this.android.appli, 7 d YcationVariants.all{variant->
defname=variant.name
defbaseName=variant.baseName
println"name:$name,b] C h 6 uaseNM ! R g [ ] Yame:$baseName"
}
}

最终，履行 gradle clean task，其输出信息如下所示：

>Configureproject:app
name:dou! ] L 4 RyinDebug,baseName:douyin-debug
name:_ P w f k 8douyinRelease,b- c ^ + s ta[ d I 4 w $seName:do7  ) B c ; V t )uyin-releasej 3 ? d - g l R J
name:weixinDebug,baseName:weixin-debug
name:weixinRelease,baseName:weixin-release
name:googleDebug,baseName:google-debug
name:googleRelease,baseName:google-release

能够看到，name 与 baseName 的X 6 Q差异：baiduDebug 与 baidu-debug 。

2、运用 applicationVariants.all 在装备阶段之后去修正输出的 APK 称号

this.afterEvaluate{
this.8 V i a [ n p $android.applicationVariants.all{variant->
variant.outp] + i x o 6 {uts.each{
//因为咱们当时的变体是application类型的，所以
/_ e _ _ v/这F I @ ~ n - `个output便是咱们APK文件的输出途径，咱们
//能够经过重命名这个文件来修正咱们最终输出的APK文件
outputFileName="app-${variant.baseName}-${variant.versionName}.apk"
printlnou[ 6 otputFileName
}
}
}

履行 gradle clean task，其输出信息如下所示：

>Confi- - R ^ r ogureproject:app
app-debug-1.0.apk
app-releas~ ! M l R s + ,e-1.0.apk

3、对 applicationVariants 中的 Task 进行 Hook

咱们能够在 android.applicationVariants.all 的闭包中经过 variant.task 来& L O 5 G |获取相应的 Task。代码如下所示：

this.afterEvaluate{
this.android.applicationVariants.all{variant->
deftask=varii U Y P i - ~ = 6ant.checkManifest
priU k ; k 3 P {ntlf & z ; ^ j T nntask.name
}
}

然后，履行 gradle clean task，其输出信息如下所示：

checkDebugManifesT / ` T Vt
checkReleaseManifest

已然能够获取到变体中的 Task，咱们就能够根据不同的 Task 类型来做特殊处理。例如，咱们能够运用 variants 去处理插件化开发中的痛点：编写一个对插件化项目中的各个插件自动更新的脚本，其间心代码如下所示：

this.afterEvaluate{
this.android.applicationVariants.all{variant->
//checkManifest这个Task在Task容器中
//靠前的方位，咱们能够在这儿预先更新插件。
defcheckTask=variaX v p . +nt.checkManifeu o H d F K Ist
checkTask.doFirst{
defbt=variant.buildType.name
if(bt=='qa'||bt=='preview'
||bt=='release'){
update_plugin# t n y(bt)
}
}
}
}

至于 uN T 9 f b D kpdate_plugin 的完成，首要便是一些插件安全校验与下载的逻! X $ A U辑，这部分其实跟 Gradle 没有什么联络，假如有需求，能够在 Awesome-WC a `anAndroid 项目下查看。

五、Transform

众所周知，Google 官方在 Android Gradle V1.5.0 版别今后提4 I , /供了 Transfrom API, 允许第三方 Plugin 在打包成 .dex 文件之前的( n * z K a 2 a –编译进程中操作 .class 文件，咱们需求做的便是完成 Transfol X , a ) _rm 来对 .class 文件遍历以拿到一切办法，修正完结后再对原文件进行替换即6 o D i P 7 R可。

总的来说，Gradle Transform 的功用便是把输入的 .class 文件转化为目t g . 9 [标字节码文件。

下面，咱们来了解一下 Transform 的两个基础概念。

1、TransformInput

TransformInput 可认为是一切输入文件的一个笼统，它首要包括两个部分，如下所示：

  • 1）、Dir1 a _ectoryInput 调集：表明以源码办法参– : l i ~ i w #与项目编译的一切目录结构与其E W N 4 _ 8目录下的源码文件。
  • 2）、JarInput 调集：表明以 jar 包办法参与项目编译的一切本地 jar 包和长途 jar 包。需求注意的是，l – ^ A ^ Y @ c这个 jar 所指也包括 aar。

2、Transfor! 0 Q L :mOutputProvider

表明m 2 X ^ X C ^ Transform 的输出，运用它咱们能够 获取输出途径等信息。

3、完成 Transform

1、首先，装备 Android DSL 相关的依靠：

//因为buildSrc的履行时机要早于任何一个project，因此需求⾃⼰增加库房
repositories{
google()
jceI = c r J P Q Onter()
}

dependencies{
//AndroidDSL
implementation'com.android.tools.build:gradle:3.6.2'
}

2、然后，承继 com.android.build.api.transform.Transform ，创立⼀个 Transfor: xm 的子类：

其创立进程能够细分为五步，如下所示：

  • 1）、重写 getName 办法：回来对应的 Task 称号。
  • 2）、重写 getInputTypes 办法：确认对那些类型的F n 9 5 , G * 1 g成果进行转化。
  • 3）、重写 getScopes 办法：指定插件的适用规模。
  • 4）、重写 isIncremental 办法：表明是否支撑增量更新。
  • 5）、重写 transform 办法：进行详细的u r D Y 1 T O转化进程。

下面，咱们来别离来进行! B . W U详细解说。

1、重写! V q getName 办法：回来对应的 Task 称号

每一个 Transform 都有一个c t z C ) r k与之对应的 Transform task，这儿便是回来的 task name。它会呈现在 app/b% 9 T H ` e Puild/intermediates/transforms 目录下。其代码如下所示：

/**
*每一个Transform都有一个与之对应的Transformtask，
*这儿Z { ~ v Q n . 2便是回来的taskname。它会呈现在
*app/build/intermediates/transfor~ u C = @ + . -ms目录下
*
*@returnTransformName
*/
@Override
StringgetName(){
return"MyCustomTransL ` h e a * n *form"
}

2、重写 getInpu% ! $tTypes 办法：确J r Y认对那些类型的成果进行转化

getInpu1 = JtTypes 办法用于确认咱们需求对哪些类型的成果进行转化：如字节码、资源⽂件等等。现在 ContentType 有六种枚举类型，通常咱们运用比较频频的有前两种% F o，如下所示：

  • 1} a h、CONTENT_CLASS：表明需求处理 jz H } { x #ava 的 class 文件。
  • 2、CONTENT_JARS：表明需求处理 java 的 class 与 资源文件。
  • 3、CONTENT_RESOURCES：表明需求处理 javr L b M c ? ` A Ta 的资源文件。
  • 4、CONTENT_NATIVE_LIBS：表明需求处理 native 库的代码。
  • 5n q J _、CONTENT_DEX：表明需求处理 DEX 文件。
  • 6、CONTENT_DEX_WITH_RESOURCES：表明需求处理 DEX 与 java 的资源文件。

因为咱们需求修正的是字节码，所以直接回来 TransformManager.CONTENT_CLASS 即可，代码如下所示：

/**
*需求处理的数据类型，现在ContentType
*有六种枚举类型，通常咱$ C | q ^ = [们运用4 ^ w比较频频的有前两种：
*1、CONTENT_CLASS：表明需b ^ D s |求处理java的class文件。
*2、= u # + 3 D % ! NCONTP p ? 5 ( i 9 * BENT_JARS：表明需求处理java的class与t B f ! S h资源文件。
*3、CONTENT_RESOURCES：表明需求处理java的资源文件。
*4、CONTENTe s v : m b _ I /_NATIVE_LIBS：表明需求处S G 3 ;理native库的代码。
*5、CONTENT_DEX：表明需求处理DEX文件。
*6、CONTENT_DEX_WITH_RESOURCES：表明需求处理DEX与java的资源文件。
*
*@return
*/
@OvG d ] T  ; 2 erride
Set<QualifiedContent.ContentType>getInputTypes(){
//用于确认咱们需求对哪些类型的成果进行转化：如字节码、资源⽂件等等。
//returnTransformt m r Z -Manager.RESOURCES
returnTransformManager.CONTENT_CLASS
}

3、重写 getScoz } D d 2 * Apes 办法：指定插件的适用规模

getScopes 办法则v M t M . ] ! I是用于确认插件的适用规模：现在 Scope 有 五种根本类型，如下所示：

  • 1、PROJECT：只要项目内容。
  • 2、SUB_PROJECTS：只要子项目。
  • 3、EXTERNAL_LIBRARIES：只要外部库，
  • 4、TESTED_CODE：由当时变# 1 a & ~ 8体（包括依靠项）} | T v )所测验的代码。
  • 5、PROVIDED_ONLY：只提供本地或长途依靠项。

此外，还有一些复合类型，_ M . q [ 6它们是都是由m W w 4 M这五种根本类型组成，以完成灵活确认自界说插件的规模，这儿通常是指定整个 project，也能够指定其它规模，其代码如下所: o U L示：

/**
*表明Transforf C c j Bm要操作的内容规模，现在Scope有五种根本类型：
*1、PROJECT只要项V # d ( x目内容
*2、SUB_PROJECTS只要子项目
*3、EXTERNAL_LIBRARIES只要外部库
*4、TESTED_CODE由当时变体（包括依靠项）所测验的代码# { z  S { } V E
*5、PROVIDED_ONLY只提供本地或长途依靠项
*SCOPE_FULL_PROJECT是一个Scope调集，包括Scope.PROJECT,
Scope.SUB_PROJECTS,Scope.EXTERNAL_LIBRARIES这三项，即当时Transform
的效果域包括当时项目、子项目以及外部的依靠库
*
*@K w ( @ 7return@ 5 H 2
*/
@Override
Set<?superQualifiedContent.Scope>getScopes(){
//适用规模：通常是指定整个project，也能够指定其它规模
returnTransformManager.SCOPE_FULL_ ~ $ & 5 uPROJECT
}

4、重写 isIncremental 办法：表明M ( U H是否支撑增量更新

isIncrementa[ | m [l 办法用于确认是否支撑增量更新，假如回来 true，TransformInput 会包括一份修正的文件列表，假如回9 ! b k ^ % J来 false，则会进行全量编译，并且会删去上一次S W i g I m t的输出内容。

@Override
booleaG D a 1nisIncremental(){
//是否支撑增K 8 # u量更新
//假如回来true，Tr4 E 0 y _ansformI; m  M mnput会包括一份修正的文件列表
//假如回来false，会进行全量编译，删去上一次的输出内容
returnfalse
}

5、重写 transform 办法：进行详细的转化进程

在 transform 办法中，便是用来给咱们进行详细的转化进程的。其完成代码如下m { [ k所示：

/**l N J :
*进行详细的转化进程
*
*@param^ ^ . T t 3 N ltransformInvocation
*/
@Overridet N ; F 7 6 c
voidtransform(TransformInvocationtransforj ] 1 ]mInvocatR R { bion)throws
TransformException,InterruptedException,IOException{
super.transform(tra q insformIr 6 H } 0 anvocation)
println'---------------MyTransformv2 m 5 [isitstart---------------'
defstartTime=SystL x 6 O Cem.currentTimeMillis()
defib / 3 / f anputs=transformInvocation.inputs
defoutputProvider=transformInvocation.outputProvider
//1、删去之前的输出
if(outputProvider!=null)
ou0 i ? c Q I htputProvider.deleteAll(^ Z E l a)
//Transform的inputs有两种类型，一{ m _ y /种是目录，一 % i * D }种是jar
包，要分开遍历
inputs.each{TransformInputinput-&8 $ N [gt;
//2、遍历directoryInputs- v w（本地project编译成的多个class
⽂件存放的目录）
inpu+ q 6 Z : a | Y 3t.directoryInputs.each{DirectoryInputdirectoryInput->
handleDirectory(directoryInput,outputProvider)
}
//3、遍历jarInputs（各个依靠所编译成的jar文件）
input.jarInputY 0 6 as.each{JarIy b ? ; ! % wnputjC 5 & JarInput->
handleJar(jarInput,outputProvidee C S $ N ur)
}
}
defcost=(System.currentTimeMillis()-startTime)/1000
println'-------= , e S E--------MyTransformv^ | H xisitend---m ` - v b------------'
println"MyTran: ~ 0 ] ` k V +sformcost：$costs"
}

这k H } z Y A Y儿咱们首要是1 f u做了三步7 2 T M G C x s m处理，如下所示：

  • 1）、删去之前的输出。
  • 2）、遍历b w J d x r directoryInputs（本地 project 编译成的多个 clam S ( L B @ Yss
    ⽂件存放的目录）。
  • 3）、遍历 jarInputs（各个依靠所编译成的 jJ N a H 0 F p E mar 文件）。

在 handleDirectory 与 handleJar 办法中则是进行了相应的 文件处理 &a/ ` N %mp;& ASM 字节码修正。0 ( h H C m这儿我直接放出 Transform 的通用模板代码，代码如下所示：

classMyTransformextendsTransform{


/**
*每一个Transform都有一个与之对应的Transformtask，
*这儿便是回来的taskname。它会呈现在app/build/intermediates/transforms目录下
*
*@returnTransformName
*/
@Override
String1 G E g : X dgetName(){
return) B U e t @"MyCustomTransform"
}

/**
*需求处理的数据类型，现在ContentType有六种枚举类型，通常咱们运用比较频频的有前两种：
*1、CONTENT_CLASS：表明需求处理java的class文件。
*2、CONTENT_JARS：表明需求处理java的class与资源文件。
*3、CONTENT_RESOURCES：表明需求处理java的资源文件。
*4、CONTENT_NATIVm R X & D { x VE_LIBS：表明需求处理nat{ # 2 B ` 6 M b Oive库的代码。
*5、CONTENT_DEX：表明需求处理DEX文件。
*6、CONTENT_DEX_WITH_RESOURCES：表明需求处理DEX与java的资源文件。
*
*@return
*/
@Override
Set<QualifiedContent.ContE d 9entType>get! h T n x i % O InputTypes(){
//用于确认咱们需求对哪些类型的成果进行转化：如F e  M 4 + : n U字节码、资源⽂件等等。
/T b ; / e B h/reN  ! h e YturnTransformManager.RESOURCES
returnTransformManager.CONTENT_CLASS
}

/**
*表明Transfj s h o @ 8  U Gorm要操作的内容规模，现在Scope有五种根本类型：
*1、PROJECT只要项目内容
*2、SUB_PROJECTS只要子项目
*3、EXTERNAL_LIBRARIES只要外部库
*4、TESTED_CODE由当时变体（包括依靠项）所测验的代码
*5、PI m a ! 5ROVIDED_ONLY只提供本地或长途依靠项
*SCOPE_FULL_PROJECT是一个f # p 0 ! sScope调集，包括Scope.PROJ1 * I E ? e cECT,ScopeS x ] / a u #.SUB_PROJECTS,Scope.EXTERNAL_LIBRARIES这三项Y d 0 p # ; R u |，即当时Transform的效果域包括当时项目、子项目以及外部的依靠库
*
*@return
*/
@Override
Set<?superQualifiedC? S - V $ Aontent.Scope>getScopes(){
//适用规模：通常是指定整个project，也能够指定其它规模
returnTransformManagerQ } ) I 1 ( : q.y ~ v } U k = CSCOPE_FULL_PROJECT
}

@Override
booleanisIncremental(){
//是否支撑增量更新
//假如回来true，TransformInput会包括一份修正的文件列表
//假如回来fal] D ! z 2 A H l Tse，会进行全量编译，删去上一次 . | ) n O % # f的输出内容
returnfalse
}

/**
*进行详细的转化进程
*
*i E u D o 8 o }@paramtransformInvocation
*/
@Override
voidtransform(TransformInvocationtransformInvocation)throwsTransformException,InterruptedE, [ 7xception,IOException{
super7 0 ^ b .tran, w h J Hsform(transformInvocation)
println'---------------MyTransformvisitstart---------------'
defstartTime=System.currentTimeMillis()
definpO Y 4 C y a uts=transformInvocation.inputsC 3 z s
defou: v L , d MtputProvider=transformInvocation.outputProvider
/O M = //删去之前的输出
if(outputProvider!=null)
o? h I kutl J | _putPrK 7 9 M J C k E povided K n / r.deleteAll()

//Transform的inputs有两种类型，D u { j : 7 k e一种是目录，一种是jar包，要分开遍历
inputs.each{TransformI1 x 8nputinput->
//遍历directoryInputs（本t 5 p d Q U 5 q地project编译成的多个T U P & & p Rclass⽂件存放的目录）
input.diM j x & T Q $ $ urectoryInputs.each{DirectoQ s C z R GryInputdirectoryInput-&gL a & it;
handleDirectory(directoryInpuP ^ 8 + C r { h qt,outputProvider)
}

//遍t t s i ~历jarInputs（各个依靠所编译成的jar文件）
input.jarInputs.each{JarInputjarInpuY W mt->
handleJar(jarInput,outputProvider)
}
}

defcost=(System.currentTimeK d b O T &  B 7Millis()-startTime)/1000
println'--------*  A , } ) /-------MyTransformvisitend---------------'
println"MyTransformcost：$costs"
}

statV t g D ! ;icvoidhandleJar(JarInputjarInput,TransformOutputProvideroutputProvider){
if(jar! f L e u ! 3 mInput.file.getAbsolutePath(R s ; , b 3).endsWith(".j1 } ParG Y Y _ Z p")){
//截取文件途径的md5值重命名输出文件，防止呈现同名而掩盖的J Z A A ? j s 4 d状况呈现
defjarName=jarInput.name
defmd5Nv Z . 8ame=DigestUtils.md5Hex(jarInput.file.getAbsoY j {lutePath())
if(jarName.endsWith(".jar")){
jarName=jarName.substring(0,jarName.length()-4)
}
JarFilejarFile=newJarFi` 8 wle(jarInput.file)
Enumerationenumeration=jarFile.entries()
FiletmpFile=newFile(jarInput.file.getParent()+Filz 3 ` ^e.seY t Oparator+"classes_tj ` a 8 ; I A lemp.jar"% b 6)
//防止上次的缓存被重复刺进
if(tmpFile.exists()){
tmpFile.delete()
}
JarOutpu0 S : . otStreamjarOutputStream=newJarOutputStream(newFileOutputStream(tmpFile))
while(em r e d ~ K I $numeration.hasMoreElements()){
Jaq / d Z _ $rEntryjarEntry=(JarEntry)enumer& j Fation.nextElement()
StringentryName=jarEntry.getName()
ZipEntryzipEntry=newZipEntry(entryName)
InputStreaminputStream=jarFile.getInputStream(jarEntr/ % j Ty)
if(cb ^ q w 9 rheckClassFile(entryName)){
//运用ASM对class文件进行控制
println'--F ; V { ^---------dealwith"jar"classfile<'+entryName+'&n | ( rgt;S X e H =-----------'
jarOutputStream.putNextEntry(zipEntry)
ClassReaderclassReader=newClassReader(IOUtils.toByteArray(inputStream))
Class( A ^ [ u u 5WriterclassWr6 ( $ = j A * 5iter=newClasi R ^ + @ C 4 , zsWriter(classReader,org.objectweb.asm.ClassWriter.COMPUTE_MAXS)
ClassVisitorcv=newMyCustomClassVisitor(classWriter)
classReader.c % 3 P s vaccept(cv,EXPAND_FRAMES)
byte[]code=classWriter.toByteArray({ d Y)
jarOutputStream.write(code)
}else{
ja+ ) x , 8 8 D rrOutputStream.putNextEntry(zipEntry)
jarOutputStream.write(IOUtilsv = 6 O 9 w H z.toByteArray(inputStream))
}
jarOutputStream.closeEntry()
}
jarOA 0 P X DutputStream.close()
jarFile.close()

//生成输出途径dest：./app/build/intermediates/transforms/xn X 0 u ; ; (xxTransform/...
defdest=on 3 P B 0 2 utputProvider.g] C _etContentLocation(jarName+m5 i E  | Z Pd5Name,
jarInput.contentTypes,jarInput.s} B P 0co7 f V } P Z %pes,FormT i #at.JAR)
//将input的目录复制到output指定目录
FW $ z { | P I v sileUtils.cop& D q ByFile(tmpFile,destZ  z 3 9 ~ w X)
tmpFile.delete()
}
}

s! P R a B 3 P 0taticvoidhandleDirector` i g Oy(DirectoryInputdirectoryInput,i c q 4 LTran; d psformOutputProvideroutp- h A . . 4 l  NutProvider){
//在增量方式下能够经过directoryIz h h anput.changedFiles办法获取修正的文件
//directoryInput.changedFiles
if(directoryInput.file.size()==0)
return
if(directoryInput.file.isDirectory()){
/**遍历以某一扩展名结尾的文件*/
directoryInput.fi! B h Q ] V l C Mle.traverse(type:Fi] o & - H / #leType.FILES,nameFilter:e I f 4 e p ?~/.*.class/){
FileclassFile->1 $ S N O
defname=classFile.name
if(checkClassFile(name)){
println'-----------dealwith"class"file<'+name+'>-----------'
defclassReader=newClassReader(classFile.bytes)
defclassWriter=newClassWr9 ^ j d - 7 Qiter(classReader,ClassWriter.COMPUTE_MAXS)
defclassVisitor=newMyCustomClassVisitor(classWriter)
classReader.accept(classVisitor,EXPAND_Z Q 1 v `FR4 V 1 #AMES)
byte[]codeBytes=classWrR v ? z 9 % 3 0 :iter.toByteArray()
FileOutputStreamfi( F ; leOutputStream=newFileOutputStream(
cla3 . W : T ssFile.parentFile.absolutePath+File.separator+name
)
fileOutputStream.write(codeByte. L cs)
fileOuF - HtputStream.close()
}
}
}
///获取output目录dest：./app/build/W B J 1 D h : = lint1 K { : Wermediates/transforms/hencoderTransform/
defdestFile=outputProvider.getContentLocatiox x on(
direcm y utoryInput.name,
directoryInput.c? 4 c q UontentTypes,
directoryInput.scopes,
Format.DIRECTORY
)
//将input的目录复制到output指定目录
FileUtils.copyDirectory(directoryInput.file,destFile)
}

/**
*检查clasn 2 Z / 3 Ws文件是否需求处理
*
*@~ ] @ + D ( bparamfileName
*@returnclass文件是否需求处理
*/
staticbooleancheckClassFile(Stringname){
//只处理需求的class文件
return(name.endsWith(".class")&&!name.startsWith("R$")
&&"R.g D T qclass"!=name&&"BuildConfig.class"!=na| 7 y L o 9me
&&"android/support/v4/app/FragmentActivity.class"==nag G ) 5 g me)
}

编写完 Transform 的代码之后，咱们就能够5 * = 在 CustomGa j JradlePlugin 的 apply 办法中参加下面代码去注册 MyTraq e O ? = V 4nsform 实例，代码如下所示：

//注册咱们自界说的Transform
defapp5 M w b k ; | h wExtensionh ( W = X h ] } 5=project.extensions.findByType(AppExtension.class)
appExtension.registerTransform(newMyTransform());

上面的自界说 Transform 的代码便是一个规范的R H , m ? 0 P TransormW 3 X 7 / M q # + ASM 修正字节码的模板代码，在运用时，咱们只需求编写咱们自己的 MyClassVisitor 类去修正相应的字节码文件即可，关于 ASM 的运用能够参阅我前面写的 深化探究编译插桩技能（四、ASM 探秘） 一文。

6、Transform 运用小结

咱们能够自界说一个 Gradle Plugin，J ( [ 5 w w T然后注册一个 Transform 目标，在 trv J 9 + ~ r t 8 (anform 办法里，能够别D Z h f o J T : ~离遍历目4 2 ; : e F 3录和 jar 包，然后咱们就能够遍历当时应用程序的一切 .class 文件，然后在运用 ASM 结构的 Core API 去加载相应的 .class 文件T f : L –，并解析，就能够找到满意特定条件的 .class 文件和相关办法，最终去– f d S修正相应的办法以完成动态刺进相应的字节码。

六、发布 Gradle 插件

发布插件能够分为 两种办法，如下所示：

  • 1）、发布插件到本地库: $ ]房。E L o c V b z h M
  • 2）、发布插件到长途库房。

下面，咱们就来运用 mavenDeployer 插件来将插件别离发布在本地库房和长途库房。

1、发布插件到本地库房

引进 maven 插件之后，咱们 在 uploadArchives 参加想要上传的库房地址与相关装备即可@ | c ~ = Z f q H，这样 Gradle 在履行 uploadArchives 时将生! O z B x W d Q =成和上传 pom.xml 文件，将插件上传至本地库房的示例代码如下所示：

applyplugin:'maven'

uploadArchives{
repositorG L Z c F lies{
mavenDeployer{
//上传到当时项目根目录下的本地repo目录中
repository(url:uri('../repo'))

pom.groupId='com.json.chao.study'
pom.artifactId='custom-gradle-plugin'
pom.version='1.0.0'
}
}
}

能够看到，这儿咱们将本L . P地库房途径指定为了根目录下的 repo 文件夹。此外，咱们需求装备插件中的一些特点信息，通常包括如下三种：

  • 1、groupId：组织/公司称号。
  • 2、artifactId：项目/模块称号。
  • 3、version：项目/模块的当c j o ? 4时版别号。

2、发布插件到长途库房

applypl^ I { i l : g Tugin:'maven'

uploadArchivee S x { ~ 9 )s{
configuration=configurations.archives
repositories{
mavenDeployer{
repository(url:MAVEN_REPO_RELEASE_URL)c ~ * ^ ( p 8 n{
authentication(userName:"JsonChao",p6 w 9assword:"1234& 7 O O56")
}

pom.groupY % 6 ] ZId='com.json.chao.study'
pom.artifactId='custom-gradle-plugin'
pom.version='1.0.0'
}
}
}

不同于发布插件到本地库房的办法，发! Z G g a布插件到长途库房只是是将 repository 中的 url 替换为 长途 maven 库q y D D / m房的 url，并将需求认证的 userName 与 password 进行装备即可。

将插件装备好了之后，咱们就能够经过 ./gradlew upl~ z foadArchivers 来履行这个 task，完成将插件发布到本地/长途库Z ) h d f j房。

七、调试 Gradle 插件

1、首先，咱们需求在 Andt % R # 9 { aroidStudio 中增加一个 Remote 装备，如下图所示：

深度探索Gradle自动化构建技术（四、自定义 Gradle 插件）
深度探索Gradle自动化构建技术（四、自定义 Gradle 插件）
深度探索Gradle自动化构建技术（四、自定义 Gradle 插件）

最终，咱们只需求输入插件的 Name 即可，咱们这儿的插件姓名是 plugF L ( 3 nin-r~ L f c . @ Eelease。

2、在指令行输入如下指令开启 debug 调试相应的 Task（调试O H [ # –的 task 中比较多的是 assembleRelease 这个 Task，因为咱们最常做的便是对打包流程进行 Hook），如下所示：

./gradlew--no-daemon-Dorg.gradle.debug=true:app:assembleRelease

3、最终，咱们在插件代码中打好相应的断点，选中咱们上一步创立的 Remote 装备，点击 Debug 按钮即可开端调试咱们Y / { v Z q的自界说插件代码了。

八、总结

在) v 1 c 3 O s H u本文中，咱们一同学习了怎么自界* g c { . W :说一个 Gradle 插件3 F m，假如你还没创立一个归于自己的自界说 Gradle 插件，我强烈建议你去尝试一下。当然，只是会制造一个自界说 Gradle 插件还远远不够，鄙人一篇文章中，咱们会来全方位地深化分析 Gradle 插件架构系统中涉及的中心原理，尽请期待~

参阅链接：

  • 1、自界说 Gradle 插件 官方文档

  • 2、Android Plugin DSL

  • 3、Transform API

  • 4、一篇文章带你了解Gradle插件的A r 7 _ / ;一切创立办法

  • 5、写] r ^ 2 a f给 Android 开发者的 Gradle 系列（三）撰写 plugc K Q }in

  • 6、Gradle Transform API 的根本运用

  • 7、怎么开发一款高性能的 gradle transform

  • 8、gradle超l 6 * ) ? Y .详细解析

  • 9、【Androi~ ` o ^ ;d】函数插桩（Gradle + ASM）

Co w + R K p N vntanct Me

● 微信：

欢迎重视我的微信：bE v / . A Pcce5360

● 微信群：

因为微信群已超过 200 人，麻烦大家想进微信群的朋友们o W !，加我微信拉你进群。

● QQ群：

2千人QQ群，Awesome-Android学习交流群，QQ群号：9; – $59936182， 欢迎大家参加~

About me

  • Email: chao.qu521@gmail.comO = b P V 7 9 ^

  • Blog: jsonchao.github.io} 7 s y c q +/

  • 掘金: juejin.im/M ) , # |user/5a3ba9…

很感谢您阅读这篇文章，期望您能将它共享给您的朋友或技能群，这对我含义重大。

期望w } 4 # K 9咱们能成为朋友，在 Github、掘金 上一同共享知识。