偷天换日，用JavaAgent欺骗你的JVM

原创：微信公众号

码农参上

（ID：CODER_SANJYOU），欢迎分享，转载请保留出处。

熟悉Spring的小伙伴们应该都对aop比较了解，面向切面编程允许我们在目标方法的前后织入想要执行的逻辑，而今天要给大家介绍的Java Agent技术，在思想上与aop比较类似，翻译过来可以被称为Java代理、Java探针技术。

Java Agent出现在JDK1.5版本以后，它允许程序员利用agent技术构建一个独立于应用程序的代理程序，用途也非常广泛，可以协助监测、运行、甚至替换其他JVM上的程序，先从下面这张图直观的看一下它都被应用在哪些场景：

看到这里你是不是也很好奇，究竟是什么神仙技术，能够应用在这么多场景下，那今天我们就来挖掘一下，看看神奇的Java Agent是如何工作在底层，默默支撑了这么多优秀的应用。

回到文章开头的类比，我们还是用和aop比较的方式，来先对Java Agent有一个大致的了解：

• 作用级别：aop运行于应用程序内的方法级别，而agent能够作用于虚拟机级别
• 组成部分：aop的实现需要目标方法和逻辑增强部分的方法，而Java Agent要生效需要两个工程，一个是agent代理，另一个是需要被代理的主程序
• 执行场合：aop可以运行在切面的前后或环绕等场合，而Java Agent的执行只有两种方式，jdk1.5提供的

  preMain

  模式在主程序运行前执行，jdk1.6提供的

  agentMain

  在主程序运行后执行

下面我们就分别看一下在两种模式下，如何动手实现一个agent代理程序。

Premain模式

Premain模式允许在主程序执行前执行一个agent代理，实现起来非常简单，下面我们分别实现两个组成部分。

agent

先写一个简单的功能，在主程序执行前打印一句话，并打印传递给代理的参数：

public class MyPreMainAgent {public static void premain(String agentArgs, Instrumentation inst) {System.out.println("premain start");System.out.println("args:"+agentArgs);}}

在写完了agent的逻辑后，需要把它打包成

jar

文件，这里我们直接使用maven插件打包的方式，在打包前进行一些配置。

<build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-jar-plugin</artifactId><version>3.1.0</version><configuration><archive><manifest><addClasspath>true</addClasspath></manifest><manifestEntries><Premain-Class>com.cn.agent.MyPreMainAgent</Premain-Class><Can-Redefine-Classes>true</Can-Redefine-Classes><Can-Retransform-Classes>true</Can-Retransform-Classes><Can-Set-Native-Method-Prefix>true</Can-Set-Native-Method-Prefix></manifestEntries></archive></configuration></plugin></plugins></build>

配置的打包参数中，通过

manifestEntries

的方式添加属性到

MANIFEST.MF

文件中，解释一下里面的几个参数：

• Premain-Class

  ：包含

  premain

  方法的类，需要配置为类的全路径

• Can-Redefine-Classes

  ：为

  true

  时表示能够重新定义class

• Can-Retransform-Classes

  ：为

  true

  时表示能够重新转换class，实现字节码替换

• Can-Set-Native-Method-Prefix

  ： 为

  true

  时表示能够设置native方法的前缀

其中

Premain-Class

为必须配置，其余几项是非必须选项，默认情况下都为

false

，通常也建议加入，这几个功能我们会在后面具体介绍。在配置完成后，使用

mvn

命令打包：

mvn clean package

打包完成后生成

myAgent-1.0.jar

文件，我们可以解压

jar

文件，看一下生成的

MANIFEST.MF

文件：

可以看到，添加的属性已经被加入到了文件中。到这里，agent代理部分就完成了，因为代理不能够直接运行，需要附着于其他程序，所以下面新建一个工程来实现主程序。

主程序

在主程序的工程中，只需要一个能够执行的

main

方法的入口就可以了。

public class AgentTest {public static void main(String[] args) {System.out.println("main project start");}}

在主程序完成后，要考虑的就是应该如何将主程序与agent工程连接起来。这里可以通过

-javaagent

参数来指定运行的代理，命令格式如下：

java -javaagent:myAgent.jar -jar AgentTest.jar

并且，可以指定的代理的数量是没有限制的，会根据指定的顺序先后依次执行各个代理，如果要同时运行两个代理，就可以按照下面的命令执行：

java -javaagent:myAgent1.jar -javaagent:myAgent2.jar  -jar AgentTest.jar

以我们在idea中执行程序为例，在

VM options

中加入添加启动参数：

-javaagent:F:\\Workspace\\MyAgent\\target\\myAgent-1.0.jar=Hydra-javaagent:F:\\Workspace\\MyAgent\\target\\myAgent-1.0.jar=Trunks

执行

main

方法，查看输出结果：

根据执行结果的打印语句可以看出，在执行主程序前，依次执行了两次我们的agent代理。可以通过下面的图来表示执行代理与主程序的执行顺序。

缺陷

在提供便利的同时，premain模式也有一些缺陷，例如如果agent在运行过程中出现异常，那么也会导致主程序的启动失败。我们对上面例子中agent的代码进行一下改造，手动抛出一个异常。

public static void premain(String agentArgs, Instrumentation inst) {System.out.println("premain start");System.out.println("args:"+agentArgs);throw new RuntimeException("error");}

再次运行主程序：

可以看到，在agent抛出异常后主程序也没有启动。针对premain模式的一些缺陷，在jdk1.6之后引入了agentmain模式。

Agentmain模式

agentmain模式可以说是premain的升级版本，它允许代理的目标主程序的jvm先行启动，再通过

attach

机制连接两个jvm，下面我们分3个部分实现。

agent

agent部分和上面一样，实现简单的打印功能：

public class MyAgentMain {public static void agentmain(String agentArgs, Instrumentation instrumentation) {System.out.println("agent main start");System.out.println("args:"+agentArgs);}}

修改maven插件配置，指定

Agent-Class

：

<plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-jar-plugin</artifactId><version>3.1.0</version><configuration><archive><manifest><addClasspath>true</addClasspath></manifest><manifestEntries><Agent-Class>com.cn.agent.MyAgentMain</Agent-Class><Can-Redefine-Classes>true</Can-Redefine-Classes><Can-Retransform-Classes>true</Can-Retransform-Classes></manifestEntries></archive></configuration></plugin>

主程序

这里我们直接启动主程序等待代理被载入，在主程序中使用了

System.in

进行阻塞，防止主进程提前结束。

public class AgentmainTest {public static void main(String[] args) throws IOException {System.in.read();}}

attach机制

和premain模式不同，我们不能再通过添加启动参数的方式来连接agent和主程序了，这里需要借助

com.sun.tools.attach

包下的

VirtualMachine

工具类，需要注意该类不是jvm标准规范，是由Sun公司自己实现的，使用前需要引入依赖：

<dependency><groupId>com.sun</groupId><artifactId>tools</artifactId><version>1.8</version><scope>system</scope><systemPath>${JAVA_HOME}\\lib\\tools.jar</systemPath></dependency>

VirtualMachine

代表了一个要被附着的java虚拟机，也就是程序中需要监控的目标虚拟机，外部进程可以使用

VirtualMachine

的实例将agent加载到目标虚拟机中。先看一下它的静态方法

attach

：

public static VirtualMachine attach(String var0);

通过

attach

方法可以获取一个jvm的对象实例，这里传入的参数是目标虚拟机运行时的进程号

pid

。也就是说，我们在使用

attach

前，需要先获取刚才启动的主程序的

pid

，使用

jps

命令查看线程

pid

：

1114016372 RemoteMavenServer3616392 AgentmainTest20204 Jps2460 Launcher

获取到主程序

AgentmainTest

运行时

pid

是16392，将它应用于虚拟机的连接。

public class AttachTest {public static void main(String[] args) {try {VirtualMachine  vm= VirtualMachine.attach("16392");vm.loadAgent("F:\\\\Workspace\\\\MyAgent\\\\target\\\\myAgent-1.0.jar","param");} catch (Exception e) {e.printStackTrace();}}}

在获取到

VirtualMachine

实例后，就可以通过

loadAgent

方法可以实现注入agent代理类的操作，方法的第一个参数是代理的本地路径，第二个参数是传给代理的参数。执行

AttachTest

，再回到主程序

AgentmainTest

的控制台，可以看到执行了了agent中的代码：

这样，一个简单的agentMain模式代理就实现完成了，可以通过下面这张图再梳理一下三个模块之间的关系。

应用

到这里，我们就已经简单地了解了两种模式的实现方法，但是作为高质量程序员，我们肯定不能满足于只用代理单纯地打印语句，下面我们再来看看能怎么利用Java Agent搞点实用的东西。

在上面的两种模式中，agent部分的逻辑分别是在

premain

方法和

agentmain

方法中实现的，并且，这两个方法在签名上对参数有严格的要求，

premain

方法允许以下面两种方式定义：

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

agentmain

方法允许以下面两种方式定义：

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

如果在agent中同时存在两种签名的方法，带有

Instrumentation

参数的方法优先级更高，会被jvm优先加载，它的实例

inst

会由jvm自动注入，下面我们就看看能通过

Instrumentation

实现什么功能。

Instrumentation

先大体介绍一下

Instrumentation

接口，其中的方法允许在运行时操作java程序，提供了诸如改变字节码，新增jar包，替换class等功能，而通过这些功能使Java具有了更强的动态控制和解释能力。在我们编写agent代理的过程中，

Instrumentation

中下面3个方法比较重要和常用，我们来着重看一下。

addTransformer

addTransformer

方法允许我们在类加载之前，重新定义Class，先看一下方法的定义：

void addTransformer(ClassFileTransformer transformer);

ClassFileTransformer

是一个接口，只有一个

transform

方法，它在主程序的

main

方法执行前，装载的每个类都要经过

transform

执行一次，可以将它称为转换器。我们可以实现这个方法来重新定义Class，下面就通过一个例子看看具体如何使用。

首先，在主程序工程创建一个

Fruit

类：

public class Fruit {public void getFruit(){System.out.println("banana");}}

编译完成后复制一份class文件，并将其重命名为

Fruit2.class

，再修改

Fruit

中的方法为：

public void getFruit(){System.out.println("apple");}

创建主程序，在主程序中创建了一个

Fruit

对象并调用了其

getFruit

方法：

public class TransformMain {public static void main(String[] args) {new Fruit().getFruit();}}

这时执行结果会打印

apple

，接下来开始实现premain代理部分。

在代理的

premain

方法中，使用

Instrumentation

的

addTransformer

方法拦截类的加载：

public class TransformAgent {public static void premain(String agentArgs, Instrumentation inst) {inst.addTransformer(new FruitTransformer());}}

FruitTransformer

类实现了

ClassFileTransformer

接口，转换class部分的逻辑都在

transform

方法中：

public class FruitTransformer implements ClassFileTransformer {@Overridepublic byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,ProtectionDomain protectionDomain, byte[] classfileBuffer){if (!className.equals("com/cn/hydra/test/Fruit"))return classfileBuffer;String fileName="F:\\\\Workspace\\\\agent-test\\\\target\\\\classes\\\\com\\\\cn\\\\hydra\\\\test\\\\Fruit2.class";return getClassBytes(fileName);}public static byte[] getClassBytes(String fileName){File file = new File(fileName);try(InputStream is = new FileInputStream(file);ByteArrayOutputStream bs = new ByteArrayOutputStream()){long length = file.length();byte[] bytes = new byte[(int) length];int n;while ((n = is.read(bytes)) != -1) {bs.write(bytes, 0, n);}return bytes;}catch (Exception e) {e.printStackTrace();return null;}}}

在

transform

方法中，主要做了两件事：

• 因为

  addTransformer

  方法不能指明需要转换的类，所以需要通过

  className

  判断当前加载的class是否我们要拦截的目标class，对于非目标class直接返回原字节数组，注意

  className

  的格式，需要将类全限定名中的

  .

  替换为

  /

• 读取我们之前复制出来的class文件，读入二进制字符流，替换原有

  classfileBuffer

  字节数组并返回，完成class定义的替换

将agent部分打包完成后，在主程序添加启动参数：

-javaagent:F:\\Workspace\\MyAgent\\target\\transformAgent-1.0.jar

再次执行主程序，结果打印：

banana

这样，就实现了在

main

方法执行前class的替换。

redefineClasses

我们可以直观地从方法的名字上来理解它的作用，重定义class，通俗点来讲的话就是实现指定类的替换。方法定义如下：

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

它的参数是可变长的

ClassDefinition

数组，再看一下

ClassDefinition

的构造方法：

public ClassDefinition(Class<?> theClass,byte[] theClassFile) {...}

ClassDefinition

中指定了的Class对象和修改后的字节码数组，简单来说，就是使用提供的类文件字节，替换了原有的类。并且，在

redefineClasses

方法重定义的过程中，传入的是

ClassDefinition

的数组，它会按照这个数组顺序进行加载，以便满足在类之间相互依赖的情况下进行更改。

下面通过一个例子来看一下它的生效过程，premain代理部分：

public class RedefineAgent {public static void premain(String agentArgs, Instrumentation inst)throws UnmodifiableClassException, ClassNotFoundException {String fileName="F:\\\\Workspace\\\\agent-test\\\\target\\\\classes\\\\com\\\\cn\\\\hydra\\\\test\\\\Fruit2.class";ClassDefinition def=new ClassDefinition(Fruit.class,FruitTransformer.getClassBytes(fileName));inst.redefineClasses(new ClassDefinition[]{def});}}

主程序可以直接复用上面的，执行后打印：

banana

可以看到，用我们指定的class文件的字节替换了原有类，即实现了指定类的替换。

retransformClasses

retransformClasses

应用于agentmain模式，可以在类加载之后重新定义Class，即触发类的重新加载。首先看一下该方法的定义：

void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;

它的参数

classes

是需要转换的类数组，可变长参数也说明了它和

redefineClasses

方法一样，也可以批量转换类的定义。

下面，我们通过例子来看看如何使用

retransformClasses

方法，agent代理部分代码如下：

public class RetransformAgent {public static void agentmain(String agentArgs, Instrumentation inst)throws UnmodifiableClassException {inst.addTransformer(new FruitTransformer(),true);inst.retransformClasses(Fruit.class);System.out.println("retransform success");}}

看一下这里调用的

addTransformer

方法的定义，与上面略有不同：

void addTransformer(ClassFileTransformer transformer, boolean canRetransform);

ClassFileTransformer

转换器依旧复用了上面的

FruitTransformer

，重点看一下新加的第二个参数，当

canRetransform

为

true

时，表示允许重新定义class。这时，相当于调用了转换器

ClassFileTransformer

中的

transform

方法，会将转换后class的字节作为新类定义进行加载。

主程序部分代码，我们在死循环中不断的执行打印语句，来监控类是否发生了改变：

public class RetransformMain {public static void main(String[] args) throws InterruptedException {while(true){new Fruit().getFruit();TimeUnit.SECONDS.sleep(5);}}}

最后，使用attach api注入agent代理到主程序中：

public class AttachRetransform {public static void main(String[] args) throws Exception {VirtualMachine vm = VirtualMachine.attach("6380");vm.loadAgent("F:\\\\Workspace\\\\MyAgent\\\\target\\\\retransformAgent-1.0.jar");}}

回到主程序控制台，查看运行结果：

可以看到在注入代理后，打印语句发生变化，说明类的定义已经被改变并进行了重新加载。

其他

除了这几个主要的方法外，

Instrumentation

中还有一些其他方法，这里仅简单列举一下常用方法的功能：

• removeTransformer

  ：删除一个

  ClassFileTransformer

  类转换器

• getAllLoadedClasses

  ：获取当前已经被加载的Class

• getInitiatedClasses

  ：获取由指定的

  ClassLoader

  加载的Class

• getObjectSize

  ：获取一个对象占用空间的大小

• appendToBootstrapClassLoaderSearch

  ：添加jar包到启动类加载器

• appendToSystemClassLoaderSearch

  ：添加jar包到系统类加载器

• isNativeMethodPrefixSupported

  ：判断是否能给native方法添加前缀，即是否能够拦截native方法

• setNativeMethodPrefix

  ：设置native方法的前缀

Javassist

在上面的几个例子中，我们都是直接读取的class文件中的字节来进行class的重定义或转换，但是在实际的工作环境中，可能更多的是去动态的修改class文件的字节码，这时候就可以借助javassist来更简单的修改字节码文件。

简单来说，javassist是一个分析、编辑和创建java字节码的类库，在使用时我们可以直接调用它提供的api，以编码的形式动态改变或生成class的结构。相对于ASM等其他要求了解底层虚拟机指令的字节码框架，javassist真的是非常简单和快捷。

下面，我们就通过一个简单的例子，看看如何将Java agent和Javassist结合在一起使用。首前先引入javassist的依赖：

<dependency><groupId>org.javassist</groupId><artifactId>javassist</artifactId><version>3.20.0-GA</version></dependency>

我们要实现的功能是通过代理，来计算方法执行的时间。premain代理部分和之前基本一致，先添加一个转换器：

public class Agent {public static void premain(String agentArgs, Instrumentation inst) {inst.addTransformer(new LogTransformer());}static class LogTransformer implements ClassFileTransformer {@Overridepublic byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,ProtectionDomain protectionDomain, byte[] classfileBuffer)throws IllegalClassFormatException {if (!className.equals("com/cn/hydra/test/Fruit"))return null;try {return calculate();} catch (Exception e) {e.printStackTrace();return null;}}}}

在

calculate

方法中，使用javassist动态的改变了方法的定义：

static byte[] calculate() throws Exception {ClassPool pool = ClassPool.getDefault();CtClass ctClass = pool.get("com.cn.hydra.test.Fruit");CtMethod ctMethod = ctClass.getDeclaredMethod("getFruit");CtMethod copyMethod = CtNewMethod.copy(ctMethod, ctClass, new ClassMap());ctMethod.setName("getFruit$agent");StringBuffer body = new StringBuffer("{\\n").append("long begin = System.nanoTime();\\n").append("getFruit$agent($$);\\n").append("System.out.println(\\"use \\"+(System.nanoTime() - begin) +\\" ns\\");\\n").append("}");copyMethod.setBody(body.toString());ctClass.addMethod(copyMethod);return ctClass.toBytecode();}

在上面的代码中，主要实现了这些功能：

• 利用全限定名获取类

  CtClass

• 根据方法名获取方法

  CtMethod

  ，并通过

  CtNewMethod.copy

  方法复制一个新的方法

• 修改旧方法的方法名为

  getFruit$agent

• 通过

  setBody

  方法修改复制出来方法的内容，在新方法中进行了逻辑增强并调用了旧方法，最后将新方法添加到类中

主程序仍然复用之前的代码，执行查看结果，完成了代理中的执行时间统计功能：

这时候我们可以再通过反射看一下：

for (Method method : Fruit.class.getDeclaredMethods()) {System.out.println(method.getName());method.invoke(new Fruit());System.out.println("-------");}

查看结果，可以看到类中确实已经新增了一个方法：

除此之外，javassist还有很多其他的功能，例如新建Class、设置父类、读取和写入字节码等等，大家可以在具体的场景中学习它的用法。

总结

虽然我们在平常的工作中，直接用到Java Agent的场景可能并不是很多，但是在热部署、监控、性能分析等工具中，它们可能隐藏在业务系统的角落里，一直在默默发挥着巨大的作用。

本文从Java Agent的两种模式入手，手动实现并简要分析了它们的工作流程，虽然在这里只利用它们完成了一些简单的功能，但是不得不说，正是Java Agent的出现，让程序的运行不再循规蹈矩，也为我们的代码提供了无限的可能性。

作者简介，

码农参上

（CODER_SANJYOU），一个热爱分享的公众号，有趣、深入、直接，与你聊聊技术。个人微信DrHydra9，欢迎添加好友，进一步交流。