JAVA核心知识点--Instrumentation

朱雀 2023-03-06 10:33 245阅读 0赞

**目录**

Instrumentation 的基本功能和用法

Java SE 6 的新特性：虚拟机启动后的动态 instrument

--------------------

利用 Java 代码，即 java.lang.instrument 做动态 Instrumentation 是 Java SE 5 的新特性，它把 Java 的 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 语言本身更加强大。

# Instrumentation 的基本功能和用法 #

“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 还在虚拟机内存管理，线程控制，方法和变量操作等等方面提供了大量有价值的函数。关于 JVMTI 的详细信息，请参考 Java SE 6 文档中的介绍。

Instrumentation 的最大作用，就是类定义动态改变和操作。在 Java SE 5 及其后续版本当中，开发者可以在一个普通 Java 程序（带有 main 函数的 Java 类）运行时，通过 -javaagent参数指定一个特定的 jar 文件（包含 Instrumentation 代理）来启动 Instrumentation 的代理程序。

在 Java SE 5 当中，开发者可以让 Instrumentation 代理在 main 函数运行前执行。简要说来就是如下几个步骤：

(1) 编写 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 包中定义的一个接口，也是这个包的核心部分，集中了其中几乎所有的功能方法，例如类定义的转换和操作等等。

(2) jar 文件打包

将这个 Java 类打包成一个 jar 文件，并在其中的 manifest 属性当中加入” Premain-Class”来指定步骤 1 当中编写的那个带有 premain 的 Java 类。（可能还需要指定其他属性以开启更多功能）

(3) 运行

用如下方式运行带有 Instrumentation 的 Java 程序：

java -javaagent:jar 文件的位置 [= 传入 premain 的参数 ]

对 Java 类文件的操作，可以理解为对一个 byte 数组的操作（将类文件的二进制字节流读入一个 byte 数组）。开发者可以在“ClassFileTransformer”的 transform 方法当中得到，操作并最终返回一个类的定义（一个 byte 数组）。这方面，Apache 的 BCEL 开源项目提供了强有力的支持，具体的字节码操作并非本文的重点，所以，本文中所举的例子，只是采用简单的类文件替换的方式来演示 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.lang.instrument.ClassFileTransformer; 
    import java.io.FileInputStream; 
    import java.io.IOException; 
    import java.io.InputStream; 
    import java.lang.instrument.ClassFileTransformer; 
    import java.lang.instrument.IllegalClassFormatException; 
    import java.security.ProtectionDomain; 
    
    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[] { def }); 
            System.out.println("success"); 
        } 
    }

redefineClasses 的功能比较强大，可以批量转换很多类。

# Java SE 6 的新特性：虚拟机启动后的动态 instrument #

在 Java SE 5 当中，开发者只能在 premain 当中施展想象力，所作的 Instrumentation 也仅限与 main 函数执行前，这样的方式存在一定的局限性。

在 Java SE 5 的基础上，Java SE 6 针对这种状况做出了改进，开发者可以在main 函数开始执行以后，再启动自己的 Instrumentation 程序。

在 Java SE 6 的 Instrumentation 当中，有一个跟 premain“并驾齐驱”的“agentmain”方法，可以在 main 函数开始运行之后再运行。跟 premain 函数一样， 开发者可以编写一个含有“agentmain”函数的 Java 类：

public static void agentmain (String agentArgs, Instrumentation inst); //[1] 
    public static void agentmain (String agentArgs);                       //[2]

同样，\[1\] 的优先级比 \[2\] 高，将会被优先执行。跟 premain 函数一样，开发者可以在 agentmain 中进行对类的各种操作。其中的 agentArgs 和 Inst 的用法跟 premain 相同。

与“Premain-Class”类似，开发者必须在 manifest 文件里面设置“Agent-Class”来指定包含 agentmain 函数的类。  
可是，跟 premain 不同的是，agentmain 需要在 main 函数开始运行后才启动，这样的时机应该如何确定呢，这样的功能又如何实现呢？

在 Java SE 6 文档当中，开发者也许无法在 java.lang.instrument 包相关的文档部分看到明确的介绍，更加无法看到具体的应用 agnetmain 的例子。不过，在 Java SE 6 的新特性里面，有一个不太起眼的地方，揭示了 agentmain 的用法。这就是Java SE 6 当中提供的 Attach API。

Attach API 不是 Java 的标准 API，而是 Sun 公司提供的一套扩展 API，用来向目标 JVM ”附着”（Attach）代理工具程序的。有了它，开发者可以方便的监控一个 JVM，运行一个外加的代理程序。

Attach API 很简单，只有 2 个主要的类，都在 com.sun.tools.attach 包里面：VirtualMachine 代表一个 Java 虚拟机，也就是程序需要监控的目标虚拟机，提供了 JVM 枚举，Attach 动作和 Detach 动作（Attach 动作的相反行为，从 JVM 上面解除一个代理）等等 ;VirtualMachineDescriptor 则是一个描述虚拟机的容器类，配合 VirtualMachine 类完成各种功能。

为了简单起见，我们举例简化如下：依然用类文件替换的方式，将一个返回 1 的函数替换成返回 2 的函数，Attach API 写在一个线程里面，用睡眠等待的方式，每隔半秒时间检查一次所有的 Java 虚拟机，当发现有新的虚拟机出现的时候，就调用 attach 函数，随后再按照 Attach API 文档里面所说的方式装载 Jar 文件。等到 5 秒钟的时候，attach 程序自动结束。而在 main 函数里面，程序每隔半秒钟输出一次返回值（显示出返回值从 1 变成 2）。

TransClass 类和 Transformer 类的代码不变，参看上一节介绍。 含有 main 函数的 TestMainInJar 代码为：

public class TestMainInJar { 
        public static void main(String[] args) throws InterruptedException { 
            System.out.println(new TransClass().getNumber()); 
            int count = 0; 
            while (true) { 
                Thread.sleep(500); 
                count++; 
                int number = new TransClass().getNumber(); 
                System.out.println(number); 
                if (3 == number || count >= 10) { 
                    break; 
                } 
            } 
        } 
    }

含有 agentmain 的 AgentMain 类的代码为：

import java.lang.instrument.ClassDefinition; 
    import java.lang.instrument.Instrumentation; 
    import java.lang.instrument.UnmodifiableClassException; 
    
    public class AgentMain { 
        public static void agentmain(String agentArgs, Instrumentation inst)  throws ClassNotFoundException, UnmodifiableClassException, InterruptedException { 
            inst.addTransformer(new Transformer (), true); 
            inst.retransformClasses(TransClass.class); 
            System.out.println("Agent Main Done"); 
        } 
    }

其中，retransformClasses 是 Java SE 6 里面的新方法，它跟 redefineClasses 一样，可以批量转换类定义，多用于 agentmain 场合。

Jar 文件跟 Premain 那个例子里面的 Jar 文件差不多，也是把 main 和 agentmain 的类，TransClass，Transformer 等类放在一起，打包为“TestInstrument1.jar”，而 Jar 文件当中的 Manifest 文件为 :

Manifest-Version: 1.0 
    Agent-Class: AgentMain

另外，为了运行 Attach API，我们可以再写一个控制程序来模拟监控过程：（代码片段）

import com.sun.tools.attach.VirtualMachine; 
    import com.sun.tools.attach.VirtualMachineDescriptor; 
    ……
    // 一个运行 Attach API 的线程子类
    static class AttachThread extends Thread { 
    
            private final List<VirtualMachineDescriptor> listBefore; 
    
            private final String jar; 
    
            AttachThread(String attachJar, List<VirtualMachineDescriptor> vms) { 
                listBefore = vms;  // 记录程序启动时的 VM 集合
                jar = attachJar; 
            } 
    
            public void run() { 
                VirtualMachine vm = null; 
                List<VirtualMachineDescriptor> listAfter = null; 
                try { 
                    int count = 0; 
                    while (true) { 
                        listAfter = VirtualMachine.list(); 
                        for (VirtualMachineDescriptor vmd : listAfter) { 
                            if (!listBefore.contains(vmd)) { 
                                // 如果 VM 有增加，我们就认为是被监控的 VM 启动了
                                // 这时，我们开始监控这个 VM 
                                vm = VirtualMachine.attach(vmd); 
                                break; 
                            } 
                        } 
                        Thread.sleep(500); 
                        count++; 
                        if (null != vm || count >= 10) { 
                            break; 
                        } 
                    } 
                    vm.loadAgent(jar); 
                    vm.detach(); 
                } catch (Exception e) { 
                     ignore 
                } 
            } 
        } 
    ……
    public static void main(String[] args) throws InterruptedException {     
         new AttachThread("TestInstrument1.jar", VirtualMachine.list()).start(); 
    }

运行时，可以首先运行上面这个启动新线程的 main 函数，然后，在 5 秒钟内（仅仅简单模拟 JVM 的监控过程）运行如下命令启动测试 Jar 文件 :

java – javaagent:TestInstrument2.jar – cp TestInstrument2.jar TestMainInJar

如果时间掌握得不太差的话，程序首先会在屏幕上打出 1，这是改动前的类的输出，然后会打出一些 2，这个表示 agentmain 已经被 Attach API 成功附着到 JVM 上，代理程序生效了，当然，还可以看到“Agent Main Done”字样的输出。

以上例子仅仅只是简单示例，简单说明这个特性而已。真实的例子往往比较复杂，而且可能运行在分布式环境的多个 JVM 之中。