javaagent使用指南

今天打算寫一下 Javaagent，一開始我對它的概念也比較陌生，後來在别人口中聽到

位元組碼插樁

，

bTrace

Arthas

後面才逐漸了解到Java還提供了這麼個工具。

JVM啟動前靜态Instrument

Javaagent 是什麼？

Javaagent是java指令的一個參數。參數 javaagent 可以用于指定一個 jar 包，并且對該 java 包有2個要求：

1. 這個 jar 包的 MANIFEST.MF 檔案必須指定 Premain-Class 項。
2. Premain-Class 指定的那個類必須實作 premain() 方法。

premain 方法，從字面上了解，就是運作在 main 函數之前的的類。當Java 虛拟機啟動時，在執行 main 函數之前，JVM 會先運作

-javaagent

所指定 jar 包内 Premain-Class 這個類的 premain 方法 。

在指令行輸入

java

可以看到相應的參數，其中有 和 java agent相關的：

-agentlib:<libname>[=<選項>] 加載本機代理庫 <libname>, 例如 -agentlib:hprof
	另請參閱 -agentlib:jdwp=help 和 -agentlib:hprof=help
-agentpath:<pathname>[=<選項>]
	按完整路徑名加載本機代理庫
-javaagent:<jarpath>[=<選項>]
	加載 Java 程式設計語言代理, 請參閱 java.lang.instrument
           

在上面

-javaagent

參數中提到了參閱

java.lang.instrument

，這是在

rt.jar

中定義的一個包，該路徑下有兩個重要的類：

該包提供了一些工具幫助開發人員在 Java 程式運作時，動态修改系統中的 Class 類型。其中，使用該軟體包的一個關鍵元件就是 Javaagent。從名字上看，似乎是個 Java 代理之類的，而實際上，他的功能更像是一個Class 類型的轉換器，他可以在運作時接受重新外部請求，對Class類型進行修改。

從本質上講，Java Agent 是一個遵循一組嚴格約定的正常 Java 類。 上面說到 javaagent指令要求指定的類中必須要有premain()方法，并且對premain方法的簽名也有要求，簽名必須滿足以下兩種格式：

public static void premain(String agentArgs, Instrumentation inst)
    
public static void premain(String agentArgs)
           

JVM 會優先加載 帶

Instrumentation

簽名的方法，加載成功忽略第二種，如果第一種沒有，則加載第二種方法。這個邏輯在sun.instrument.InstrumentationImpl 類中：

Instrumentation 類 定義如下：

public interface Instrumentation {
    
    //增加一個Class 檔案的轉換器，轉換器用于改變 Class 二進制流的資料，參數 canRetransform 設定是否允許重新轉換。
    void addTransformer(ClassFileTransformer transformer, boolean canRetransform);

    //在類加載之前，重新定義 Class 檔案，ClassDefinition 表示對一個類新的定義，如果在類加載之後，需要使用 retransformClasses 方法重新定義。addTransformer方法配置之後，後續的類加載都會被Transformer攔截。對于已經加載過的類，可以執行retransformClasses來重新觸發這個Transformer的攔截。類加載的位元組碼被修改後，除非再次被retransform，否則不會恢複。
    void addTransformer(ClassFileTransformer transformer);

    //删除一個類轉換器
    boolean removeTransformer(ClassFileTransformer transformer);

    boolean isRetransformClassesSupported();

    //在類加載之後，重新定義 Class。這個很重要，該方法是1.6 之後加入的，事實上，該方法是 update 了一個類。
    void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;

    boolean isRedefineClassesSupported();

    
    void redefineClasses(ClassDefinition... definitions)
        throws  ClassNotFoundException, UnmodifiableClassException;

    boolean isModifiableClass(Class<?> theClass);

    @SuppressWarnings("rawtypes")
    Class[] getAllLoadedClasses();

  
    @SuppressWarnings("rawtypes")
    Class[] getInitiatedClasses(ClassLoader loader);

    //擷取一個對象的大小
    long getObjectSize(Object objectToSize);


   
    void appendToBootstrapClassLoaderSearch(JarFile jarfile);

    
    void appendToSystemClassLoaderSearch(JarFile jarfile);

    
    boolean isNativeMethodPrefixSupported();

    
    void setNativeMethodPrefix(ClassFileTransformer transformer, String prefix);
}
           

最為重要的是上面注釋的幾個方法，下面我們會用到。

如何使用javaagent？

使用 javaagent 需要幾個步驟：

1. 定義一個 MANIFEST.MF 檔案，必須包含 Premain-Class 選項，通常也會加入Can-Redefine-Classes 和 Can-Retransform-Classes 選項。
2. 建立一個Premain-Class 指定的類，類中包含 premain 方法，方法邏輯由使用者自己确定。
3. 将 premain 的類和 MANIFEST.MF 檔案打成 jar 包。
4. 使用參數 -javaagent: jar包路徑 啟動要代理的方法。

在執行以上步驟後，JVM 會先執行 premain 方法，大部分類加載都會通過該方法，注意：是大部分，不是所有。當然，遺漏的主要是系統類，因為很多系統類先于 agent 執行，而使用者類的加載肯定是會被攔截的。也就是說，這個方法是在 main 方法啟動前攔截大部分類的加載活動，既然可以攔截類的加載，那麼就可以去做重寫類這樣的操作，結合第三方的位元組碼編譯工具，比如ASM，javassist，cglib等等來改寫實作類。

通過上面的步驟我們用代碼實作來實作。實作 javaagent 你需要搭建兩個工程，一個工程是用來承載 javaagent類，單獨的打成jar包；一個工程是javaagent需要去代理的類。即javaagent會在這個工程中的main方法啟動之前去做一些事情。

1.首先來實作javaagent工程。

工程目錄結構如下：

-java-agent
----src
--------main
--------|------java
--------|----------com.rickiyang.learn
--------|------------PreMainTraceAgent
--------|resources
-----------META-INF
--------------MANIFEST.MF
           

第一步是需要建立一個類，包含premain 方法：

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;

/**
 * @author: rickiyang
 * @date: 2019/8/12
 * @description:
 */
public class PreMainTraceAgent {

    public static void premain(String agentArgs, Instrumentation inst) {
        System.out.println("agentArgs : " + agentArgs);
        inst.addTransformer(new DefineTransformer(), true);
    }

    static class DefineTransformer implements ClassFileTransformer{

        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
            System.out.println("premain load Class:" + className);
            return classfileBuffer;
        }
    }
}

           

上面就是我實作的一個類，實作了帶Instrumentation參數的premain()方法。調用addTransformer()方法對啟動時所有的類進行攔截。

然後在 resources 目錄下建立目錄：META-INF，在該目錄下建立檔案：MANIFREST.MF：

Manifest-Version: 1.0
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Premain-Class: PreMainTraceAgent

           

注意到第5行有空行。

說一下MANIFREST.MF檔案的作用，這裡如果你不去手動指定的話，直接 打包，預設會在打包的檔案中生成一個MANIFREST.MF檔案：

Manifest-Version: 1.0
Implementation-Title: test-agent
Implementation-Version: 0.0.1-SNAPSHOT
Built-By: yangyue
Implementation-Vendor-Id: com.rickiyang.learn
Spring-Boot-Version: 2.0.9.RELEASE
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.rickiyang.learn.LearnApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Created-By: Apache Maven 3.5.2
Build-Jdk: 1.8.0_151
Implementation-URL: https://projects.spring.io/spring-boot/#/spring-bo
 ot-starter-parent/test-agent
           

這是預設的檔案，包含目前的一些版本資訊，目前工程的啟動類，它還有别的參數允許你做更多的事情，可以用上的有：

Premain-Class ：包含 premain 方法的類（類的全路徑名）

Agent-Class ：包含 agentmain 方法的類（類的全路徑名）

Boot-Class-Path ：設定引導類加載器搜尋的路徑清單。查找類的特定于平台的機制失敗後，引導類加載器會搜尋這些路徑。按列出的順序搜尋路徑。清單中的路徑由一個或多個空格分開。路徑使用分層 URI 的路徑元件文法。如果該路徑以斜杠字元（“/”）開頭，則為絕對路徑，否則為相對路徑。相對路徑根據代理 JAR 檔案的絕對路徑解析。忽略格式不正确的路徑和不存在的路徑。如果代理是在 VM 啟動之後某一時刻啟動的，則忽略不表示 JAR 檔案的路徑。（可選）

Can-Redefine-Classes ：true表示能重定義此代理所需的類，預設值為 false（可選）

Can-Retransform-Classes ：true 表示能重轉換此代理所需的類，預設值為 false （可選）

Can-Set-Native-Method-Prefix： true表示能設定此代理所需的本機方法字首，預設值為 false（可選）

即在該檔案中主要定義了程式運作相關的配置資訊，程式運作前會先檢測該檔案中的配置項。

一個java程式中

-javaagent

參數的個數是沒有限制的，是以可以添加任意多個javaagent。所有的java agent會按照你定義的順序執行，例如：

java -javaagent:agent1.jar -javaagent:agent2.jar -jar MyProgram.jar
           

程式執行的順序将會是：

MyAgent1.premain -> MyAgent2.premain -> MyProgram.main

說回上面的 javaagent工程，接下來将該工程打成jar包，我在打包的時候發現打完包之後的 MANIFREST.MF檔案被預設配置替換掉了。是以我是手動将上面我的配置檔案替換到jar包中的檔案，這裡你需要注意。

另外的再說一種不去手動寫MANIFREST.MF檔案的方式，使用maven插件：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.1.0</version>
    <configuration>
        <archive>
            <!--自動添加META-INF/MANIFEST.MF -->
            <manifest>
                <addClasspath>true</addClasspath>
            </manifest>
            <manifestEntries>
                <Premain-Class>com.rickiyang.learn.PreMainTraceAgent</Premain-Class>
                <Agent-Class>com.rickiyang.learn.PreMainTraceAgent</Agent-Class>
                <Can-Redefine-Classes>true</Can-Redefine-Classes>
                <Can-Retransform-Classes>true</Can-Retransform-Classes>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>
           

用這種插件的方式也可以自動生成該檔案。

agent代碼就寫完了，下面再重新開一個工程，你隻需要寫一個帶 main 方法的類即可：

public class TestMain {

    public static void main(String[] args) {
        System.out.println("main start");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main end");
    }
}
           

很簡單，然後需要做的就是将上面的 代理類 和 這個測試類關聯起來。有兩種方式：

如果你用的是idea，那麼你可以點選菜單： run-debug configuration，然後将你的代理類包 指定在 啟動參數中即可：

另一種方式是不用 編譯器，采用指令行的方法。與上面大緻相同，将 上面的測試類編譯成 class檔案，然後 運作該類即可：

#将該類編譯成class檔案
 > javac TestMain.java
 
 #指定agent程式并運作該類
 > java -javaagent:c:/alg.jar TestMain
           

使用上面兩種方式都可以運作,輸出結果如下：

D:\soft\jdk1.8\bin\java.exe -javaagent:c:/alg.jar "-javaagent:D:\soft\IntelliJ IDEA 2019.1.1\lib\idea_rt.jar=54274:D:\soft\IntelliJ IDEA 2019.1.1\bin" -Dfile.encoding=UTF-8 -classpath D:\soft\jdk1.8\jre\lib\charsets.jar;D:\soft\jdk1.8\jre\lib\deploy.jar;D:\soft\jdk1.8\jre\lib\ext\access-bridge-64.jar;D:\soft\jdk1.8\jre\lib\ext\cldrdata.jar;D:\soft\jdk1.8\jre\lib\ext\dnsns.jar;D:\soft\jdk1.8\jre\lib\ext\jaccess.jar;D:\soft\jdk1.8\jre\lib\ext\jfxrt.jar;D:\soft\jdk1.8\jre\lib\ext\localedata.jar;D:\soft\jdk1.8\jre\lib\ext\nashorn.jar;D:\soft\jdk1.8\jre\lib\ext\sunec.jar;D:\soft\jdk1.8\jre\lib\ext\sunjce_provider.jar;D:\soft\jdk1.8\jre\lib\ext\sunmscapi.jar;D:\soft\jdk1.8\jre\lib\ext\sunpkcs11.jar;D:\soft\jdk1.8\jre\lib\ext\zipfs.jar;D:\soft\jdk1.8\jre\lib\javaws.jar;D:\soft\jdk1.8\jre\lib\jce.jar;D:\soft\jdk1.8\jre\lib\jfr.jar;D:\soft\jdk1.8\jre\lib\jfxswt.jar;D:\soft\jdk1.8\jre\lib\jsse.jar;D:\soft\jdk1.8\jre\lib\management-agent.jar;D:\soft\jdk1.8\jre\lib\plugin.jar;D:\soft\jdk1.8\jre\lib\resources.jar;D:\soft\jdk1.8\jre\lib\rt.jar;D:\workspace\demo1\target\classes;E:\.m2\repository\org\springframework\boot\spring-boot-starter-aop\2.1.1.RELEASE\spring-
...
...
...
1.8.11.jar;E:\.m2\repository\com\google\guava\guava\20.0\guava-20.0.jar;E:\.m2\repository\org\apache\commons\commons-lang3\3.7\commons-lang3-3.7.jar;E:\.m2\repository\com\alibaba\fastjson\1.2.54\fastjson-1.2.54.jar;E:\.m2\repository\org\springframework\boot\spring-boot\2.1.0.RELEASE\spring-boot-2.1.0.RELEASE.jar;E:\.m2\repository\org\springframework\spring-context\5.1.3.RELEASE\spring-context-5.1.3.RELEASE.jar com.springboot.example.demo.service.TestMain
agentArgs : null
premain load Class     :java/util/concurrent/ConcurrentHashMap$ForwardingNode
premain load Class     :sun/nio/cs/ThreadLocalCoders
premain load Class     :sun/nio/cs/ThreadLocalCoders$1
premain load Class     :sun/nio/cs/ThreadLocalCoders$Cache
premain load Class     :sun/nio/cs/ThreadLocalCoders$2
premain load Class     :java/util/jar/Attributes
premain load Class     :java/util/jar/Manifest$FastInputStream
...
...
...
premain load Class     :java/lang/Class$MethodArray
premain load Class     :java/lang/Void
main start
premain load Class     :sun/misc/VMSupport
premain load Class     :java/util/Hashtable$KeySet
premain load Class     :sun/nio/cs/ISO_8859_1$Encoder
premain load Class     :sun/nio/cs/Surrogate$Parser
premain load Class     :sun/nio/cs/Surrogate
...
...
...
premain load Class     :sun/util/locale/provider/LocaleResources$ResourceReference
main end
premain load Class     :java/lang/Shutdown
premain load Class     :java/lang/Shutdown$Lock

Process finished with exit code 0

           

上面的輸出結果我們能夠發現：

1. 執行main方法之前會加載所有的類，包括系統類和自定義類；
2. 在ClassFileTransformer中會去攔截系統類和自己實作的類對象；
3. 如果你有對某些類對象進行改寫，那麼在攔截的時候抓住該類使用位元組碼編譯工具即可實作。

下面是使用javassist來動态将某個方法替換掉：

package com.rickiyang.learn;

import javassist.*;

import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;

/**
 * @author rickiyang
 * @date 2019-08-06
 * @Desc
 */
public class MyClassTransformer implements ClassFileTransformer {
    @Override
    public byte[] transform(final ClassLoader loader, final String className, final Class<?> classBeingRedefined,final ProtectionDomain protectionDomain, final byte[] classfileBuffer) {
        // 操作Date類
        if ("java/util/Date".equals(className)) {
            try {
                // 從ClassPool獲得CtClass對象
                final ClassPool classPool = ClassPool.getDefault();
                final CtClass clazz = classPool.get("java.util.Date");
                CtMethod convertToAbbr = clazz.getDeclaredMethod("convertToAbbr");
                //這裡對 java.util.Date.convertToAbbr() 方法進行了改寫，在 return之前增加了一個 列印操作
                String methodBody = "{sb.append(Character.toUpperCase(name.charAt(0)));" +
                        "sb.append(name.charAt(1)).append(name.charAt(2));" +
                        "System.out.println(\"sb.toString()\");" +
                        "return sb;}";
                convertToAbbr.setBody(methodBody);

                // 傳回位元組碼，并且detachCtClass對象
                byte[] byteCode = clazz.toBytecode();
                //detach的意思是将記憶體中曾經被javassist加載過的Date對象移除，如果下次有需要在記憶體中找不到會重新走javassist加載
                clazz.detach();
                return byteCode;
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        // 如果傳回null則位元組碼不會被修改
        return null;
    }
}
           

JVM啟動後動态Instrument

上面介紹的Instrumentation是在 JDK 1.5中提供的，開發者隻能在main加載之前添加手腳，在 Java SE 6 的 Instrumentation 當中，提供了一個新的代理操作方法：agentmain，可以在 main 函數開始運作之後再運作。

跟

premain

函數一樣， 開發者可以編寫一個含有

agentmain

函數的 Java 類：

//采用attach機制，被代理的目标程式VM有可能很早之前已經啟動，當然其所有類已經被加載完成，這個時候需要借助Instrumentation#retransformClasses(Class<?>... classes)讓對應的類可以重新轉換，進而激活重新轉換的類執行ClassFileTransformer清單中的回調
public static void agentmain (String agentArgs, Instrumentation inst)

public static void agentmain (String agentArgs)
           

同樣，agentmain 方法中帶Instrumentation參數的方法也比不帶優先級更高。開發者必須在 manifest 檔案裡面設定“Agent-Class”來指定包含 agentmain 函數的類。

在Java6 以後實作啟動後加載的新實作是Attach api。Attach API 很簡單，隻有 2 個主要的類，都在

com.sun.tools.attach

包裡面：

1. VirtualMachine

   字面意義表示一個Java 虛拟機，也就是程式需要監控的目标虛拟機，提供了擷取系統資訊(比如擷取記憶體dump、線程dump，類資訊統計(比如已加載的類以及執行個體個數等)， loadAgent，Attach 和 Detach （Attach 動作的相反行為，從 JVM 上面解除一個代理）等方法，可以實作的功能可以說非常之強大 。該類允許我們通過給attach方法傳入一個jvm的pid(程序id)，遠端連接配接到jvm上 。

   代理類注入操作隻是它衆多功能中的一個，通過

   loadAgent

   方法向jvm注冊一個代理程式agent，在該agent的代理程式中會得到一個Instrumentation執行個體，該執行個體可以 在class加載前改變class的位元組碼，也可以在class加載後重新加載。在調用Instrumentation執行個體的方法時，這些方法會使用ClassFileTransformer接口中提供的方法進行處理。

2. VirtualMachineDescriptor

   則是一個描述虛拟機的容器類，配合 VirtualMachine 類完成各種功能。

attach實作動态注入的原理如下：

通過VirtualMachine類的

attach(pid)

方法，便可以attach到一個運作中的java程序上，之後便可以通過

loadAgent(agentJarPath)

來将agent的jar包注入到對應的程序，然後對應的程序會調用agentmain方法。

既然是兩個程序之間通信那肯定的建立起連接配接，VirtualMachine.attach動作類似TCP建立連接配接的三次握手，目的就是搭建attach通信的連接配接。而後面執行的操作，例如vm.loadAgent，其實就是向這個socket寫入資料流，接收方target VM會針對不同的傳入資料來做不同的處理。

我們來測試一下agentmain的使用：

工程結構和 上面premain的測試一樣，編寫AgentMainTest，然後使用maven插件打包 生成MANIFEST.MF。

package com.rickiyang.learn;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;

/**
 * @author rickiyang
 * @date 2019-08-16
 * @Desc
 */
public class AgentMainTest {

    public static void agentmain(String agentArgs, Instrumentation instrumentation) {
        instrumentation.addTransformer(new DefineTransformer(), true);
    }
    
    static class DefineTransformer implements ClassFileTransformer {

        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
            System.out.println("premain load Class:" + className);
            return classfileBuffer;
        }
    }
}

           

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <version>3.1.0</version>
  <configuration>
    <archive>
      <!--自動添加META-INF/MANIFEST.MF -->
      <manifest>
        <addClasspath>true</addClasspath>
      </manifest>
      <manifestEntries>
        <Agent-Class>com.rickiyang.learn.AgentMainTest</Agent-Class>
        <Can-Redefine-Classes>true</Can-Redefine-Classes>
        <Can-Retransform-Classes>true</Can-Retransform-Classes>
      </manifestEntries>
    </archive>
  </configuration>
</plugin>
           

将agent打包之後，就是編寫測試main方法。上面我們畫的圖中的步驟是：從一個attach JVM去探測目标JVM，如果目标JVM存在則向它發送agent.jar。我測試寫的簡單了些，找到目前JVM并加載agent.jar。

package com.rickiyang.learn.job;

import com.sun.tools.attach.*;

import java.io.IOException;
import java.util.List;

/**
 * @author rickiyang
 * @date 2019-08-16
 * @Desc
 */
public class TestAgentMain {

    public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
        //擷取目前系統中所有 運作中的 虛拟機
        System.out.println("running JVM start ");
        List<VirtualMachineDescriptor> list = VirtualMachine.list();
        for (VirtualMachineDescriptor vmd : list) {
            //如果虛拟機的名稱為 xxx 則 該虛拟機為目标虛拟機，擷取該虛拟機的 pid
            //然後加載 agent.jar 發送給該虛拟機
            System.out.println(vmd.displayName());
            if (vmd.displayName().endsWith("com.rickiyang.learn.job.TestAgentMain")) {
                VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
                virtualMachine.loadAgent("/Users/yangyue/Documents/java-agent.jar");
                virtualMachine.detach();
            }
        }
    }

}
           

list()方法會去尋找目前系統中所有運作着的JVM程序，你可以列印

vmd.displayName()

看到目前系統都有哪些JVM程序在運作。因為main函數執行起來的時候程序名為目前類名，是以通過這種方式可以去找到目前的程序id。

注意：在mac上安裝了的jdk是能直接找到 VirtualMachine 類的，但是在windows中安裝的jdk無法找到，如果你遇到這種情況，請手動将你jdk安裝目錄下：lib目錄中的tools.jar添加進目前工程的Libraries中。

運作main方法的輸出為：

可以看到實際上是啟動了一個socket程序去傳輸agent.jar。先列印了“running JVM start”表名main方法是先啟動了，然後才進入代理類的transform方法。

instrument原理

instrument

的底層實作依賴于

JVMTI(JVM Tool Interface)

，它是JVM暴露出來的一些供使用者擴充的接口集合，JVMTI是基于事件驅動的，JVM每執行到一定的邏輯就會調用一些事件的回調接口（如果有的話），這些接口可以供開發者去擴充自己的邏輯。

JVMTIAgent

是一個利用

JVMTI

暴露出來的接口提供了代理啟動時加載(agent on load)、代理通過attach形式加載(agent on attach)和代了解除安裝(agent on unload)功能的動态庫。而

instrument agent

可以了解為一類

JVMTIAgent

動态庫，别名是

JPLISAgent(Java Programming Language Instrumentation Services Agent)

，也就是專門為java語言編寫的插樁服務提供支援的代理。

啟動時加載instrument agent過程：

1. 建立并初始化 JPLISAgent；
2. 監聽

   VMInit

   事件，在 JVM 初始化完成之後做下面的事情：
   1. 建立 InstrumentationImpl 對象 ；
   2. 監聽 ClassFileLoadHook 事件 ；
   3. 調用 InstrumentationImpl 的

      loadClassAndCallPremain

      方法，在這個方法裡會去調用 javaagent 中 MANIFEST.MF 裡指定的Premain-Class 類的 premain 方法 ；
3. 解析 javaagent 中 MANIFEST.MF 檔案的參數，并根據這些參數來設定 JPLISAgent 裡的一些内容。

運作時加載instrument agent過程：

通過 JVM 的attach機制來請求目标 JVM 加載對應的agent，過程大緻如下：

1. 建立并初始化JPLISAgent；
2. 解析 javaagent 裡 MANIFEST.MF 裡的參數；
3. 建立 InstrumentationImpl 對象；
4. 監聽 ClassFileLoadHook 事件；

5. loadClassAndCallAgentmain

   方法，在這個方法裡會去調用javaagent裡 MANIFEST.MF 裡指定的

   Agent-Class

   類的

   agentmain

   方法。

Instrumentation的局限性

大多數情況下，我們使用Instrumentation都是使用其位元組碼插樁的功能，或者籠統說就是類重定義(Class Redefine)的功能，但是有以下的局限性：

1. premain和agentmain兩種方式修改位元組碼的時機都是類檔案加載之後，也就是說必須要帶有Class類型的參數，不能通過位元組碼檔案和自定義的類名重新定義一個本來不存在的類。
2. 類的位元組碼修改稱為類轉換(Class Transform)，類轉換其實最終都回歸到類重定義Instrumentation#redefineClasses()方法，此方法有以下限制：
   1. 新類和老類的父類必須相同；
   2. 新類和老類實作的接口數也要相同，并且是相同的接口；
   3. 新類和老類通路符必須一緻。 新類和老類字段數和字段名要一緻；
   4. 新類和老類新增或删除的方法必須是private static/final修飾的；
   5. 可以修改方法體。

除了上面的方式，如果想要重新定義一個類，可以考慮基于類加載器隔離的方式：建立一個新的自定義類加載器去通過新的位元組碼去定義一個全新的類，不過也存在隻能通過反射調用該全新類的局限性。