javaagents:转换顺序

Question

在我的项目中，我想分两个阶段转换字节码。命令很重要。

1. 首先，我需要改变方法的定义。
2. 然后调用方法的方式

例如

1. 将定义从String hello()更改为String hello(String s)
2. 将调用从Hello.hello()更改为Hello.hello("newArgument")

我设法添加了转换器，这是第一步。

public class MyJavaAgent {

    private static Instrumentation instrumentation;

    public static void premain(String args, Instrumentation inst)
            throws Exception {
        instrumentation = inst;
        instrumentation.addTransformer(new MyClassFileTransformer());
    }
}

我的问题是:我可以这样添加新的变压器吗？

public class MyJavaAgent {

    private static Instrumentation instrumentation;

    public static void premain(String args, Instrumentation inst)
            throws Exception {
        instrumentation = inst;
        instrumentation.addTransformer(new MyClassFileTransformer());
        instrumentation.addTransformer(new MyClassFileTransformer2());
    }
}

确保MyClassFileTransformer在MyClassFileTransformer2之前做好他的工作

Answer 1

有一个简单的方法来测试这个..。在每个转换器类的转换方法中添加一个System.out指令，以输出相应类的唯一消息。然后查看在控制台上获取输出的顺序。如果您在Transformer1之前得到了Transformer2的唯一消息，那么是的，转换方法是按顺序调用的。

我就是这么做的..。

package Test;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;

public class TransFormerTest  {


    public TransFormerTest() {
        super();
    }

    public static void premain(String agentArguments, Instrumentation instrumentation) {
        instrumentation.addTransformer(new Transformer1());
        instrumentation.addTransformer(new Transformer2());
    }
}

class Transformer1 implements ClassFileTransformer {
    public byte[] transform(ClassLoader loader, String className, Class redefiningClass, ProtectionDomain domain, byte[] bytes) throws IllegalClassFormatException {
        System.out.println(className + "one"); // one for Transformer
        return bytes;
    }
}

class Transformer2 implements ClassFileTransformer {
    public byte[] transform(ClassLoader loader, String className, Class redefiningClass, ProtectionDomain domain, byte[] bytes) throws IllegalClassFormatException {
        System.out.println(className + "two"); // two for Transformer 2
        return bytes;
    }
}

因此，每次加载类并调用转换器时，您都应该看到类的名称被打印了两次，首先以1作为后缀，然后以2作为后缀。

我用一个简单的Hello程序测试了这个理论。这是我的输出：

Test/Transformer2 - one
sun/launcher/LauncherHelper - one
sun/launcher/LauncherHelper - two
java/lang/Enum - one
java/lang/Enum - two
HelloWorld - one
HelloWorld - two
java/lang/Void - one
java/lang/Void - two
Hello World
java/lang/Shutdown - one
java/lang/Shutdown - two
java/lang/Shutdown$Lock - one
java/lang/Shutdown$Lock - two

所以，它似乎确实维持了秩序。

话虽如此，你考虑过将转换方法链接起来吗？比如说..。

public class TransFormerTest  {

    public TransFormerTest() {
        super();
    }

    public static void premain(String agentArguments, Instrumentation instrumentation) {
        instrumentation.addTransformer(new Transformer());
    }
}

class Transformer implements ClassFileTransformer {
    public byte[] transform(ClassLoader loader, String className, Class redefiningClass, ProtectionDomain domain, byte[] bytes) throws IllegalClassFormatException {
        byte[] bytes2 =  privateTransformer(className, bytes);
        return bytes2;
    }

    private byte[] privateTransformer(String className, byte[] bytes) {
        System.out.println(className + " - one");
            // TODO add code for First Transformation.
        byte[] bytes2 = privateTransformer2(className, bytes);
        return bytes2;
    }

    private byte[] privateTransformer2(String className, byte[] bytes) {
        System.out.println(className + " - two");
            // TODO add code for Second Transformation.
        return bytes;
    }
}

这仍将取得类似的结果，这肯定会维持转换可能发生的顺序。