说实话，你工作5年，不知道什么是Java agent技术，让我很吃惊...

点击上方“朱小厮的博客”，选择“ 设为星标”

来源：urlify.cn/JrQruu

注：本文定义-在函数执行前后增加对应的逻辑的操作统称为MOCK。

引子

在某天与QA同学进行沟通时，发现QA同学有针对某个方法调用时，有让该方法停止一段时间的需求，我对这部分的功能实现非常好奇，因此决定对原理进行一些深入的了解，力争找到一种使用者尽可能少的对原有代码进行修改的方式，以达到对应的MOCK要求。

整体的感知程度可以分为三个级别：

• 硬编码

• 增加配置

• 无需任何修改

思路

在对方法进行mock，暂停以及异常模拟，在不知道其原理的情况下，进行猜想，思考其具体的实现原理，整体来说，最简单的实现模型无外乎两种：

朴素思路

假设存在如下的函数

public Object targetMethod(){    System.out.println("运行");}

若想要在函数执行后暂停一段时间、返回特定mock值或抛出特定异常，那么可以考虑修改对应的函数内容：

public Object targetMethod(){      //在此处加入Sleep return 或 throw逻辑    System.out.println("运行");}

或使用类似代理的方法把对应的函数进行代理：

public Object proxy(){    //执行Sleep return 或 throw逻辑      return targetMethod();}public Object targetMethod(){    System.out.println("运行");}

略成熟思路

在朴素思路的基础上，我们可以看出，实现类似的暂停、mock和异常功能整体实现方案无外乎两种：

• 代理模式

• 深入修改内部函数

  
  

在这两种思路的基础上，我们从代理模式开始考虑（主要是代理使用的比较多，更熟悉）

1、动态代理

说起代理，最常想到的两个词语就是静态代理和动态代理，二者却别不进行详述，对于静态代理模式由于需要大量硬编码，所以完全可以不用考虑。

针对动态代理来看，开始考虑最具代表性的JDK代理进行调研。

下面的代码为一个典型的使用JDK进行动态代理的样例（代理的函数为HelloInterface.sayHelllo）：

public class DynamicProxy implements InvocationHandler {
    private Object target;
    public DynamicProxy(Object object) {        this.target = object;    }
    private void before() {        System.out.println("before");    }
    private void after() {        System.out.println("after");    }
    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        Object res = null;        before();        try {            res = method.invoke(target, args);        } catch (Throwable e) {            throw e.getCause();        }        after();        return res;    }    public static void main(String[] args) throws IOException {




    
        try {            SayHello sayHello = new SayHello();            DynamicProxy dynamicProxy = new DynamicProxy(sayHello);            HelloInterface helloInterface = (HelloInterface) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), sayHello.getClass().getInterfaces(), dynamicProxy);            helloInterface.sayHello();        } catch (Throwable e) {            e.printStackTrace();        }    }}

从上面代码可以看出，对于JDK的动态代理而言，需要在原有代码中进行硬编码，且需要在对象初始化的时候，使用特定的方式进行初始化。因此若使用JDK完成MOCK，需要对应代码的的感知程度最高，达到了硬编码的程度。

2、AspectJ

由于使用代理方式无法在不对代码进行修改的情况下完成MOCK，因此我们抛弃代理方式，考虑使用修改方法内部代码的方式进行MOCK。

基于这种思路，将目光转向了AspectJ。

在使用AspectJ时，需要定义方法执行前的函数以及方法执行后的函数：

@Aspectpublic class AspectJFrame {    private Object before() {        System.out.println("before");        return new Object();    }
    private Object after() {        System.out.println("after");        return new Object();    }
    @Around("aroundPoint()")    public Object doMock(ProceedingJoinPoint joinPoint) {        Object object=null;        before();        try {            object = joinPoint.proceed();        } catch (Throwable throwable) {            throwable.printStackTrace();        }        after();        return object;    }}

并通过aop.xml指定对应的切点以及对应的环绕函数

但是基于以上的实现方式，需要对原有项目进行一定侵入，主要包含两部分内容：

• 在META-INF路径下增加aop.xml

• 引入对应的切面定义的jar包

通过aspectj可以完成在硬编码的情况下实现MOCK，但是这种实现方式受限于Aspectj自身局限，MOCK的功能代码在编译期就已经添加到对应的函数中了，最晚可在运行时完成MOCK功能代码的添加。这种方式主要有两个缺点：

• 对于运行中的java进行无法在不重启的条件下执行新增MOCK

• MOCK功能代码嵌入到目标函数中，无法对MOCK功能代码进行卸载，可能带来稳定性风险

# java agent介绍

由于在上述提到的各种技术都难以很好的支持在对原有项目无任何修改下完成MOCK功能的需求，在查阅资料后，将目光放至了java agent技术。

什么是java agent？

java agent本质上可以理解为一个插件，该插件就是一个精心提供的jar包，这个jar包通过JVMTI（JVM Tool Interface）完成加载，最终借助JPLISAgent（Java Programming Language Instrumentation Services Agent）完成对目标代码的修改。

java agent技术的主要功能如下：

• 可以在加载java文件之前做拦截把字节码做修改

• 可以在运行期将已经加载的类的字节码做变更

• 还有其他的一些小众的功能

• 获取所有已经被加载过的类

• 获取所有已经被初始化过了的类

• 获取某个对象的大小

• 将某个jar加入到bootstrapclasspath里作为高优先级被bootstrapClassloader加载

• 将某个jar加入到classpath里供AppClassloard去加载

• 设置某些native方法的前缀，主要在查找native方法的时候做规则匹配

java Instrumentation API

通过java agent技术进行类的字节码修改最主要使用的就是Java Instrumentation API。下面将介绍如何使用Java Instrumentation API进行字节码修改

1、实现agent启动方法

Java Agent支持目标JVM启动时加载，也支持在目标JVM运行时加载，这两种不同的加载模式会使用不同的入口函数，如果需要在目标JVM启动的同时加载Agent，那么可以选择实现下面的方法：

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

JVM将首先寻找[1]，如果没有发现[1]，再寻找[2]。如果希望在目标JVM运行时加载Agent，则需要实现下面的方法：

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

这两组方法的第一个参数AgentArgs是随同 “–javaagent”一起传入的程序参数，如果这个字符串代表了多个参数，就需要自己解析这些参数。inst是Instrumentation类型的对象，是JVM自动传入的，我们可以拿这个参数进行类增强等操作。

2、指定Main-Class

Agent需要打包成一个jar包，在ManiFest属性中指定“Premain-Class”或者“Agent-Class”,且需根据需求定义Can-Redefine-Classes和Can-Retransform-Classes：

Manifest-Version: 1.0
preMain-Class: com.test.AgentClass
Archiver-Version: Plexus Archiver
Agent-Class: com.test.AgentClass
Can-Redefine-Classes: true
Can-Retransform-Classes: true
Created-By: Apache Maven 3.3.9
Build-Jdk: 1.8.0_112

3、agent加载

@启动时加载

启动参数增加-javaagent:[path]，其中path为对应的agent的jar包路径

@运行中加载

使用com.sun.tools.attach.VirtualMachine加载

try { String jvmPid = 目标进行的pid;  logger.info("Attaching to target JVM with PID: " + jvmPid);  VirtualMachine jvm = VirtualMachine.attach(jvmPid);  jvm.loadAgent(agentFilePath);//agentFilePath为agent的路径  jvm.detach();  logger.info("Attached to target JVM and loaded Java agent successfully");} catch (Exception e) {  throw new RuntimeException(e);}

4、Instrument

instrument是JVM提供的一个可以修改已加载类的类库，专门为Java语言编写的插桩服务提供支持。它需要依赖JVMTI的Attach API机制实现。在JDK 1.6以前，instrument只能在JVM刚启动开始加载类时生效，而在JDK 1.6之后，instrument支持了在运行时对类定义的修改。要使用instrument的类修改功能，我们需要实现它提供的ClassFileTransformer接口，定义一个类文件转换器。接口中的transform()方法会在类文件被加载时调用，而在transform方法里，我们可以利用上文中的ASM或Javassist对传入的字节码进行改写或替换，生成新的字节码数组后返回。

首先可以定义如下的类转换器：

public class TestTransformer implements ClassFileTransformer {      //目标类名称，  .分隔      private String targetClassName;    //目标类名称，  /分隔    private String targetVMClassName;    private String targetMethodName;

    public TestTransformer(String className,String methodName){        this.targetVMClassName = new String(className).replaceAll("\\.","\\/");        this.targetMethodName = methodName;        this.targetClassName=className;    }    //类加载时会执行该函数，其中参数 classfileBuffer为类原始字节码，返回值为目标字节码，className为/分隔    public byte[] transform(ClassLoader loader, String className, Class> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {          //判断类名是否为目标类名        if(!className.equals(targetVMClassName)){            return classfileBuffer;        }        try {            ClassPool classPool = ClassPool.getDefault();            CtClass cls = classPool.get(this.targetClassName);            CtMethod ctMethod = cls.getDeclaredMethod(this.targetMethodName);            ctMethod.insertBefore("{ System.out.println(\"start\"); }");            ctMethod.insertAfter("{ System.out.println(\"end\"); }");            return cls.toBytecode();        } catch (Exception e) {
        }        return classfileBuffer;    }}

类转换器定义完毕后，需要将定义好的类转换器添加到对应的instrmentation中，对于已经加载过的类使用retransformClasses对类进行重新加载：

public class AgentDemo {
    private static String className = "hello.GreetingController";    private static String methodName = "getDomain";
    public static void agentmain(String args, Instrumentation instrumentation) {
        try {            List needRetransFormClasses = new LinkedList<>();            Class[] loadedClass = instrumentation.getAllLoadedClasses();            for (int i = 0; i < loadedClass.length; i++) {                if (loadedClass[i].getName().equals(className)) {                    needRetransFormClasses.add(loadedClass[i]);                }            }
            instrumentation.addTransformer(new TestTransformer(className, methodName));            instrumentation.retransformClasses(needRetransFormClasses.toArray(new Class[0]));        } catch (Exception e) {
        }    }
    public static void premain(String args, Instrumentation instrumentation) {        instrumentation.addTransformer(new TestTransformer(className, methodName));    }

}

从上图的代码可以看出，主方法实现了两个，分别为agentmain和premain，其中

@premain

用于在启动时，类加载前定义类的TransFormer，在类加载的时候更新对应的类的字节码。

@agentmain

注册类的TransFormer

调用retransformClasses函数进行类的重加载

用于在运行时进行类的字节码的修改，步骤整体分为两步

# java agent原理简述