0. 前言

在Android Gradle Plugin中,有一個(gè)叫Transform API(從1.5.0版本才有的)的東西.利用這個(gè)Transform API咱可以在.class文件轉(zhuǎn)換成dex文件之前,對(duì).class文件進(jìn)行處理.比如監(jiān)控,埋點(diǎn)之類(lèi)的.

而對(duì).class文件進(jìn)行處理這個(gè)操作,咱們這里使用ASM.ASM是一個(gè)通用的Java字節(jié)碼操作和分析框架。它可以直接以二進(jìn)制形式用于修改現(xiàn)有類(lèi)或動(dòng)態(tài)生成類(lèi).咱們?cè)诖虬臅r(shí)候,直接操作字節(jié)碼修改class,對(duì)運(yùn)行時(shí)性能是沒(méi)有任何影響的,所以它的效率是相當(dāng)高的.

本篇文章給大家簡(jiǎn)單介紹一下Transform和ASM的使用,最后再結(jié)合一個(gè)小栗子練習(xí)一下.文中demo源碼地址

1. 使用Transform API

1.1 注冊(cè)一個(gè)自定義的Transform

首先寫(xiě)一個(gè)Plugin,然后通過(guò)registerTransform方法進(jìn)行注冊(cè)自定義的Transform.

class MethodTimeTransformPlugin implements Plugin<Project> {
    @Override
    void apply(Project project) {
        //注冊(cè)方式1
        AppExtension appExtension = project.extensions.getByType(AppExtension)
        appExtension.registerTransform(new MethodTimeTransform())

        //注冊(cè)方式2
        //project.android.registerTransform(new MethodTimeTransform())
    }
}
復(fù)制代碼

通過(guò)獲取module的Project的AppExtension,通過(guò)它的registerTransform方法注冊(cè)的Transform.

這里注冊(cè)之后,會(huì)在編譯過(guò)程中的TransformManager#addTransform中生成一個(gè)task,然后在執(zhí)行這個(gè)task的時(shí)候會(huì)執(zhí)行到我們自定義的Transform的transform方法.這個(gè)task的執(zhí)行時(shí)機(jī)其實(shí)就是.class文件轉(zhuǎn)換成.dex文件的時(shí)候,轉(zhuǎn)換的邏輯是定義在transform方法中的.

1.2 自定義一個(gè)Transform

先讓大家看一下比較標(biāo)準(zhǔn)的Transform模板代碼:

class MethodTimeTransform extends Transform {

    @Override
    String getName() {
        return "MethodTimeTransform"
    }

    @Override
    Set<QualifiedContent.ContentType> getInputTypes() {
        //需要處理的數(shù)據(jù)類(lèi)型,這里表示class文件
        return TransformManager.CONTENT_CLASS
    }

    @Override
    Set<? super QualifiedContent.Scope> getScopes() {
        //作用范圍
        return TransformManager.SCOPE_FULL_PROJECT
    }

    @Override
    boolean isIncremental() {
        //是否支持增量編譯
        return true
    }

    @Override
    void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        super.transform(transformInvocation)

        //TransformOutputProvider管理輸出路徑,如果消費(fèi)型輸入為空,則outputProvider也為空
        TransformOutputProvider outputProvider = transformInvocation.outputProvider

        //transformInvocation.inputs的類(lèi)型是Collection<TransformInput>,可以從中獲取jar包和class文件夾路徑。需要輸出給下一個(gè)任務(wù)
        transformInvocation.inputs.each { input -> //這里的input是TransformInput

            input.jarInputs.each { jarInput ->
                //處理jar
                processJarInput(jarInput, outputProvider)
            }

            input.directoryInputs.each { directoryInput ->
                //處理源碼文件
                processDirectoryInput(directoryInput, outputProvider)
            }
        }
    }

    void processJarInput(JarInput jarInput, TransformOutputProvider outputProvider) {
        File dest = outputProvider.getContentLocation(jarInput.file.absolutePath, jarInput.contentTypes, jarInput.scopes, Format.JAR)
        //將修改過(guò)的字節(jié)碼copy到dest,就可以實(shí)現(xiàn)編譯期間干預(yù)字節(jié)碼的目的
        println("拷貝文件 $dest -----")
        FileUtils.copyFile(jarInput.file, dest)
    }

    void processDirectoryInput(DirectoryInput directoryInput, TransformOutputProvider outputProvider) {
        File dest = outputProvider.getContentLocation(directoryInput.name, directoryInput.contentTypes, directoryInput.scopes, Format
                .DIRECTORY)
        //將修改過(guò)的字節(jié)碼copy到dest,就可以實(shí)現(xiàn)編譯期間干預(yù)字節(jié)碼的目的
        println("拷貝文件夾 $dest -----")
        FileUtils.copyDirectory(directoryInput.file, dest)
    }

}
復(fù)制代碼

1. getName(): 表示當(dāng)前Transform名稱(chēng),這個(gè)名稱(chēng)會(huì)被用來(lái)創(chuàng)建目錄,它會(huì)出現(xiàn)在app/build/intermediates/transforms目錄下面.
2. getInputTypes(): 需要處理的數(shù)據(jù)類(lèi)型,用于確定我們需要對(duì)哪些類(lèi)型的結(jié)果進(jìn)行轉(zhuǎn)換,比如class,資源文件等:
   • CONTENT_CLASS：表示需要處理java的class文件
   • CONTENT_JARS：表示需要處理java的class與資源文件
   • CONTENT_RESOURCES：表示需要處理java的資源文件
   • CONTENT_NATIVE_LIBS：表示需要處理native庫(kù)的代碼
   • CONTENT_DEX：表示需要處理DEX文件
   • CONTENT_DEX_WITH_RESOURCES：表示需要處理DEX與java的資源文件
3. getScopes(): 表示Transform要操作的內(nèi)容范圍(上面demo里面使用的SCOPE_FULL_PROJECT是Scope的集合,包含了Scope.PROJECT,Scope.SUB_PROJECTS,Scope.EXTERNAL_LIBRARIES這幾個(gè)東西.當(dāng)然,TransformManager里面還有一些其他集合,這里不做舉例).
   • PROJECT: 只有項(xiàng)目?jī)?nèi)容
   • SUB_PROJECTS: 只有子項(xiàng)目
   • EXTERNAL_LIBRARIES: 只有外部庫(kù)
   • TESTED_CODE: 測(cè)試代碼
   • PROVIDED_ONLY: 只提供本地或遠(yuǎn)程依賴項(xiàng)
4. isIncremental(): 是否支持增量更新
   • 如果返回true,則TransformInput會(huì)包含一份修改的文件列表
   • 如果是false,則進(jìn)行全量編譯,刪除上一次輸出內(nèi)容
5. transform(): 進(jìn)行具體轉(zhuǎn)換邏輯.
   • 消費(fèi)型Transform: 在transform方法中,我們需要將每個(gè)jar包和class文件復(fù)制到dest路徑,這個(gè)dest路徑就是下一個(gè)Transform的輸入數(shù)據(jù).在復(fù)制的時(shí)候,我們可以將jar和class文件的字節(jié)碼做一些修改,再進(jìn)行復(fù)制. 可以看出,如果我們注冊(cè)了Transform,但是又不將內(nèi)容復(fù)制到下一個(gè)Transform需要的輸入路徑的話,就會(huì)出問(wèn)題,比如少了一些class之類(lèi)的.上面的demo中僅僅是將所有的輸入文件拷貝到目標(biāo)目錄下,并沒(méi)有對(duì)字節(jié)碼文件進(jìn)行任何處理.
   • 引用型Transform: 當(dāng)前Transform可以讀取這些輸入,而不需要輸出給下一個(gè)Transform.

可以看出,最關(guān)鍵的核心代碼就是transform()方法里面,我們需要做一些class文件字節(jié)碼的修改,才能讓Transform發(fā)揮其效果.

道理是這個(gè)道理,但是字節(jié)碼那玩意兒想改就能改么? 忘記字節(jié)碼是什么的小伙伴可以看我之前發(fā)的文章 Java字節(jié)碼解讀 復(fù)習(xí)一下. 字節(jié)碼比較復(fù)雜,連"讀懂"都非常非常困難,還讓我去改它,那更是難上加難.

不過(guò),幸好咱們可以借助后面介紹的ASM工具進(jìn)行方便的修改字節(jié)碼工作.

1.3 增量編譯

就是Transform中的isIncremental()方法返回值,如果是false的話,則表示不開(kāi)啟增量編譯,每次都得處理每個(gè)文件,非常非常拖慢編譯時(shí)間. 我們可以借助該方法,返回值改成true,開(kāi)啟增量編譯.當(dāng)然,開(kāi)啟了增量編譯之后需要檢查每個(gè)文件的Status,然后根據(jù)這個(gè)文件的Status進(jìn)行不同的操作.

具體的Status如下:

• NOTCHANGED: 當(dāng)前文件不需要處理,連復(fù)制操作也不用
• ADDED: 正常處理,輸出給下一個(gè)任務(wù)
• CHANGED: 正常處理,輸出給下一個(gè)任務(wù)
• REMOVED: 移除outputProvider獲取路徑對(duì)應(yīng)的文件

來(lái)看一下代碼如何實(shí)現(xiàn),咱將上面的dmeo代碼簡(jiǎn)單改改:

@Override
void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
    super.transform(transformInvocation)
    printCopyRight()

    //TransformOutputProvider管理輸出路徑,如果消費(fèi)型輸入為空,則outputProvider也為空
    TransformOutputProvider outputProvider = transformInvocation.outputProvider

    //當(dāng)前是否是增量編譯,由isIncremental方法決定的
    // 當(dāng)上面的isIncremental()寫(xiě)的返回true,這里得到的值不一定是true,還得看當(dāng)時(shí)環(huán)境.比如clean之后第一次運(yùn)行肯定就不是增量編譯嘛.
    boolean isIncremental = transformInvocation.isIncremental()
    if (!isIncremental) {
        //不是增量編譯則刪除之前的所有文件
        outputProvider.deleteAll()
    }

    //transformInvocation.inputs的類(lèi)型是Collection<TransformInput>,可以從中獲取jar包和class文件夾路徑。需要輸出給下一個(gè)任務(wù)
    transformInvocation.inputs.each { input -> //這里的input是TransformInput

        input.jarInputs.each { jarInput ->
            //處理jar
            processJarInput(jarInput, outputProvider, isIncremental)
        }

        input.directoryInputs.each { directoryInput ->
            //處理源碼文件
            processDirectoryInput(directoryInput, outputProvider, isIncremental)
        }
    }
}

/**
 * 處理jar
 * 將修改過(guò)的字節(jié)碼copy到dest,就可以實(shí)現(xiàn)編譯期間干預(yù)字節(jié)碼的目的
 */
void processJarInput(JarInput jarInput, TransformOutputProvider outputProvider, boolean isIncremental) {
    def status = jarInput.status
    File dest = outputProvider.getContentLocation(jarInput.file.absolutePath, jarInput.contentTypes, jarInput.scopes, Format.JAR)
    if (isIncremental) {
        switch (status) {
            case Status.NOTCHANGED:
                break
            case Status.ADDED:
            case Status.CHANGED:
                transformJar(jarInput.file, dest)
                break
            case Status.REMOVED:
                if (dest.exists()) {
                    FileUtils.forceDelete(dest)
                }
                break
        }
    } else {
        transformJar(jarInput.file, dest)
    }

}

void transformJar(File jarInputFile, File dest) {
    //println("拷貝文件 $dest -----")
    FileUtils.copyFile(jarInputFile, dest)
}

/**
 * 處理源碼文件
 * 將修改過(guò)的字節(jié)碼copy到dest,就可以實(shí)現(xiàn)編譯期間干預(yù)字節(jié)碼的目的
 */
void processDirectoryInput(DirectoryInput directoryInput, TransformOutputProvider outputProvider, boolean isIncremental) {
    File dest = outputProvider.getContentLocation(directoryInput.name, directoryInput.contentTypes, directoryInput.scopes, Format
            .DIRECTORY)
    FileUtils.forceMkdir(dest)

    println("isIncremental = $isIncremental")

    if (isIncremental) {
        String srcDirPath = directoryInput.getFile().getAbsolutePath()
        String destDirPath = dest.getAbsolutePath()
        Map<File, Status> fileStatusMap = directoryInput.getChangedFiles()
        for (Map.Entry<File, Status> changedFile : fileStatusMap.entrySet()) {
            Status status = changedFile.getValue()
            File inputFile = changedFile.getKey()
            String destFilePath = inputFile.getAbsolutePath().replace(srcDirPath, destDirPath)
            File destFile = new File(destFilePath)
            switch (status) {
                case Status.NOTCHANGED:
                    break
                case Status.ADDED:
                case Status.CHANGED:
                    FileUtils.touch(destFile)
                    transformSingleFile(inputFile, destFile)
                    break
                case Status.REMOVED:
                    if (destFile.exists()) {
                        FileUtils.forceDelete(destFile)
                    }
                    break
            }
        }
    } else {
        transformDirectory(directoryInput.file, dest)
    }
}

void transformSingleFile(File inputFile, File destFile) {
    println("拷貝單個(gè)文件")
    FileUtils.copyFile(inputFile, destFile)
}

void transformDirectory(File directoryInputFile, File dest) {
    println("拷貝文件夾 $dest -----")
    FileUtils.copyDirectory(directoryInputFile, dest)
}
復(fù)制代碼

根據(jù)是否為增量更新,如果不是,則刪除之前的所有文件.然后對(duì)每個(gè)文件進(jìn)行狀態(tài)判斷,根據(jù)其狀態(tài)來(lái)決定到底是該刪除,或者復(fù)制.開(kāi)啟增量編譯之后,速度會(huì)有特別大的提升.

1.4 并發(fā)編譯

畢竟是在電腦上進(jìn)行編譯,盡管壓榨電腦性能,我們把并發(fā)編譯給搞起.說(shuō)來(lái)也輕巧,就下面幾行代碼就行

private WaitableExecutor mWaitableExecutor = WaitableExecutor.useGlobalSharedThreadPool()
transformInvocation.inputs.each { input -> //這里的input是TransformInput

    input.jarInputs.each { jarInput ->
        //處理jar
        mWaitableExecutor.execute(new Callable<Object>() {
            @Override
            Object call() throws Exception {
                //多線程
                processJarInput(jarInput, outputProvider, isIncremental)
                return null
            }
        })
    }

    //處理源碼文件
    input.directoryInputs.each { directoryInput ->
        //多線程
        mWaitableExecutor.execute(new Callable<Object>() {
            @Override
            Object call() throws Exception {
                processDirectoryInput(directoryInput, outputProvider, isIncremental)
                return null
            }
        })
    }
}

//等待所有任務(wù)結(jié)束
mWaitableExecutor.waitForTasksWithQuickFail(true)
復(fù)制代碼

增加的代碼不多,其他都是之前的.就是讓處理邏輯的地方放線程里面去執(zhí)行,然后得等這些線程都處理完成才結(jié)束任務(wù).

到這里Transform基本的API也將介紹完了,原理(系統(tǒng)有一些列Transform用于在class轉(zhuǎn)dex的過(guò)程中的處理邏輯,我們也可以自定義Transform參與其中,這個(gè)Transform最終其實(shí)是在一個(gè)Task里面執(zhí)行的.)的話也知曉了個(gè)大概,接下來(lái)我們看看如何利用ASM修改字節(jié)碼實(shí)現(xiàn)炫酷的功能吧.

2. ASM

2.1 介紹

ASM官網(wǎng)

官網(wǎng)上是這樣介紹ASM的: ASM是一個(gè)通用的Java字節(jié)碼操作和分析框架。它可以直接以二進(jìn)制形式用于修改現(xiàn)有類(lèi)或動(dòng)態(tài)生成類(lèi)键痛。ASM提供了一些常見(jiàn)的字節(jié)碼轉(zhuǎn)換和分析算法，可從中構(gòu)建定制的復(fù)雜轉(zhuǎn)換和代碼分析工具匾七。ASM提供了與其他Java字節(jié)碼框架類(lèi)似的功能絮短，但是側(cè)重于 性能。因?yàn)樗脑O(shè)計(jì)和實(shí)現(xiàn)是盡可能的小和盡可能快昨忆，所以它非常適合在動(dòng)態(tài)系統(tǒng)中使用（但當(dāng)然也可以以靜態(tài)方式使用丁频，例如在編譯器中）。(可能翻譯得不是很準(zhǔn)確,英文好的同學(xué)可以去官網(wǎng)看原話)

2.2 引入ASM

下面是我的demo中的buildSrc里面build.gradle配置.它包含了Plugin+Transform+ASM的所有依賴,放心拿去用.

dependencies {
    implementation gradleApi()
    implementation localGroovy()
    //常用io操作
    implementation "commons-io:commons-io:2.6"

    // Android DSL  Android編譯的大部分gradle源碼
    implementation 'com.android.tools.build:gradle:3.6.2'
    implementation 'com.android.tools.build:gradle-api:3.6.2'
    //ASM
    implementation 'org.ow2.asm:asm:7.1'
    implementation 'org.ow2.asm:asm-util:7.1'
    implementation 'org.ow2.asm:asm-commons:7.1'
}
復(fù)制代碼

2.3 ASM基本使用

在使用之前我們先來(lái)看一些常用的對(duì)象

• ClassReader : 按照J(rèn)ava虛擬機(jī)規(guī)范中定義的方式來(lái)解析class文件中的內(nèi)容,在遇到合適的字段時(shí)調(diào)用ClassVisitor中相應(yīng)的方法
• ClassVisitor : Java中類(lèi)的訪問(wèn)者,提供一系列方法由ClassReader調(diào)用.它是一個(gè)抽象類(lèi),在使用時(shí)需要繼承此類(lèi).
• ClassWriter : 它是一個(gè)繼承了ClassVisitor的類(lèi),主要負(fù)責(zé)將ClassReader傳遞過(guò)來(lái)的數(shù)據(jù)寫(xiě)到一個(gè)字節(jié)流中.在傳遞數(shù)據(jù)完成之后,可以通過(guò)它的toByteArray方法獲得完整的字節(jié)流.
• ModuleVisitor : Java中模塊的訪問(wèn)者,作為ClassVisitor.visitModule方法的返回值,要是不關(guān)心模塊的使用情況,可以返回一個(gè)null.
• AnnotationVisitor : Java中注解的訪問(wèn)者,作為ClassVisitor.visitTypeAnnotation的返回值,不關(guān)心注解使用情況也是可以返回null.
• FieldVisitor : Java中字段的訪問(wèn)者,作為ClassVisitor.visitField的返回值,不關(guān)心字段使用情況也是可以返回null.
• MethodVisitor：Java中方法的訪問(wèn)者,作為ClassVisitor.visitMethod的返回值,不關(guān)心方法使用情況也是可以返回null.

上面這些對(duì)象先簡(jiǎn)單過(guò)一下,眼熟就行,待會(huì)兒會(huì)使用到這些對(duì)象.

大體工作流程: 通過(guò)ClassReader讀取class字節(jié)碼文件,然后ClassReader將讀取到的數(shù)據(jù)通過(guò)一個(gè)ClassVisitor(上面的ClassWriter其實(shí)就是一個(gè)ClassVisitor)將數(shù)據(jù)表現(xiàn)出來(lái).表現(xiàn)形式: 將字節(jié)碼的每個(gè)細(xì)節(jié)按順序通過(guò)接口的方式傳遞給ClassVisitor.就比如說(shuō),訪問(wèn)到了class文件的xx方法,就會(huì)回調(diào)ClassVisitor的visitMethod方法;訪問(wèn)到了class文件的屬性,就會(huì)回調(diào)ClassVisitor的visitField方法.

ClassWriter是一個(gè)繼承了ClassVisitor的類(lèi),它保存了這些由ClassReader讀取出來(lái)的字節(jié)流數(shù)據(jù),最后通過(guò)它的toByteArray方法獲得完整的字節(jié)流.

上面的概念比較生硬,咱們先來(lái)寫(xiě)一個(gè)簡(jiǎn)單的復(fù)制class文件的方法:

private void copyFile(File inputFile, File outputFile) {
    FileInputStream inputStream = new FileInputStream(inputFile)
    FileOutputStream outputStream = new FileOutputStream(outputFile)

    //1\. 構(gòu)建ClassReader對(duì)象
    ClassReader classReader = new ClassReader(inputStream)
    //2\. 構(gòu)建ClassVisitor的實(shí)現(xiàn)類(lèi)ClassWriter
    ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS)
    //3\. 將ClassReader讀取到的內(nèi)容回調(diào)給ClassVisitor接口
    classReader.accept(classWriter, ClassReader.EXPAND_FRAMES)
    //4\. 通過(guò)classWriter對(duì)象的toByteArray方法拿到完整的字節(jié)流
    outputStream.write(classWriter.toByteArray())

    inputStream.close()
    outputStream.close()
}
復(fù)制代碼

看到這里,可能有的同學(xué)已經(jīng)有點(diǎn)感覺(jué)了.ClassReader對(duì)象就是專(zhuān)門(mén)負(fù)責(zé)讀取字節(jié)碼文件的,而ClassWriter就是一個(gè)繼承了ClassVisitor的類(lèi),當(dāng)ClassReader讀取字節(jié)碼文件的時(shí)候,數(shù)據(jù)會(huì)通過(guò)ClassVisitor回調(diào)回來(lái).咱們可以自定義一個(gè)ClassWriter用來(lái)接收讀取到的字節(jié)數(shù)據(jù),接收數(shù)據(jù)的同時(shí),咱們?cè)俨迦胍稽c(diǎn)東西到這些數(shù)據(jù)的前面或者后面,最后通過(guò)ClassWriter的toByteArray方法將這些字節(jié)碼數(shù)據(jù)導(dǎo)出,寫(xiě)入新的文件,這就是我們所說(shuō)的插樁了.

現(xiàn)在咱們舉個(gè)栗子,到底插樁能有啥用?就實(shí)現(xiàn)一個(gè)簡(jiǎn)單的需求吧,在每個(gè)方法的最前面插入一句打印Hello World!的代碼.

修改前的代碼如下所示:

private void test() {
    System.out.println("test");
}
復(fù)制代碼

預(yù)期修改后的代碼:

private void test() {
    System.out.println("Hello World!");
    System.out.println("test");
}
復(fù)制代碼

將上面的復(fù)制文件的代碼簡(jiǎn)單改改

void traceFile(File inputFile, File outputFile) {
    FileInputStream inputStream = new FileInputStream(inputFile)
    FileOutputStream outputStream = new FileOutputStream(outputFile)

    ClassReader classReader = new ClassReader(inputStream)
    ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS)
    classReader.accept(new HelloClassVisitor(classWriter)), ClassReader.EXPAND_FRAMES)
    outputStream.write(classWriter.toByteArray())

    inputStream.close()
    outputStream.close()
}
復(fù)制代碼

唯一有變化的地方就是classReader的accept方法傳入的ClassVisitor對(duì)象變了,咱自定義了一個(gè)HelloClassVisitor.

class HelloClassVisitor extends ClassVisitor {

    HelloClassVisitor(ClassVisitor cv) {
        //這里需要指定一下版本Opcodes.ASM7
        super(Opcodes.ASM7, cv)
    }

    @Override
    MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        def methodVisitor = cv.visitMethod(access, name, descriptor, signature, exceptions)
        return new HelloMethodVisitor(api, methodVisitor, access, name, descriptor)
    }
}
復(fù)制代碼

我們自定義了一個(gè)ClassVisitor,它將ClassWriter傳入其中.在ClassVisitor的實(shí)現(xiàn)中,只要傳入了classVisitor對(duì)象,那么就會(huì)將功能委托給這個(gè)classVisitor對(duì)象.相當(dāng)于我傳入的這個(gè)ClassWriter就讀取到了字節(jié)碼,最后toByteArray就是所有的字節(jié)碼.多說(shuō)無(wú)益,看看代碼:

public abstract class ClassVisitor {
    /** The class visitor to which this visitor must delegate method calls. May be null. */
  protected ClassVisitor cv;

   public ClassVisitor(final int api, final ClassVisitor classVisitor) {
    if (api != Opcodes.ASM7 && api != Opcodes.ASM6 && api != Opcodes.ASM5 && api != Opcodes.ASM4) {
      throw new IllegalArgumentException("Unsupported api " + api);
    }
    this.api = api;
    this.cv = classVisitor;
  }

  public AnnotationVisitor visitAnnotation(final String descriptor, final boolean visible) {
    if (cv != null) {
      return cv.visitAnnotation(descriptor, visible);
    }
    return null;
  }

  public MethodVisitor visitMethod(
      final int access,
      final String name,
      final String descriptor,
      final String signature,
      final String[] exceptions) {
    if (cv != null) {
      return cv.visitMethod(access, name, descriptor, signature, exceptions);
    }
    return null;
  }

  ...
}
復(fù)制代碼

有了我們傳入的ClassWriter,咱們?cè)谧远xClassVisitor的時(shí)候,只需要關(guān)注需要修改的地方即可.咱們是想對(duì)方法進(jìn)行插樁,自然就得關(guān)心visitMethod方法,該方法會(huì)在ClassReader閱讀class文件里面的方法時(shí)會(huì)回調(diào).這里我們首先是在HelloClassVisitor的visitMethod中調(diào)用了ClassVisitor的visitMethod方法,拿到MethodVisitor對(duì)象.

而MethodVisitor是和ClassVisitor是類(lèi)似的,在ClassReader閱讀方法的時(shí)候會(huì)回調(diào)這個(gè)類(lèi)里面的visitParameter(訪問(wèn)方法參數(shù)),visitAnnotationDefault(訪問(wèn)注解的默認(rèn)值),visitAnnotation(訪問(wèn)注解)等等.

所以為了能夠?qū)Ψ椒ú鍢?咱們需要再包一層,自己實(shí)現(xiàn)一下MethodVisitor,我們將ClassWriter.visitMethod返回的MethodVisitor傳入自定義的MethodVisitor,并在方法剛開(kāi)始的地方進(jìn)行插樁.AdviceAdapter是一個(gè)繼承自MethodVisitor的類(lèi),它能夠方便的回調(diào)方法進(jìn)入(onMethodEnter)和方法退出(onMethodExit). 我們只需要在方法進(jìn)入,也就是onMethodEnter方法里面進(jìn)行插樁即可.

class HelloMethodVisitor extends AdviceAdapter {

        HelloMethodVisitor(int api, MethodVisitor methodVisitor, int access, String name, String descriptor) {
            super(api, methodVisitor, access, name, descriptor)
        }

        //方法進(jìn)入
        @Override
        protected void onMethodEnter() {
            super.onMethodEnter()
            //這里的mv是MethodVisitor
            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            mv.visitLdcInsn("Hello World!");
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        }
}
復(fù)制代碼

插樁的核心代碼,需要一些字節(jié)碼的核心知識(shí),這里不展開(kāi)介紹,推薦大家閱讀《深入理解Java虛擬機(jī)》關(guān)于字節(jié)碼的章節(jié).

當(dāng)然,要想快速地寫(xiě)出這些代碼也是有捷徑的,安裝一個(gè)ASM Bytecode Outline插件,然后隨便寫(xiě)一個(gè)Test類(lèi),然后隨便寫(xiě)一個(gè)方法

public class Test {
    public void hello() {
        System.out.println("Hello World!");
    }
}
復(fù)制代碼

然后選中該Test.java文件,右鍵菜單,點(diǎn)擊Show ByteCode outline

在右側(cè)窗口內(nèi)選擇ASMified,即可得到如下代碼:

mv = cw.visitMethod(ACC_PUBLIC, "hello", "()V", null, null);
mv.visitCode();
Label l0 = new Label();
mv.visitLabel(l0);
mv.visitLineNumber(42, l0);
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("Hello World!");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
Label l1 = new Label();
mv.visitLabel(l1);
mv.visitLineNumber(43, l1);
mv.visitInsn(RETURN);
Label l2 = new Label();
mv.visitLabel(l2);
mv.visitLocalVariable("this", "Lcom/xfhy/gradledemo/Test;", null, l0, l2, 0);
mv.visitMaxs(2, 1);
mv.visitEnd();
復(fù)制代碼

其中關(guān)于Label的咱不需要,所以只剩下核心代碼

mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("Hello World!");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
復(fù)制代碼

到這里,ASM的基本使用已經(jīng)告一段落.ASM可操作性非常強(qiáng),人有多大膽,地有多大產(chǎn).只要你想實(shí)現(xiàn)的,基本都能實(shí)現(xiàn).關(guān)鍵在于你的想法.但是有個(gè)小問(wèn)題,上面的插件只能生成一些簡(jiǎn)單的代碼,如果需要寫(xiě)一些復(fù)雜的邏輯,就必須深入Java字節(jié)碼,才能自己寫(xiě)出來(lái)或者是看懂ASM的插樁代碼.

3. ASM 實(shí)戰(zhàn) 防快速點(diǎn)擊(抖動(dòng))

上面那個(gè)小demo在每個(gè)方法里面打印一句"Hello World!"好像沒(méi)什么實(shí)際意義..咱決定做個(gè)有實(shí)際意義的東西,一般情況下,我們?cè)谧鲩_(kāi)發(fā)的會(huì)去防止用戶快速點(diǎn)擊某個(gè)View.這是為了追求更好的用戶體驗(yàn),如果不處理的話,在快速點(diǎn)擊Button的時(shí)候可能會(huì)連續(xù)打開(kāi)2個(gè)相同的界面,在用戶看來(lái)確實(shí)有點(diǎn)奇怪,影響體驗(yàn).所以,一般情況下,我們會(huì)去做一下限制.

處理的時(shí)候,其實(shí)也很簡(jiǎn)單,我們只需要取快速點(diǎn)擊事件中的其中一次點(diǎn)擊事件就行了.有哪些方案進(jìn)行處理呢?下面是我想到的幾種

1. 在BaseActivity的dispatchTouchEvent里判斷一下,如果ACTION_DOWN&&快速點(diǎn)擊則返回true就行.
2. 寫(xiě)一個(gè)工具類(lèi),記錄上一次點(diǎn)擊的時(shí)間,每次在onClick里面判斷一下,是否為快速點(diǎn)擊,如果是,則不響應(yīng)事件.
3. 可以在方案2的基礎(chǔ)上,記錄每個(gè)View上一次的點(diǎn)擊時(shí)間,控制更為精準(zhǔn).

下面是我簡(jiǎn)單實(shí)現(xiàn)的一個(gè)工具類(lèi)FastClickUtil.java

public class FastClickUtil {

    private static final int FAST_CLICK_TIME_DISTANCE = 300;
    private static long sLastClickTime = 0;

    public static boolean isFastDoubleClick() {
        long time = System.currentTimeMillis();
        long timeDistance = time - sLastClickTime;
        if (0 < timeDistance && timeDistance < FAST_CLICK_TIME_DISTANCE) {
            return true;
        }
        sLastClickTime = time;
        return false;
    }

}
復(fù)制代碼

有了這個(gè)工具類(lèi),那咱們就可以在每個(gè)onClick方法的最前面插入isFastDoubleClick()判斷語(yǔ)句,簡(jiǎn)單判斷一下即可實(shí)現(xiàn)防抖.就像下面這樣:

public void onClick(View view) {
    if (!FastClickUtil.isFastDoubleClick()) {
        ......
    }
}
復(fù)制代碼

為了實(shí)現(xiàn)上面這個(gè)最終效果,我們其實(shí)只需要這樣做:

1. 找到onClick方法
2. 進(jìn)行插樁

除了自定義ClassVisitor,其他代碼是和上面的demo差不多的,咱直接看自定義ClassVisitor.

class FastClickClassVisitor extends ClassVisitor {

    FastClickClassVisitor(ClassVisitor classVisitor) {
        super(Opcodes.ASM7, classVisitor)
    }

    @Override
    MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        def methodVisitor = cv.visitMethod(access, name, descriptor, signature, exceptions)
        if (name == "onClick" && descriptor == "(Landroid/view/View;)V") {
            return new FastMethodVisitor(api, methodVisitor, access, name, descriptor)
        } else {
            return methodVisitor
        }
    }
}
復(fù)制代碼

在ClassVisitor里面的visitMethod里面,只需要找到onClick方法,然后自定義自己的MethodVisitor.

class FastMethodVisitor extends AdviceAdapter {

    FastMethodVisitor(int api, MethodVisitor methodVisitor, int access, String name, String descriptor) {
        super(api, methodVisitor, access, name, descriptor)
    }

    //方法進(jìn)入
    @Override
    protected void onMethodEnter() {
        super.onMethodEnter()
        mv.visitMethodInsn(INVOKESTATIC, "com/xfhy/gradledemo/FastClickUtil", "isFastDoubleClick", "()Z", false)
        Label label = new Label()
        mv.visitJumpInsn(IFEQ, label)
        mv.visitInsn(RETURN)
        mv.visitLabel(label)
    }
}
復(fù)制代碼

在方法進(jìn)入(onMethodEnter())里面調(diào)用FastClickUtil的靜態(tài)方法isFastDoubleClick()判斷一下即可.到此,我們的小案例計(jì)算全部完成了.可以看到,利用ASM輕輕松松就能實(shí)現(xiàn)我們之前看起來(lái)比較麻煩的功能,而且低侵入性,不用改動(dòng)之前的所有代碼.

插樁之后可以將編譯完成的apk直接拖入jadx里面看一下最終源碼驗(yàn)證,也可以直接將apk安裝到手機(jī)上進(jìn)行驗(yàn)證.

當(dāng)然了,上面的這種實(shí)現(xiàn)有些不太人性化的地方.比如某些View的點(diǎn)擊事件,不需要防抖.怎么辦?用上面這種方式不太合適,咱可以自定義一個(gè)注解,在不需要處理防抖的onClick方法上標(biāo)注一下這個(gè)注解.然后在ASM這邊判斷一下,如果某onClick方法上有這個(gè)注解就不進(jìn)行插樁.事情完美解決.這里就不帶著大家實(shí)現(xiàn)了,留給大家課后實(shí)踐.

image

作者：瀟風(fēng)寒月
鏈接：https://juejin.im/post/6864349303843307534