概述

對於Javassist可理解成在java語言層面上來操縱java位元組碼的一種工具。經典應用場景是在構建java程式碼階段直接修改位元組碼，如程式碼插樁。

特點：

• 更改原有class：增、刪和修改class中的欄位或方法；修改類的繼承結構
• 新增class：增加欄位、方法、構造方法；注意不能新增介面。
• 新增介面：只適用於介面
• 新增註解：用於建立註解

核心基礎

1. CtClass：Javassist並不是直接操縱java位元組碼檔案（class），而是將class封裝抽象成CtClass，再使用CtClass來完成class的修改。

   • 獲取CtClass：藉助於ClassPool.get(String classname)方法，classname必須是全限定類名
     。
   • 輸出檔案：對於CtClass的修改僅是記憶體上的，如果需要持久化的修改則需要藉助於CtClass.writeFile方法，輸出路徑：rootProject/包名/類.class
   • CtClass狀態：分為凍結與解凍狀態，當CtClass執行了writeFile、toClass或 toBytecode方法後CtClass會進入凍結狀態，處於凍結狀態的CtClass不能被修改。
   • 凍結與解凍：使用freeze方法對CtClass凍結，使用defrost方法對CtClass解凍。
   • 繼承與實現：修改類繼承結構，extend使用setSuperclass方法，implements則使用setInterfaces方法。

2. ClassPool：專門用於存放CtClass容器，所有的CtClass物件例項必須使用ClassPool來獲取。

   • 獲取CtClass範圍：預設ClassPool所獲取到的CtClass範圍除了本工程程式碼，還包括java、javax以及classpath配置中的路徑，至於遠端路徑則需要額外的配置。
   • 新增CtClass：makeClass用於建立新的位元組碼檔案，注意不能建立介面，但能建立抽象類。
   • 新增介面：makeInterface專門用於建立新的介面，注意介面方法只能通過CtNewMethod.abstractMethod來建立。

3. CtField：Javassist將class中的成員變數抽象成CtField，藉助於CtField來實現對class中的成員變數的操縱。

   • 新建CtField：使用CtField.make方法完成CtField物件的建立，注意建立的語句必須以分號結尾，否則拋CannotCompileException異常。
   • CtField與CtClass關係：新建好的CtField通過CtClass.addField新增到CtClass。

4. CtMethod：Javassist將class中除了構造方法以外的其它方法抽象成CtMethod，藉助於CtMethod來實現對class中的這些方法的操縱。

   • 新建CtMethod：CtMethod提供了幾個靜態make方法，也可使用專門構造CtMethod例項的CtNewMethod類來實現。
   • CtNewMethod：簡單理解就是一個工廠類，執行建立普通方法、抽象方法、setter/getter等方法。
   • CtMethod與CtClass關係：新建好的CtField通過CtClass.addMethod新增到CtClass。

5. CtConstructor：Javassist單獨將class中的構造方法抽象成CtConstructor，藉助於CtConstructor來實現對class中的構造方法的操縱。

   • 新建CtConstructor：使用幾個過載的CtConstructor方法，也可使用專門構造CtConstructor例項的CtNewConstructor類來實現。
   • 修改方法體：CtConstructor.setBody，注意方法體是必須包含在{}中。
   • CtConstructor與CtClass關係：新建好的CtField通過CtClass.addConstructor新增到CtClass。

程式碼注入

1. 對於CtMethod，Javassist提供了簡潔的程式碼注入方式以實現對現有的方法的變更：

   • 方法執行前：CtMethod的insertBefore能將程式碼直接注入到方法體的最前方，藉助於此方法可以實現對方法執行流程的攔截。
   • 方法執行後：CtMethod的insertBefore能將程式碼直接注入到方法體執行完畢返回之前，藉助於此方法可以實現對方法返回值的攔截。
   • 位元組碼某處注入：CtMethod的insertAt能將程式碼直接注入到位元組碼的某一行處。

2. 對於CtConstructor，除了支援上述CtMethod的幾種注入方式之外，還支援以下方式：

   • insertBeforeBody：相比insertBefore，insertBeforeBody更適合構造方法包含super或this的注入
   • setBody：可以直接重寫方法體程式碼。

3. 注入語法：Javassist的注入的程式碼其實只是一段字串，要想與方法的引數、返回值、類例項（this）等建立關係就必須規定相關的語法規則：
   

   $0：代表的方法所在的類例項this，即在注入字串中使用$0將會被翻譯成this物件；
   $1，$2，...：方法引數列表，順序是一一對應的； 
   $r，$w：用於型別轉換表示式裡，否則轉換不生效而編譯失敗
   $_：返回值

Android專案實踐

1. 目標：新建一個Device類，並實現一個EventListener介面，最後將Device插入到MainActivity位元組碼檔案裡。

2. 新建一個普通的Android專案，如下圖
   

3. 在上述新建好的Android專案上再新建一個Gradle外掛模組buildSrc，此處不再贅述，具體看自定義Gradle外掛，如下圖：
   

4. 在buildSrc的build.gradle配置javassist依賴，如下：

   dependencies {
       compile 'org.javassist:javassist:3.20.0-GA'
   }

5. BytecodePlugin與BytecodeTransform都是普通Gradle外掛程式碼，在BytecodeTransform的transform中呼叫BytecodeModifier，注意包名的寫法，如下

   BytecodeModifier.injectCode(directoryInput.file.absolutePath, "com\\example\\transform")

6. BytecodeModifier程式碼如下：

   public static void injectCode(String path, String packageName) {
       File dir = new File(path)
       if (dir.isDirectory()) {
           dir.eachFileRecurse { File file ->
               String filePath = file.absolutePath
               if (filePath.endsWith(".class")
                   && filePath.contains(packageName)
                   && filePath.contains('MainActivity')
                   && !filePath.contains('R$')
                   && !filePath.contains('R.class')
                   && !filePath.contains("BuildConfig.class")) {
   
                   LogHelper.debug("path:" + path + ",filePath:" + filePath)
   
                   // 建立一個Device.class並設定成MainActivity的成員變數
                   CtClass deviceClass = JavassistManager.createDeviceClass(path)
                   if (deviceClass != null) {
                       JavassistManager.injectToMainActivity(path, deviceClass)
                   }
               }
           }
       }
   }

7. 最後所有的位元組碼操縱都由JavassistManager實現，如下：

   public static void injectToMainActivity(String path, CtClass ctClass) {
       ClassPool pool = ClassPool.getDefault();
       CtClass mainActivity;
       try {
           pool.appendClassPath(path);
           mainActivity = pool.get("com.example.transform.MainActivity");
           if (mainActivity.isFrozen()) {
               mainActivity.defrost();
           }
   
           CtField ctField = new CtField(ctClass, "device", mainActivity);
           mainActivity.addField(ctField);
           mainActivity.writeFile(path);
       } catch (NotFoundException e) {
           e.printStackTrace();
       } catch (CannotCompileException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
   
   public static CtClass createDeviceClass(String path) {
       String className = "com.example.transform.Device";
       ClassPool pool = ClassPool.getDefault();
       CtClass cc = pool.makeClass(className);
   
       try {
           CtField ctField = CtField.make("String deviceId;", cc);
           cc.addField(ctField);
   
           CtConstructor con = CtNewConstructor.make(new CtClass[]{pool.get("java.lang.String")}, null, "{this" +
               ".deviceId = \"1234567890\";}", cc);
           cc.addConstructor(con);
   
           CtMethod ctMethod = CtNewMethod.abstractMethod(CtClass.voidType, "update", null, null, cc);
           cc.addMethod(ctMethod);
   
           CtClass eventListener = createEventListener(path);
           if (eventListener != null) {
               cc.setInterfaces(new CtClass[]{eventListener});
           }
   
           cc.writeFile(path);
           return cc;
       } catch (CannotCompileException e) {
           e.printStackTrace();
       } catch (NotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
       return null;
   }
   
   private static CtClass createEventListener(String path) {
       String className = "com.example.transform.EventListener";
       ClassPool pool = ClassPool.getDefault();
       CtClass cc = pool.makeInterface(className);
   
       try {
           CtMethod ctMethod = CtNewMethod.abstractMethod(CtClass.voidType, "onCreate", null, null, cc);
           cc.addMethod(ctMethod);
   
           CtMethod ctMethod1 = CtNewMethod.abstractMethod(CtClass.voidType, "onDestroy", null, null, cc);
           cc.addMethod(ctMethod1);
   
           cc.writeFile(path);
           return cc;
       } catch (CannotCompileException e) {
           e.printStackTrace();
       } catch (NotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
       return null;
   }

8. 編譯執行，生成如下class，如下圖：
   

   Device.class

   public abstract class Device implements EventListener {
   
       String deviceId = "1234567890";
   
       public Device(String var1) {
       }
   
       public abstract void update();
   }

   EventListener.class

   public interface EventListener {
       void onCreate();
   
       void onDestroy();
   }

   MainActivity.class

   public class MainActivity extends AppCompatActivity {
       Device device;
   
       public MainActivity() {
       }
   
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           this.setContentView(2130968603);
       }
   }

9. 注意，如果要操作的是Android.jar相關的位元組碼，則需要新增如下的classpath，如下程式碼：

   private static void addAndroidClassPath(Project project) {
       String androidClassPath = project.android.bootClasspath[0].toString();
       pool = ClassPool.getDefault();
       pool.appendClassPath(androidClassPath)
       // 匯入widget包
       pool.importPackage("android.widget")
       // 匯入app包
       pool.importPackage("android.app")
       ... ...
   }

10. 小結：Javassist提供了非常便利的API來實現對class位元組碼檔案的強大的操縱能力。