Java Instrumentation是Java SE 6中的新特性，通過Java 代碼即 java.lang.instrument可以實現instrument用Java代碼的方式解決問題的一個功能。
定義,功能和用法,
定義
使用 Instrumentation，開發者可以構建一個獨立於應用程式的代理程式（Agent），用來監測和協助運行在 JVM 上的程式，甚至能夠替換和修改某些類的定義。有了這樣的功能，開發者就可以實現更為靈活的運行時虛擬機監控和 Java 類操作了，這樣的特性實際上提供了一種虛擬機級別支持的 AOP 實現方式，使得開發者無需對 JDK 做任何升級和改動，就可以實現某些 AOP 的功能了。
在 Java SE 6 裡面，instrumentation 包被賦予了更強大的功能：啟動後的 instrument、本地代碼（native code）instrument，以及動態改變 classpath 等等。這些改變，意味著 Java 具有了更強的動態控制、解釋能力，它使得 Java 語言變得更加靈活多變。
在 Java SE6 裡面，最大的改變使運行時的 Instrumentation 成為可能。在 Java SE 5 中，Instrument 要求在運行前利用命令行參數或者系統參數來設定代理類，在實際的運行之中，虛擬機在初始化之時（在絕大多數的 Java 類庫被載入之前），instrumentation 的設定已經啟動，並在虛擬機中設定了回調函式，檢測特定類的載入情況，並完成實際工作。但是在實際的很多的情況下，我們沒有辦法在虛擬機啟動之時就為其設定代理，這樣實際上限制了 instrument 的套用。而 Java SE 6 的新特性改變了這種情況，通過 Java Tool API 中的 attach 方式，我們可以很方便地在運行過程中動態地設定載入代理類，以達到 instrumentation 的目的。
另外，對 native 的 Instrumentation 也是 Java SE 6 的一個嶄新的功能，這使以前無法完成的功能 —— 對 native 接口的 instrumentation 可以在 Java SE 6 中，通過一個或者一系列的 prefix 添加而得以完成。
最後，Java SE 6 里的 Instrumentation 也增加了動態添加 class path 的功能。所有這些新的功能，都使得 instrument 包的功能更加豐富，從而使 Java 語言本身更加強大。
功能和用法
“java.lang.instrument”包的具體實現，依賴於 JVMTI。JVMTI（Java Virtual Machine Tool Interface）是一套由 Java 虛擬機提供的，為 JVM 相關的工具提供的本地編程接口集合。JVMTI 是從 Java SE 5 開始引入，整合和取代了以前使用的 Java Virtual Machine Profiler Interface (JVMPI) 和 the Java Virtual Machine Debug Interface (JVMDI)，而在 Java SE 6 中，JVMPI 和 JVMDI 已經消失了。JVMTI 提供了一套”代理”程式機制，可以支持第三方工具程式以代理的方式連線和訪問 JVM，並利用 JVMTI 提供的豐富的編程接口，完成很多跟 JVM 相關的功能。事實上，java.lang.instrument 包的實現，也就是基於這種機制的：在 Instrumentation 的實現當中，存在一個 JVMTI 的代理程式，通過調用 JVMTI 當中 Java 類相關的函式來完成 Java 類的動態操作。除開 Instrumentation 功能外，JVMTI 還在虛擬機記憶體管理，執行緒控制，方法和變數操作等等方面提供了大量有價值的函式。
Instrumentation 的最大作用，就是類定義動態改變和操作。在 Java SE 5 及其後續版本當中，開發者可以在一個普通 Java 程式（帶有 main 函式的 Java 類）運行時，通過 –javaagent 參數指定一個特定的 jar 檔案（包含 Instrumentation 代理）來啟動 Instrumentation 的代理程式。
在 Java SE 5 當中，開發者可以讓 Instrumentation 代理在 main 函式運行前執行。簡要說來就是如下幾個步驟：
編寫 premain 函式
編寫一個 Java 類，包含如下兩個方法當中的任何一個
public static void premain(String agentArgs, Instrumentation inst); [1]
public static void premain(String agentArgs); [2]
其中，[1] 的優先權比 [2] 高，將會被優先執行（[1] 和 [2] 同時存在時，[2] 被忽略）。
在這個 premain 函式中，開發者可以進行對類的各種操作。
agentArgs 是 premain 函式得到的程式參數，隨同 “–javaagent”一起傳入。與 main 函式不同的是，這個參數是一個字元串而不是一個字元串數組，如果程式參數有多個，程式將自行解析這個字元串。
Inst 是一個 java.lang.instrument.Instrumentation 的實例，由 JVM 自動傳入。java.lang.instrument.Instrumentation 是 instrument 包中定義的一個接口，也是這個包的核心部分，集中了其中幾乎所有的功能方法，例如類定義的轉換和操作等等。
jar 檔案打包
將這個 Java 類打包成一個 jar 檔案，並在其中的 manifest 屬性當中加入” Premain-Class”來指定步驟 1 當中編寫的那個帶有 premain 的 Java類。（可能還需要指定其他屬性以開啟更多功能）
運行
用如下方式運行帶有 Instrumentation 的 Java 程式：
java -javaagent:jar檔案的位置[=傳入premain的參數]
對 Java 類檔案的操作，可以理解為對一個 byte 數組的操作（將類檔案的二進制位元組流讀入一個 byte 數組）。開發者可以在“ClassFileTransformer”的 transform 方法當中得到，操作並最終返回一個類的定義（一個 byte 數組）。這方面，Apache 的 BCEL 開源項目提供了強有力的支持，讀者可以在參考文章“Java SE 5 特性 Instrumentation 實踐”中看到一個 BCEL 和 Instrumentation 結合的例子。具體的位元組碼操作並非本文的重點，所以，本文中所舉的例子，只是採用簡單的類檔案替換的方式來演示 Instrumentation 的使用。
下面，我們通過簡單的舉例，來說明 Instrumentation 的基本使用方法。
首先，我們有一個簡單的類，TransClass， 可以通過一個靜態方法返回一個整數 1。
public class TransClass {
public int getNumber() {
return 1;
}
}
我們運行如下類，可以得到輸出 ”1“。
public class TestMainInJar {
public static void main(String[] args) {
System.out.println(new TransClass().getNumber());
}
}
然後，我們將 TransClass 的 getNumber 方法改成如下:
public int getNumber() {
return 2;
}
再將這個返回 2 的 Java 檔案編譯成類檔案，為了區別開原有的返回 1 的類，我們將返回 2 的這個類檔案命名為 TransClass2.class.2。
接下來，我們建立一個 Transformer 類：
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
class Transformer implements ClassFileTransformer {
public static final String classNumberReturns2 = "TransClass.class.2";
public static byte[] getBytesFromFile(String fileName) {
try {
// precondition
File file = new File(fileName);
InputStream is = new FileInputStream(file);
long length = file.length();
byte[] bytes = new byte[(int) length];
// Read in the bytes
int offset = 0;
int numRead = 0;
while (offset <bytes.length
&& (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
offset += numRead;
}
if (offset < bytes.length) {
throw new IOException("Could not completely read file "+ file.getName());
}
is.close();
return bytes;
} catch (Exception e) {
System.out.println("error occurs in _ClassTransformer!"+ e.getClass().getName());
return null;
}
}
public byte[] transform(ClassLoader l, String className, Class<?> c,
ProtectionDomain pd, byte[] b) throws IllegalClassFormatException {
if (!className.equals("TransClass")) {
return null;
}
return getBytesFromFile(classNumberReturns2);
}
}
這個類實現了 ClassFileTransformer 接口。其中，getBytesFromFile 方法根據檔案名稱讀入二進制字元流，而 ClassFileTransformer 當中規定的 transform 方法則完成了類定義的替換轉換。
最後，我們建立一個 Premain 類，寫入 Instrumentation 的代理方法 premain：
public class Premain {
public static void premain(String agentArgs， Instrumentation inst)
throws ClassNotFoundException， UnmodifiableClassException {
inst.addTransformer(new Transformer());
}
}
可以看出，addTransformer 方法並沒有指明要轉換哪個類。轉換髮生在 premain 函式執行之後，main 函式執行之前，這時每裝載一個類，transform 方法就會執行一次，看看是否需要轉換，所以，在 transform（Transformer 類中）方法中，程式用 className.equals("TransClass") 來判斷當前的類是否需要轉換。
代碼完成後，我們將他們打包為 TestInstrument1.jar。返回 1 的那個 TransClass 的類檔案保留在 jar 包中，而返回 2 的那個 TransClass.class.2 則放到 jar 的外面。在 manifest 裡面加入如下屬性來指定 premain 所在的類：
Manifest-Version: 1.0
Premain-Class: Premain
在運行這個程式的時候，如果我們用普通方式運行這個 jar 中的???槧?? main 函式，可以得到輸出“1”。如果用下列方式運行:
java –javaagent:TestInstrument1.jar –cp TestInstrument1.jar TestMainInJar
則會得到輸出“2”。
當然，程式運行的 main 函式不一定要放在 premain 所在的這個 jar 檔案裡面，這裡只是為了例子程式打包的方便而放在一起的。
除開用 addTransformer 的方式，Instrumentation 當中還有另外一個方法“redefineClasses”來實現 premain 當中指定的轉換。用法類似，如下：
public class Premain {
public static void premain(String agentArgs， Instrumentation inst)
throws ClassNotFoundException， UnmodifiableClassException {
ClassDefinition def = new ClassDefinition(TransClass.class， Transformer
.getBytesFromFile(Transformer.classNumberReturns2));
inst.redefineClasses(new ClassDefinition[] );
System.out.println("success");
}
}
redefineClasses 的功能比較強大，可以批量轉換很多類。
