如何在运行时重新转换类

简答题

• 不要循环访问检测中所有已加载的类。相反，只需检查传递给转换器的类名，如果它与您的目标类匹配，则对其进行转换。否则，只需返回未修改的传递类文件缓冲区。
• 在转换器外部进行设置调用（即，在您的情况下，从您的代理中执行以下操作），因此请使用要转换的类名初始化转换器（这将是内部格式，因此您将寻求与foo / bar / Snafu匹配而不是foo.bar.Snafu。然后添加转换器，调用 retransform，然后移除转换器。
• 为了调用retransform，您将需要实际的[pre-transform]类，您可以通过调用Class.forName（在agentmain中）找到它，或者如果您绝对必须这样做，您可以在Intrumentation.getAllLoadedClasses（）中找到它作为最后的手段。如果尚未加载目标类，则需要类加载器调用 Class.forName（name、boolean、classloader），在这种情况下，您可以将 URL 传递给代理主字符串 args 中的目标类类路径。

长答案

以下是一些建议：

1. 将要调用的操作分离为 2 个单独的操作：
   1. 安装代理。这只需要完成一次。
   2. 转换目标类。<您可能希望执行此操作 <b10>n 次。
2. 我会在安装代理时通过注册一个简单的 JMX MBean 来实现 1.2。此 MBean 应提供类似 的操作。并且应使用对代理获取的检测实例的引用进行初始化。MBean 类、接口和任何必需的第三方类都应包含在代理的加载.jar中。它还应该包含您的ModeMethodTest类（我假设它已经包含了）。public void transformClass(String className)
3. 在安装代理 jar 的同时，还要从 $JAVA_HOME/lib/management-agent 安装管理代理.jar这将激活管理代理，以便您可以在要注册的 MBean 中调用转换操作。
4. 参数化 DemoTransformer 类以接受要转换的类名称的内部形式。（即，如果您的二元类名称是 foo.bar.Snafu，则内部形式将为 foo/bar/Snafu。当 DemoTransformer 实例开始获取转换回调时，请忽略与您指定的内部表单类名不匹配的所有类名。（即简单地返回未修改的类文件缓冲区）
5. 然后，您的转发器 MBean transformClass 操作应：
   1. 将传递的类名转换为内部形式。
   2. 创建一个新的 DemoTransformer，传递内部表单类名。
   3. 使用 注册 DemoTransformer 实例。Instrumentation.addTransformer(theNewDemoTransformer, true)
   4. 调用（将二元类名传递给 MBean 操作）。当此调用返回时，您的类将被转换。Instrumentation.retransformClasses(ClassForName(className))
   5. 使用 卸下转换器。Intrumentation.removeTransformer(theNewDemoTransformer)

以下是我的意思的未经测试的近似值：

变形金刚

public interface TransformerServiceMBean {
    /**
     * Transforms the target class name
     * @param className The binary name of the target class
     */
    public void transformClass(String className);
}

变压器服务

public class TransformerService implements TransformerServiceMBean {
    /** The JVM's instrumentation instance */
    protected final Instrumentation instrumentation;

    /**
     * Creates a new TransformerService
     * @param instrumentation  The JVM's instrumentation instance 
     */
    public TransformerService(Instrumentation instrumentation) {
        this.instrumentation = instrumentation;
    }

    /**
     * {@inheritDoc}
     * @see com.heliosapm.shorthandexamples.TransformerServiceMBean#transformClass(java.lang.String)
     */
    @Override
    public void transformClass(String className) {
        Class<?> targetClazz = null;
        ClassLoader targetClassLoader = null;
        // first see if we can locate the class through normal means
        try {
            targetClazz = Class.forName(className);
            targetClassLoader = targetClazz.getClassLoader();
            transform(targetClazz, targetClassLoader);
            return;
        } catch (Exception ex) { /* Nope */ }
        // now try the hard/slow way
        for(Class<?> clazz: instrumentation.getAllLoadedClasses()) {
            if(clazz.getName().equals(className)) {
                targetClazz = clazz;
                targetClassLoader = targetClazz.getClassLoader();
                transform(targetClazz, targetClassLoader);
                return;             
            }
        }
        throw new RuntimeException("Failed to locate class [" + className + "]");
    }

    /**
     * Registers a transformer and executes the transform
     * @param clazz The class to transform
     * @param classLoader The classloader the class was loaded from
     */
    protected void transform(Class<?> clazz, ClassLoader classLoader) {
        DemoTransformer dt = new DemoTransformer(clazz.getName(), classLoader);
        instrumentation.addTransformer(dt, true);
        try {
            instrumentation.retransformClasses(clazz);
        } catch (Exception ex) {
            throw new RuntimeException("Failed to transform [" + clazz.getName() + "]", ex);
        } finally {
            instrumentation.removeTransformer(dt);
        }       
    }
}

类变压器

public class DemoTransformer implements ClassFileTransformer {
    /** The internal form class name of the class to transform */
    protected String className;
    /** The class loader of the class */
    protected ClassLoader classLoader;
    /**
     * Creates a new DemoTransformer
     * @param className The binary class name of the class to transform
     * @param classLoader The class loader of the class
     */
    public DemoTransformer(String className, ClassLoader classLoader) {
        this.className = className.replace('.', '/');
        this.classLoader = classLoader;
    }

    /**
     * {@inheritDoc}
     * @see java.lang.instrument.ClassFileTransformer#transform(java.lang.ClassLoader, java.lang.String, java.lang.Class, java.security.ProtectionDomain, byte[])
     */
    @Override
    public byte[] transform(ClassLoader loader, String className,
            Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
            byte[] classfileBuffer) throws IllegalClassFormatException {
        if(className.equals(this.className) && loader.equals(classLoader)) {
            return new ModifyMethodTest(classfileBuffer).modiySleepMethod();
        }
        return classfileBuffer;
    }

}

代理

public class AgentMain {

    public static void agentmain (String agentArgs, Instrumentation inst) throws Exception {
        TransformerService ts = new TransformerService(inst);
        ObjectName on = new ObjectName("transformer:service=DemoTransformer");
        // Could be a different MBeanServer. If so, pass a JMX Default Domain Name in agentArgs
        MBeanServer server = ManagementFactory.getPlatformMBeanServer();
        server.registerMBean(ts, on);
        // Set this property so the installer knows we're already here
        System.setProperty("demo.agent.installed", "true");     
    }

}

客户端安装程序

public class AgentInstaller {
    /**
     * Installs the loader agent on the target JVM identified in <code>args[0]</code>
     * and then transforms all the classes identified in <code>args[1..n]</code>.
     * @param args The target JVM pid in [0] followed by the classnames to transform
     */
    public static void main(String[] args)  {
        String agentPath = "D:\\work\\workspace\\myjar\\loaded.jar";
        String vid = args[0]; 
        VirtualMachine vm = VirtualMachine.attach(vid);
        // Check to see if transformer agent is installed
        if(!vm.getSystemProperties().contains("demo.agent.installed")) {
            vm.loadAgent(agentPath);  
            // that property will be set now, 
            // and the transformer MBean will be installed
        }
        // Check to see if connector is installed
        String connectorAddress = vm.getAgentProperties().getProperty("com.sun.management.jmxremote.localConnectorAddress", null);
        if(connectorAddress==null) {
            // It's not, so install the management agent
            String javaHome = vm.getSystemProperties().getProperty("java.home");
            File managementAgentJarFile = new File(javaHome + File.separator + "lib" + File.separator + "management-agent.jar");
            vm.loadAgent(managementAgentJarFile.getAbsolutePath());
            connectorAddress = vm.getAgentProperties().getProperty("com.sun.management.jmxremote.localConnectorAddress", null);
            // Now it's installed
        }
        // Now connect and transform the classnames provided in the remaining args.
        JMXConnector connector = null;
        try {
            // This is the ObjectName of the MBean registered when loaded.jar was installed.
            ObjectName on = new ObjectName("transformer:service=DemoTransformer");
            // Here we're connecting to the target JVM through the management agent
            connector = JMXConnectorFactory.connect(new JMXServiceURL(connectorAddress));
            MBeanServerConnection server = connector.getMBeanServerConnection();
            for(int i = 1; i < args.length; i++) {
                String className = args[i];
                // Call transformClass on the transformer MBean
                server.invoke(on, "transformClass", new Object[]{className}, new String[]{String.class.getName()});
            }
        } catch (Exception ex) {
            ex.printStackTrace(System.err);
        } finally {
            if(connector!=null) try { connector.close(); } catch (Exception e) {}
        }
        // Done. (Hopefully)
    }
}

====================================================================================================================================================================================================================================================

嘿尼克;是的，这是当前（即Java 5-8）类转换器的限制之一。引用 Instrumentation javadoc 中的一句话：

“再转化可能会改变方法体，常数池和属性。重新转换不得添加、删除或重命名字段或方法、更改方法的签名或更改继承。这些限制可能会在将来的版本中解除。在应用转换之前，不会检查，验证和安装类文件字节，如果生成的字节出错，此方法将引发异常。

顺便说一句，同样的限制也被逐字记录下来，用于重新定义类。

因此，您有 2 个选项：

1. 不要添加新方法。这通常非常有限，并且不符合使用非常常见的字节码AOP模式（如方法包装）的资格。根据所使用的字节码操作库，您可能能够将所需的所有功能注入到现有方法中。某些库使此操作比其他库更容易。或者，我应该说，一些库会比其他库更容易做到这一点。

2. 在类装入之前对其进行转换。这使用与我们已讨论过的代码相同的一般模式，只是您不通过调用 retransformClasses 来触发转换。相反，您注册 ClassFileTransformer 以在装入类之前执行转换，并且目标类在装入第一个类时将被修改。在这种情况下，您几乎可以自由地以任何您喜欢的方式修改类，前提是最终产品仍然可以被验证。击败应用程序（即在应用程序加载类之前注册ClassFileTransformer）很可能需要像javaagent这样的命令，尽管如果您对应用程序的生命周期有严格的控制，则可以在更传统的应用程序层代码中执行此操作。正如我所说，您只需要确保在加载目标类之前注册转换器即可。

您可以使用 #2 的另一个变体是使用新的类装入器模拟全新的类。如果您创建了一个新的独立类装入器，它不会委托给现有的[已装入]类，但可以访问[卸载的]目标类字节码，那么您实际上是在重现上面#2的要求，因为JVM认为这是一个全新的类。

=== === 更新 = ===

在你最后的评论中，我觉得我已经忘记了你在哪里。无论如何，Oracle JDK 1.6绝对支持重新转换。我不太熟悉ASM，但是您发布的最后一个错误表明ASM转换以某种方式修改了不允许的类架构，因此重新转换失败。

我认为一个工作示例会更加清晰。与上面相同的类（加上一个名为Person的测试类）在这里。有一些修改/添加：

• 转换器服务中的转换操作现在有 3 个参数：
  1. 二元类名
  2. 要检测的方法名称
  3. 与方法签名匹配的 [正则] 表达式。（如果为 null 或为空，则匹配所有签名）
  4. 实际的字节码修改是使用 ModifyMethodTest 类中的 Javassist 完成的。所有检测所做的就是添加一个如下所示的 System.out.println：-->Invoked method [com.heliosapm.shorthandexamples.Person.sayHello((I)V)]
• AgentInstaller（具有演示的主节点）只需自行安装代理和转换服务。（更易于开发/演示，但仍可与其他 JVM 配合使用）
• 代理自行安装后，主线程将创建一个 Person 实例并仅循环，调用 Person 的两个 sayHello 方法。

在转换之前，该输出如下所示。

Temp File:c:\temp\com.heliosapm.shorthandexamples.AgentMain8724970986698386534.jar
Installing AgentMain...
AgentMain Installed
Agent Loaded
Instrumentation Deployed:true
Hello [0]
Hello [0]
Hello [1]
Hello [-1]
Hello [2]
Hello [-2]

人有2个sayHello方法，一个采用int，另一个采用字符串。（字符串一个只打印循环索引的负数）。

一旦我启动了AgentInstaller，代理就被安装并且Person在循环中被调用，我使用JConsole连接到JVM：

我导航到 TransformerService MBean 并调用 transformClass 操作。我提供完全限定的类 [二进制] 名称、工具的方法名称以及仅与将 int 作为参数的 sayHello 方法匹配的正则表达式 （I）V。（或者我可以提供.*，或者什么都不匹配所有重载）。我执行该操作。

现在，当我回到正在运行的JVM并检查输出时：

Examining class [com/heliosapm/shorthandexamples/Person]
Instrumenting class [com/heliosapm/shorthandexamples/Person]
[ModifyMethodTest] Adding [System.out.println("\n\t-->Invoked method [com.heliosapm.shorthandexamples.Person.sayHello((I)V)]");]
[ModifyMethodTest] Intrumented [1] methods

    -->Invoked method [com.heliosapm.shorthandexamples.Person.sayHello((I)V)]
Hello [108]
Hello [-108]

    -->Invoked method [com.heliosapm.shorthandexamples.Person.sayHello((I)V)]
Hello [109]
Hello [-109]

做。检测的方法。

请记住，允许重新转换的原因是因为 Javassist 字节码修改除了将代码注入现有方法之外，没有进行任何更改。

有意义？