Gradle插件實戰之編譯期修改代碼-有解無憂

背景

在作業中我們經常會用到第三方庫，不可避免這些庫中會有各種問題，沒辦法只有給開源庫作者提issue，但是這種效率很低，而且作者不一定會去修改，因此只有自己去改，

解決方案

我們可以把專案chone下來修改，但是這種效率很低，也可能會遇到不可預知的問題，這樣大大增加了開發成本，
開發Gradle插件，利用Javassit動態修改class中已有的方法，這種方法效率很高，不會影響到原始碼，

Javassit

javassist是一個動態修改java位元組碼的開源庫，它可以在編譯好的class檔案中添加/修改方法、插入代碼等，并且不需要對位元組碼方面有深入的了解，同時也可以去生成一個新的類物件，通過完全手動的方式， javassit具體的使用方法可以查看：Tutorial-1、Tutorial-2、Tutorial-3

Gradle

Android Studio 專案是使用 Gradle 構建的，構建工具 Gradle 可以看做是一個腳本，包含一系列的Task，依次執行這些 Task 后，專案就打包成功了，自定義 Gradle 插件的本質就是把邏輯獨立的代碼進行抽取和封裝，以便于我們更高效地通過插件依賴這一方式進行功能復用，而在 Android 下的 gradle 插件共分為兩大類：

腳本插件：同普通的 gradle 腳本撰寫形式一樣，可以直接寫在build.gradle檔案中，也可以自己新建一個 gradle 腳本檔案中寫
物件插件：通過插件全路徑類名或 id 參考，它主要有三種撰寫形式，如下所示：
1）在當前構建腳本下直接撰寫，
2）在 buildSrc 目錄下撰寫，
3）在完全獨立的專案中撰寫，

buildSrc

我們就使用buildSrc默認插件目錄，該目錄下的代碼會在構建時自動地進行編譯打包，然后它會被添加到 buildScript 中的 classpath 下，所以不需要任何額外的配置，就可以直接被其他模塊中的 gradle 腳本參考，注意：在Gradle 6.0版本以上，不要在settings.gradle檔案中配置，否則會產生：'buildSrc' cannot be used as a project name as it is a reserved name例外

buildSrc 的執行時機不僅早于任何?個 project（build.gradle），而且也早于 settings.gradle，
settings.gradle 中如果配置了 ‘:buildSrc’ ，buildSrc ?錄就會被當做是子 Project ，因會它會被執行兩遍，所以在 settings.gradle 里面應該刪掉 ‘:buildSrc’ 的配置，

步驟

1.在專案根目錄新建一個module，命名為buildSrc且名字固定，
2.src 目錄下洗掉僅保留一個空的 main 目錄，并在 main 目錄下新建 1 個groovy目錄與 1 個resources目錄，
3.洗掉build.gradles所有配置，并添加以下配置

apply plugin: 'groovy'

dependencies {
    implementation gradleApi()
    implementation localGroovy()
    implementation "com.android.tools.build:gradle:4.1.0"
    implementation "commons-io:commons-io:2.4"
    implementation "org.javassist:javassist:3.25.0-GA"
}
repositories {
    google()
    jcenter()
}

4.在groovy目錄中創建你自己的包名com.gh.gamecenter.plugin，然后創建兩個groovy類，分別繼承Plugin和Transform，代碼如下：

class GhTransform extends Transform {
  ......
}

class GhPlugin implements Plugin<Project> {
    void apply(Project project) {
        project.android.registerTransform(new GhTransform(project))
    }
}

5.在 resources 目錄下創建一個 META-INF.gradle-plugins 的目錄，然后里面創建一個com.gh.gamecenter.plugin.properties檔案，properties之前的內容是插件的名字，在該檔案中添加如下內容：

implementation-class=com.gh.gamecenter.plugin.GhPlugin

6.最后我們在build.gradle中引入我們的插件，這樣我們就基本配置完了，

apply plugin: "com.gh.gamecenter.plugin"
android {
......
}

以上就是自定義插件的基本配置，接下來就是實作插件功能

Transform

Google 官方在 Android Gradle V1.5.0 版本以后提供了 Transfrom API, 允許第三方 Plugin 在打包成 .dex 檔案之前的編譯程序中操作 .class 檔案，我們需要做的就是實作 Transform 來對 .class 檔案遍歷以拿到所有方法，修改完成后再對原檔案進行替換即可，

在文章背景中我們講到開發插件的目的是修改第三方開源庫中一個類的方法，具體是需要在這個方法之前加入一段我們自己的代碼來根據需求實作攔截，我的做法是：在專案中寫一個靜態方法，然后在這個方法之前呼叫我們的靜態方法，這樣就可以實作攔截功能了，具體代碼如下：

class GhTransform extends Transform {

    private ClassPool classPool = ClassPool.getDefault()
    Project project

    GhTransform(Project project) {
        this.project = project
    }

    @Override
    String getName() {
        return "GhTransform"
    }
    /**
      * 需要處理的資料型別，目前 ContentType有六種列舉型別，通常我們使用比較頻繁的有前兩種：
      * 1、CONTENT_CLASS：表示需要處理 java 的 class 檔案，
      * 2、CONTENT_JARS：表示需要處理 java 的 class 與 資源檔案，
      * 3、CONTENT_RESOURCES：表示需要處理 java 的資源檔案，
      * 4、CONTENT_NATIVE_LIBS：表示需要處理 native 庫的代碼，
      * 5、CONTENT_DEX：表示需要處理 DEX 檔案，
      * 6、CONTENT_DEX_WITH_RESOURCES：表示需要處理 DEX 與 java 的資源檔案， 
     */
    @Override
    Set<QualifiedContent.ContentType> getInputTypes() {
        return TransformManager.CONTENT_CLASS
    }

    /**
      * Transform 要操作的內容范圍，目前 Scope 有五種基本型別：
      * 1、PROJECT：只有專案內容
      * 2、SUB_PROJECTS：只有子專案
      * 3、EXTERNAL_LIBRARIES：只有外部庫
      * 4、TESTED_CODE：由當前變體（包括依賴項）所測驗的代碼
      * 5、PROVIDED_ONLY：只提供本地或遠程依賴項
      * SCOPE_FULL_PROJECT 是一個Scope集合，包含Scope.PROJECT,Scope.SUB_PROJECTS,Scope.EXTERNAL_LIBRARIES 這三項，即當前Transform的作用域包括當前專案、子專案以及外部的依賴庫
     */
    @Override
    Set<? super QualifiedContent.Scope> getScopes() {
        //通常我們使用 SCOPE_FULL_PROJECT
        return TransformManager.SCOPE_FULL_PROJECT
    }

    /**
     * 是否需要增量編譯
     */
    @Override
    boolean isIncremental() {
        return false
    }

    @Override
    void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
        super.transform(transformInvocation)
        //添加加android.jar目錄
        classPool.appendClassPath(project.android.bootClasspath[0].toString())
        def outputProvider = transformInvocation.outputProvider
        // 洗掉之前的輸出
        if (outputProvider != null) {
            outputProvider.deleteAll()
        }
        transformInvocation.inputs.each { input ->
            input.directoryInputs.each { dirInput ->
                handleDirectory(dirInput.file)

                def dest = outputProvider.getContentLocation(dirInput.name, dirInput.contentTypes, dirInput.scopes, Format.DIRECTORY)
                // 將input的目錄復制到output指定目錄
                FileUtils.copyDirectory(dirInput.file, dest)
            }

        }
        transformInvocation.inputs.each { input ->
            input.jarInputs.each { jarInput ->
                if (jarInput.file.exists()) {
                    def srcFile = handleJar(jarInput.file)

                    //必須給jar重新命名，否則會沖突
                    def jarName = jarInput.name
                    def md5 = DigestUtils.md5Hex(jarInput.file.absolutePath)
                    if (jarName.endsWith(".jar")) {
                        jarName = jarName.substring(0, jarName.length() - 4)
                    }
                    def dest = outputProvider.getContentLocation(md5 + jarName, jarInput.contentTypes, jarInput.scopes, Format.JAR)
                    FileUtils.copyFile(srcFile, dest)
                }
            }
        }

    }

    void handleDirectory(File dir) {
        //將類路徑添加到classPool中
        classPool.insertClassPath(dir.absolutePath)
        if (dir.isDirectory()) {
            dir.eachFileRecurse { file ->
                def filePath = file.absolutePath
                classPool.insertClassPath(filePath)
                if (shouldModify(filePath)) {
                    def inputStream = new FileInputStream(file)
                    CtClass ctClass = modifyClass(inputStream)
                    ctClass.writeFile()
                    //呼叫detach方法釋放記憶體
                    ctClass.detach()
                }
            }
        }
    }

    /**
     * 主要步驟：
     * 1.遍歷所有jar檔案
     * 2.解壓jar然后遍歷所有的class
     * 3.讀取class的輸入流并使用javassit修改，然后保存到新的jar檔案中
     */
    File handleJar(File jarFile) {
        classPool.appendClassPath(jarFile.absolutePath)
        def inputJarFile = new JarFile(jarFile)
        def entries = inputJarFile.entries()
        //創建一個新的檔案
        def outputJarFile = new File(jarFile.parentFile, "temp_" + jarFile.name)
        if (outputJarFile.exists()) outputJarFile.delete()
        def jarOutputStream = new JarOutputStream(new BufferedOutputStream(new FileOutputStream(outputJarFile)))
        while (entries.hasMoreElements()) {
            def jarInputEntry = entries.nextElement()
            def jarInputEntryName = jarInputEntry.name

            def outputJarEntry = new JarEntry(jarInputEntryName)
            jarOutputStream.putNextEntry(outputJarEntry)

            def inputStream = inputJarFile.getInputStream(jarInputEntry)
            if (!shouldModify(jarInputEntryName)) {
                jarOutputStream.write(IOUtils.toByteArray(inputStream))
                inputStream.close()
                continue
            }

            def ctClass = modifyClass(inputStream)
            def byteCode = ctClass.toBytecode()
            ctClass.detach()
            inputStream.close()
            jarOutputStream.write(byteCode)
            jarOutputStream.flush()
        }
        inputJarFile.close()
        jarOutputStream.closeEntry()
        jarOutputStream.flush()
        jarOutputStream.close()
        return outputJarFile
    }

    static boolean shouldModify(String filePath) {
        return filePath.endsWith(".class") &&
                !filePath.contains("R.class") &&
                !filePath.contains('$') &&
                !filePath.contains('R$') &&
                !filePath.contains("BuildConfig.class") &&
                filePath.contains("ExoSourceManager")
    }

    CtClass modifyClass(InputStream is) {
        def classFile = new ClassFile(new DataInputStream(new BufferedInputStream(is)))
        def ctClass = classPool.get(classFile.name)
        //判斷是否需要解凍
        if (ctClass.isFrozen()) {
            ctClass.defrost()
        }

        def method = ctClass.getDeclaredMethod("release")
        //必須使用全類名，否則編譯會找不到類
        def body = '''
            int size = com.gh.gamecenter.video.detail.CustomManager.getVideoManagerSize();
            if (size > 1) {
                android.util.Log.e(\"gh_tag\",\"攔截成功\");
                return;
            }
        '''
        method.insertBefore(body)
        return ctClass

    }
}

至此我們就完成了插件的開發，接下來就要驗證代碼是否插入成功，我們可以使用Android Studio自帶的Build/Analyze APK工具，選擇編譯的apk檔案
在這里插入圖片描述
找到修改的類，右鍵點擊 Show Bytecode查看位元組碼，然后搜索我們修改的方法：

上圖紅色框中就是添加的代碼，我在代碼中插入了一行log，運行代碼查看logcat列印：

最后我們完成了插件的開發并且驗證其有效性，雖然看來稍微有些麻煩，但是如果以后遇到類似的問題我們也可以基于上面的代碼來解決問題，

需要注意的一些問題

開源庫和自己寫的插入代碼注意不要混淆
buildSrc中build.gradle的AGP版本要和app模塊中一致
插入代碼參考的類要使用全路徑
插入代碼中用到的類需要將類路徑添加到classPool中，否則會編譯不過
buildSrc不要在settings.gradle中配置
不管我們有沒有修改jar的操作，也要拷貝到目標路徑

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/252166.html

標籤：其他

上一篇：Gradle進階計劃（一）Gradle初探

下一篇：android studio和jdk環境設定