一、开篇
在梳理SkyWalking agent的plugin、elasticsearch的plugin、arthas等技术的原理时，发现他们的底层原理很多是相同的。这类工具都用到了javaagent、类加载、类隔离等技术，在此进行归类梳理。
本篇将梳理Java agent相关内容，在此先把这些技术整体的关系梳理如下：
二、什么是Java agent
Java agent 是从 JDK1.5开始引入的技术，支持将 jar 依附在 JVM 进程中运行。
Java agent 分为静态加载和动态加载两种agent加载的方式，如下图：
Java agent 技术结合 Java Intrumentation API 可以实现类修改、热加载等功能，下面是 Java agent 技术的常见应用场景：
三、Java agent 示例
我们先用一个 Java agent 实现方法开始和结束时打印日志的简单例子来实践一下，通过示例，可以很快对后面 Java agent 技术有初步的理解。
1 Java agent 实现方法开始和结束时打印日志
1.1 开发 agent
创建 demo-javaagent 工程，目录结构如下：
新建pom.xml，引入javassist用来修改目标类的字节码，增加自定义代码。通过maven-assembly-plugin插件打包自定义的 agent jar。
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>org.example</groupId> <artifactId>demo-javaagent</artifactId> <version>1.0</version> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>org.javassist</groupId> <artifactId>javassist</artifactId> <version>3.25.0-GA</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-assembly-plugin</artifactId> <version>3.1.1</version> <configuration> <descriptorRefs> <!--将应用的所有依赖包都打到jar包中。如果依赖的是 jar 包，jar 包会被解压开，平铺到最终的 uber-jar 里去。输出格式为 jar--> <descriptorRef>jar-with-dependencies</descriptorRef> </descriptorRefs> <archive> <!-- 设置manifest配置文件--> <manifestEntries> <!--Premain-Class: 代表 Agent 静态加载时会调用的类全路径名。--> <Premain-Class>demo.MethodAgentMain</Premain-Class> <!--Agent-Class: 代表 Agent 动态加载时会调用的类全路径名。--> <Agent-Class>demo.MethodAgentMain</Agent-Class> <!--Can-Redefine-Classes: 是否可进行类定义。--> <Can-Redefine-Classes>true</Can-Redefine-Classes> <!--Can-Retransform-Classes: 是否可进行类转换。--> <Can-Retransform-Classes>true</Can-Retransform-Classes> </manifestEntries> </archive> </configuration> <executions> <execution> <!--绑定到package生命周期阶段上--> <phase>package</phase> <goals> <!--绑定到package生命周期阶段上--> <goal>single</goal> </goals> </execution> </executions> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.1</version> <configuration> <source>${maven.compiler.source}</source> <target>${maven.compiler.target}</target> </configuration> </plugin> </plugins> </build> </project> 复制代码
其中重点关注重点部分
<manifestEntries> <!--Premain-Class: 代表 Agent 静态加载时会调用的类全路径名。--> <Premain-Class>demo.MethodAgentMain</Premain-Class> <!--Agent-Class: 代表 Agent 动态加载时会调用的类全路径名。--> <Agent-Class>demo.MethodAgentMain</Agent-Class> <!--Can-Redefine-Classes: 是否可进行类定义。--> <Can-Redefine-Classes>true</Can-Redefine-Classes> <!--Can-Retransform-Classes: 是否可进行类转换。--> <Can-Retransform-Classes>true</Can-Retransform-Classes> </manifestEntries> 复制代码
编写 agent 核心代码 MethodAgentMain.java，我们使用了premain()静态加载方式，agentmain动态加载方式。并用到了Instrumentation类结合javassist代码生成库进行字节码的修改。
package demo; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.Modifier; import java.lang.instrument.ClassFileTransformer; import java.lang.instrument.Instrumentation; import java.lang.instrument.UnmodifiableClassException; import java.security.ProtectionDomain; public class MethodAgentMain { /** 被转换的类 */ public static final String TRANSFORM_CLASS = "org.example.agent.AgentTest"; /** 静态加载。Java agent指定的premain方法，会在main方法之前被调用 */ public static void premain(String args, Instrumentation instrumentation) { System.out.println("premain start!"); addTransformer(instrumentation); System.out.println("premain end!"); } /** 动态加载。Java agent指定的premain方法，会在main方法之前被调用 */ public static void agentmain(String args, Instrumentation instrumentation) { System.out.println("agentmain start!"); addTransformer(instrumentation); Class<?>[] classes = instrumentation.getAllLoadedClasses(); if (classes != null){ for (Class<?> c: classes) { if (c.isInterface() ||c.isAnnotation() ||c.isArray() ||c.isEnum()){ continue; } if (c.getName().equals(TRANSFORM_CLASS)) { try { System.out.println("retransformClasses start, class: " + c.getName()); /* * retransformClasses()对JVM已经加载的类重新触发类加载。使用的就是上面注册的Transformer。 * retransformClasses()可以修改方法体，但是不能变更方法签名、增加和删除方法/类的成员属性 */ instrumentation.retransformClasses(c); System.out.println("retransformClasses end, class: " + c.getName()); } catch (UnmodifiableClassException e) { System.out.println("retransformClasses error, class: " + c.getName() + ", ex:" + e); e.printStackTrace(); } } } } System.out.println("agentmain end!"); } private static void addTransformer (Instrumentation instrumentation) { /* Instrumentation提供的addTransformer方法，在类加载时会回调ClassFileTransformer接口 */ instrumentation.addTransformer(new ClassFileTransformer() { public byte[] transform(ClassLoader l,String className, Class<?> c,ProtectionDomain pd, byte[] b){ try { className = className.replace("/", "."); if (className.equals(TRANSFORM_CLASS)) { final ClassPool classPool = ClassPool.getDefault(); final CtClass clazz = classPool.get(TRANSFORM_CLASS); for (CtMethod method : clazz.getMethods()) { /* * Modifier.isNative(methods[i].getModifiers())过滤本地方法,否则会报 * javassist.CannotCompileException: no method body at javassist.CtBehavior.addLocalVariable() * 报错原因如下 * 来自Stack Overflow网友解答 * Native methods cannot be instrumented because they have no bytecodes. * However if native method prefix is supported ( Transformer.isNativeMethodPrefixSupported() ) * then you can use Transformer.setNativeMethodPrefix() to wrap a native method call inside a non-native call * which can then be instrumented */ if (Modifier.isNative(method.getModifiers())) { continue; } method.insertBefore("System.out.println(\"" + clazz.getSimpleName() + "." + method.getName() + " start.\");"); method.insertAfter("System.out.println(\"" + clazz.getSimpleName() + "." + method.getName() + " end.\");", false); } return clazz.toBytecode(); } } catch (Exception e) { e.printStackTrace(); } return null; } }, true); } } 复制代码
编译打包:
执行 mvn clean package 编译打包，最终打包生成了 agent jar 包，结果示例：
1.1.1 编写验证 agent 功能的测试类
创建 agent-example工程，目录结构如下：
编写测试 agent 功能的类 AgentTest.java
package org.example.agent; public class AgentTest { public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 1000; i++) { System.out.println("process result: " + process()); Thread.sleep(5000); } } public static String process() { System.out.println("process!"); return "success"; } } 复制代码
1.2 使用 java agent 静态加载方式实现
在 IDEA 的 Run/Debug Configurations 中，点击 Modify options，勾选上 add VM options，在 VM options 栏增加 -javaagent:/工程的父目录/demo-javaagent/demo-javaagent/target/demo-javaagent-1.0-jar-with-dependencies.jar
运行 Main.java的 main 方法，可以看到控制台日志：
premain start! premain end! AgentTest.main start. AgentTest.process start. process! AgentTest.process end. process result: success AgentTest.process start. process! AgentTest.process end. .......省略重复的部分...... 复制代码
其中AgentTest.main start AgentTest.process start 等日志是我们自己写的 java agent 实现的功能，实现了方法运行开始和结束时打印日志。
1.3 使用 java agent 动态加载方式实现
动态加载不是通过 -javaagent: 的方式实现，而是通过 Attach API 的方式。
编写调用 Attach API 的测试类
package org.example.agent; import com.sun.tools.attach.VirtualMachine; import com.sun.tools.attach.VirtualMachineDescriptor; import java.util.List; public class AttachMain { public static void main(String[] args) throws Exception { List<VirtualMachineDescriptor> listBefore = VirtualMachine.list(); // agentmain()方法所在jar包 String jar = "/Users/terry/Gits/agent/java-agent-group/demo-javaagent/demo-javaagent/target/demo-javaagent-1.0-jar-with-dependencies.jar"; for (VirtualMachineDescriptor virtualMachineDescriptor : VirtualMachine.list()) { // 针对指定名称的JVM实例 if (virtualMachineDescriptor.displayName().equals("org.example.agent.AgentTest")) { System.out.println("将对该进程的vm进行增强：org.example.agent.AgentTest的vm进程, pid=" + virtualMachineDescriptor.id()); // attach到新JVM VirtualMachine vm = VirtualMachine.attach(virtualMachineDescriptor); // 加载agentmain所在的jar包 vm.loadAgent(jar); // detach vm.detach(); } } } } 复制代码
先直接运行 org.example.agent.AgentTest#main，注意不用加 -javaagent: 启动参数。
process! process result: success process! process result: success process! process result: success .......省略重复的部分...... 复制代码
约15秒后，再运行 org.example.agent.AttachMain#main，可以看到 org.example.agent.AttachMain#main 打印的日志：
找到了org.example.agent.AgentTest的vm进程, pid=67398 复制代码
之后可以看到 org.example.agent.AgentTest#main打印的日志中多了记录方法运行开始和结束的内容。
.......省略重复的部分...... process! process result: success agentmain start! process! process result: success agentmain end! process! process result: success process! process result: success .......省略重复的部分...... 复制代码
1.4 小结
可以看到静态加载或动态加载相同的 agent，都能实现了记录记录方法运行开始和结束日志的功能。
我们可以稍微扩展一下，打印方法的入参、返回值，也可以实现替换 class，实现热加载的功能。
四、Instrumentation
1 Instrumentation API 介绍
Instrumentation是Java提供的JVM接口，该接口提供了一系列查看和操作Java类定义的方法，例如修改类的字节码、向 classLoader 的 classpath 下加入jar文件等。使得开发者可以通过Java语言来操作和监控JVM内部的一些状态，进而实现Java程序的监控分析，甚至实现一些特殊功能（如AOP、热部署）。
Instrumentation的一些主要方法如下：
public interface Instrumentation { /** * 注册一个Transformer，从此之后的类加载都会被Transformer拦截。 * Transformer可以直接对类的字节码byte[]进行修改 */ void addTransformer(ClassFileTransformer transformer); /** * 对JVM已经加载的类重新触发类加载。使用的就是上面注册的Transformer。 * retransformClasses可以修改方法体，但是不能变更方法签名、增加和删除方法/类的成员属性 */ void retransformClasses(Class<?>... classes) throws UnmodifiableClassException; /** * 获取一个对象的大小 */ long getObjectSize(Object objectToSize); /** * 将一个jar加入到bootstrap classloader的 classpath里 */ void appendToBootstrapClassLoaderSearch(JarFile jarfile); /** * 获取当前被JVM加载的所有类对象 */ Class[] getAllLoadedClasses(); } 复制代码
其中最常用的方法是addTransformer(ClassFileTransformer transformer)，这个方法可以在类加载时做拦截，对输入的类的字节码进行修改，其参数是一个ClassFileTransformer接口，定义如下：
public interface ClassFileTransformer { /** * 传入参数表示一个即将被加载的类，包括了classloader，classname和字节码byte[] * 返回值为需要被修改后的字节码byte[] */ byte[] transform( ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException; } 复制代码
addTransformer方法配置之后，后续的类加载都会被Transformer拦截。
对于已经加载过的类，可以执行retransformClasses来重新触发这个Transformer的拦截。类加载的字节码被修改后，除非再次被retransform，否则不会恢复。
2 Instrumentation的局限性
在运行时，我们可以通过Instrumentation的redefineClasses方法进行类重定义，在redefineClasses方法上有一段注释需要特别注意：
* The redefinition may change method bodies, the constant pool and attributes. * The redefinition must not add, remove or rename fields or methods, change the * signatures of methods, or change inheritance. These restrictions maybe be * lifted in future versions. The class file bytes are not checked, verified and installed * until after the transformations have been applied, if the resultant bytes are in * error this method will throw an exception. 复制代码
这里面提到，我们不可以增加、删除或者重命名字段和方法，改变方法的签名或者类的继承关系。认识到这一点很重要，当我们通过ASM获取到增强的字节码之后，如果增强后的字节码没有遵守这些规则，那么调用redefineClasses方法来进行类的重定义就会失败。
五、Java agent
主流的JVM都提供了Instrumentation的实现，但是鉴于Instrumentation的特殊功能，并不适合直接提供在JDK的runtime里，而更适合出现在Java程序的外层，以上帝视角在合适的时机出现。
因此如果想使用Instrumentation功能，拿到Instrumentation实例，我们必须通过Java agent。
Java agent是一种特殊的Java程序（Jar文件），它是Instrumentation的客户端。与普通Java程序通过main方法启动不同，agent 并不是一个可以单独启动的程序，而必须依附在一个Java应用程序（JVM）上，与它运行在同一个进程中，通过Instrumentation API与虚拟机交互。
Java agent与Instrumentation密不可分，二者也需要在一起使用。因为Instrumentation的实例会作为参数注入到Java agent的启动方法中。
1 Java agent 的格式
1.1 premain和agentmain
Java agent以jar包的形式部署在JVM中，jar文件的manifest需要指定agent的类名。根据不同的启动时机，agent类需要实现不同的方法（二选一）。
(1) JVM 启动时加载
[1] public static void premain(String agentArgs, Instrumentation inst); [2] public static void premain(String agentArgs); 复制代码
JVM将首先寻找[1]，如果没有发现[1]，再寻找[2]。
(2) JVM 运行时加载
[1] public static void agentmain(String agentArgs, Instrumentation inst); [2] public static void agentmain(String agentArgs); 复制代码
与 premain()一致，JVM将首先寻找[1]，如果没有发现[1]，再寻找[2]。
1.2 指定MANIFEST.MF
可以通过maven plugin配置，示例：
<!-- 设置manifest配置文件--> <manifestEntries> <!--Premain-Class: 代表 Agent 静态加载时会调用的类全路径名。--> <Premain-Class>demo.MethodAgentMain</Premain-Class> <!--Agent-Class: 代表 Agent 动态加载时会调用的类全路径名。--> <Agent-Class>demo.MethodAgentMain</Agent-Class> <!--Can-Redefine-Classes: 是否可进行类定义。--> <Can-Redefine-Classes>true</Can-Redefine-Classes> <!--Can-Retransform-Classes: 是否可进行类转换。--> <Can-Retransform-Classes>true</Can-Retransform-Classes> </manifestEntries> 复制代码
生成的MANIFEST.MF，示例：
Premain-Class: demo.MethodAgentMain Built-By: terry Agent-Class: demo.MethodAgentMain Can-Redefine-Classes: true Can-Retransform-Classes: true 复制代码
2 Java agent 的加载
2.1 Java agent 与 ClassLoader
Java agent 的包先会被加入到 system class path 中，然后 agent 的类会被SystemClassLoader(AppClassLoader)所加载，和应用代码的真实classLoader无关。例如：当启动参数加上-javaagent:my-agent.jar运行 SpringBoot 打包的 fatjar 时，fatjar 中应用代码和 lib 中嵌套 jar 是由 org.springframework.boot.loader.LaunchedURLClassLoader 加载，但这个 my-agent.jar 依然是在SystemClassLoader(AppClassLoader)中加载，而非 org.springframework.boot.loader.LaunchedURLClassLoader 加载。
该类加载逻辑非常重要，在使用 Java agent 时如果遇到ClassNotFoundException、NoClassDefFoundError，很大可能就是与该加载逻辑有关。
2.2 静态加载、动态加载 Java agent
Java agent 支持静态加载和动态加载。
2.2.1 静态加载 Java agent
静态加载，即 JVM 启动时加载，对应的是 premain() 方法。通过 vm 启动参数-javaagent将 agent jar 挂载到目标 JVM 程序，随目标 JVM 程序一起启动。
(1) -javaagent启动参数
其中 -javaagent格式： "-javaagent:<jarpath>[=<option>]"。[=<option>]部分可以指定 agent 的参数，可以传递到premain(String agentArgs, Instrumentation inst)方法的agentArgs入参中。支持可以定义多个agent，按指定顺序先后执行。
示例: java -javaagent:agent1.jar=key1=value1&key2=value2 -javaagent:agent2.jar -jar Test.jar
-
其中加载顺序为(1) agent1.jar (2) agent2.jar。
-
**注意：不同的顺序可能会导致 agent 对类的修改存在冲突，在实际项目中用到了pinpoint和SkyWalking的agent，当通过-javaagent先挂载 pinpoint的 agent ，后挂载 SkyWalking**的 agent，出现 SkyWalking对类的增强发生异常的情况，而先挂载SkyWalking的 agent 则无问题。
-
agent1.jar 的premain(String agentArgs, Instrumentation inst)方法的agentArgs值为key1=value1&key2=value2。
(2) premain()方法
-
premain()方法会在程序main方法执行之前被调用，此时大部分Java类都没有被加载（"大部分"是因为，agent类本身和它依赖的类还是无法避免的会先加载的），是一个对类加载埋点做手脚（addTransformer）的好机会。
-
如果此时premain方法执行失败或抛出异常，那么JVM的启动会被终止。
-
premain() 中一般会编写如下步骤：
-
注册类的 ClassFileTransformer，在类加载的时候会自动更新对应的类的字节码
-
写法示例：
// Java agent指定的premain方法，会在main方法之前被调用 public static void premain(String args, Instrumentation inst) { // Instrumentation提供的addTransformer方法，在类加载时会回调ClassFileTransformer接口 inst.addTransformer(new ClassFileTransformer() { @Override public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) { // TODO 字节码修改 byte[] transformed = null; return transformed; } }); } 复制代码
(3) 静态加载执行流程
agent 中的 class 由 AppClassLoader 加载，premain() 方法会调用 Instrumentation API，然后 Instrumentation API 调用 JVMTI(JVMTI的内容将在后面补充)，在需要加载的类需要被加载时，会回调 JVMTI，然后回调 Instrumentation API，触发ClassFileTransformer.transform()，最终修改 class 的字节码。
(4) ClassFileTransformer.transform()
ClassFileTransformer.transform() 和 ClassLoader.load()的关系
下面是一次 ClassFileTransformer.transform()执行时的方法调用栈，
transform:38, MethodAgentMain$1 (demo) transform:188, TransformerManager (sun.instrument) transform:428, InstrumentationImpl (sun.instrument) defineClass1:-1, ClassLoader (java.lang) defineClass:760, ClassLoader (java.lang) defineClass:142, SecureClassLoader (java.security) defineClass:467, URLClassLoader (java.net) access$100:73, URLClassLoader (java.net) run:368, URLClassLoader$1 (java.net) run:362, URLClassLoader$1 (java.net) doPrivileged:-1, AccessController (java.security) findClass:361, URLClassLoader (java.net) loadClass:424, ClassLoader (java.lang) loadClass:331, Launcher$AppClassLoader (sun.misc) loadClass:357, ClassLoader (java.lang) checkAndLoadMain:495, LauncherHelper (sun.launcher) 复制代码
可以看到 ClassLoader.load()加载类时，ClassLoader.load()会调用ClassLoader.findClass(),ClassLoader.findClass()会调用ClassLoader.defefineClass()，ClassLoader.defefineClass()最终会执行ClassFileTransformer.transform() ，ClassFileTransformer.transform() 可以对类进行修改。所以ClassLoader.load()最终加载 agent 修改后Class对象。
下面是精简后的 ClassLoader.load() 核心代码：
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { synchronized (getClassLoadingLock(name)) { // 判断是否已经加载过了，如果没有，则进行load // First, check if the class has already been loaded Class<?> c = findLoadedClass(name); if (c == null) { if (c == null) { // If still not found, then invoke findClass in order // to find the class. long t1 = System.nanoTime(); // findClass()内部最终会调用 Java agent 中 ClassFileTransformer.transform() c = findClass(name); // this is the defining class loader; record the stats sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); sun.misc.PerfCounter.getFindClasses().increment(); } } if (resolve) { resolveClass(c); } return c; } } 复制代码
ClassFileTransformer.transform() 和 字节码增强
ClassFileTransformer.transform() 中可以对指定的类进行增强，我们可以选择的代码生成库修改字节码对类进行增强，比如ASM, CGLIB, Byte Buddy, Javassist。
2.2.2 动态加载 Java agent
静态加载，即 JVM 启动后的任意时间点(即运行时)，通过Attach API动态地加载 Java agent，对应的是 agentmain() 方法。
Attach API部分将在后面的章节进行说明。
agentmain()方法
对于VM启动后加载的Java agent，其agentmain()方法会在加载之时立即执行。如果agentmain执行失败或抛出异常，JVM会忽略掉错误，不会影响到正在 running 的 Java 程序。
一般 agentmain() 中会编写如下步骤：
-
注册类的 ClassFileTransformer
-
调用 retransformClasses 方法对指定的类进行重加载
六、JVMTI
1 JVMTI 介绍
JVMTI （JVM Tool Interface）是 Java 虚拟机对外提供的 Native 编程接口，通过 JVMTI ，外部进程可以获取到运行时JVM的诸多信息，比如线程、GC等。
JVMTI 是一套 Native 接口，在 Java SE 5 之前，要实现一个 Agent 只能通过编写 Native 代码来实现。从 Java SE 5 开始，可以使用 Java 的Instrumentation 接口（java.lang.instrument）来编写 Agent。无论是通过 Native 的方式还是通过 Java Instrumentation 接口的方式来编写 Agent，它们的工作都是借助 JVMTI 来进行完成。
启动方式
JVMTI和Instumentation API的作用很相似，都是一套 JVM 操作和监控的接口，且都需要通过agent来启动：
-
Instumentation API需要打包成 jar，并通过 Java agent 加载（对应启动参数: -javaagent）
-
JVMTI 需要打包成动态链接库（随操作系统，如.dll/.so文件），并通过 JVMTI agent 加载（对应启动参数: -agentlib/-agentpath）
2 加载时机
启动时（Agent_OnLoad）和运行时Attach（Agent_OnAttach）
3 功能
Instumentation API 可以支持 Java 语言实现 agent 功能，但是 JVMTI 功能比 Instumentation API 更强大，它支持：
-
获取所有线程、查看线程状态、线程调用栈、查看线程组、中断线程、查看线程持有和等待的锁、获取线程的CPU时间、甚至将一个运行中的方法强制返回值……
-
获取Class、Method、Field的各种信息，类的详细信息、方法体的字节码和行号、向Bootstrap/System Class Loader添加jar、修改System Property……
-
堆内存的遍历和对象获取、获取局部变量的值、监测成员变量的值……
-
各种事件的callback函数，事件包括：类文件加载、异常产生与捕获、线程启动和结束、进入和退出临界区、成员变量修改、gc开始和结束、方法调用进入和退出、临界区竞争与等待、VM启动与退出……
-
设置与取消断点、监听断点进入事件、单步执行事件……
4 JVMTI 与 Java agent
Java agent 是基于 JVMTI 实现，核心部分是 ClassFileLoadHook和TransFormClassFile。
ClassFileLoadHook是一个 JVMTI 事件，该事件是 Instrumentation agent 的一个核心事件，主要是在读取字节码文件回调时调用，内部调用了TransFormClassFile的函数。
TransFormClassFile的主要作用是调用java.lang.instrument.ClassFileTransformer的tranform方法，该方法由开发者实现，通过Instrumentation的addTransformer方法进行注册。
在字节码文件加载的时候，会触发ClassFileLoadHook事件，该事件调用TransFormClassFile，通过经由Instrumentation 的 addTransformer 注册的方法完成整体的字节码修改。
对于已加载的类，需要调用retransformClass函数，然后经由redefineClasses函数，在读取已加载的字节码文件后，若该字节码文件对应的类关注了ClassFileLoadHook事件，则调用ClassFileLoadHook事件。后续流程与类加载时字节码替换一致。
七、Attach API
前文提到，Java agent 动态加载是通过 Attach API 实现。
1 Attach API 介绍
Attach机制是JVM提供一种JVM进程间通信的能力，能让一个进程传命令给另外一个进程，并让它执行内部的一些操作。
日常很多工作都是通过 Attach API 实现的，示例：
-
JDK 自带的一些命令，如：jstack打印线程栈、jps列出Java进程、jmap做内存dump等功能
-
Arthas、Greys、btrace 等监控诊断产品，通过 attach 目标 JVM 进程发送指定命令，可以实现方法调用等方面的监控。
2 Attach API 用法
由于是进程间通讯，那代表着使用Attach API的程序需要是一个独立的Java程序，通过attach目标进程，与其进行通讯。下面的代码表示了向进程pid为1234的JVM发起通讯，加载一个名为agent.jar的Java agent。
// VirtualMachine等相关Class位于JDK的tools.jar VirtualMachine vm = VirtualMachine.attach("1234"); // 1234表示目标JVM进程pid try { vm.loadAgent(".../javaagent.jar"); // 指定agent的jar包路径，发送给目标进程 } finally { // attach 动作的相反的行为，从 JVM 上面解除一个代理 vm.detach(); } 复制代码
vm.loadAgent 之后，相应的 agent 就会被目标 JVM 进程加载，并执行 agentmain() 方法。
执行的流程图：
3 Attach API 原理
以Hotspot虚拟机，Linux系统为例。当external process(attach发起的进程)执行VirtualMachine.attach时，需要通过操作系统提供的进程通信方法，例如信号、socket，进行握手和通信。其具体内部实现流程如下所示：
上面提到了两个文件：
-
.attach_pidXXX 后面的XXX代表pid，例如pid为1234则文件名为.attach_pid1234。该文件目的是给目标JVM一个标记，表示触发SIGQUIT信号的是attach请求。这样目标JVM才可以把SIGQUIT信号当做attach连接请求，再来做初始化。其默认全路径为/proc/XXX/cwd/.attach_pidXXX，若创建失败则使用/tmp/attach_pidXXX
-
.java_pidXXX 后面的XXX代表pid，例如pid为1234则文件名为.java_pid1234。由于Unix domain socket通讯是基于文件的，该文件就是表示external process与target VM进行socket通信所使用的文件，如果存在说明目标JVM已经做好连接准备。其默认全路径为/proc/XXX/cwd/.java_pidXXX，若创建失败则使用/tmp/java_pidXXX
VirtualMachine.attach动作类似TCP创建连接的三次握手，目的就是搭建attach通信的连接。而后面执行的操作，例如vm.loadAgent，其实就是向这个socket写入数据流，接收方target VM会针对不同的传入数据来做不同的处理。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
