JPDA 修改监听器，某种 JVMHotRedeployListener

Question

我正在我的开发环境中热部署方法代码。

除非代码更改方法的签名或类的结构，否则代码会立即受到影响。

这很好用，我没有问题。

不幸的是，我必须再次触发该方法的执行才能执行此代码。我可以注册一个监听器，当 JVM 收到 JPDA-HotCodeReplace 时得到通知？

Answer 1

无论您使用什么 IDE/调试器，热代码替换最终都会调用 RedefineClasses 或 RetransformClasses JVM TI 函数。

因此，我们的想法是拦截这两个函数并在调用时调用侦听器。这可以通过本机 (JNI) 库来实现。

HotCodeReplaceListener.c

#include <jvmti.h>

typedef struct {
    void* unused1[86];
    jvmtiError (JNICALL *RedefineClasses)(jvmtiEnv*, jint, const jvmtiClassDefinition*);
    void* unused2[64];
    jvmtiError (JNICALL *RetransformClasses)(jvmtiEnv*, jint, const jclass*);
} JVMTIFunctions;

jvmtiError (JNICALL *orig_RedefineClasses)(jvmtiEnv*, jint, const jvmtiClassDefinition*);
jvmtiError (JNICALL *orig_RetransformClasses)(jvmtiEnv*, jint, const jclass* classes);

static JavaVM* _vm;

// Call back to static HotCodeReplace.fireListeners() method
static void fire_listeners() {
    JNIEnv* env;
    (*_vm)->GetEnv(_vm, (void**)&env, JNI_VERSION_1_6);

    jclass hot_code_replace = (*env)->FindClass(env, "HotCodeReplace");
    if (hot_code_replace != NULL) {
        jmethodID file_listeners = (*env)->GetStaticMethodID(env, hot_code_replace, "fireListeners", "()V");
        if (file_listeners != NULL) {
            (*env)->CallStaticVoidMethod(env, hot_code_replace, file_listeners);
        }
    }
}

jvmtiError RedefineClassesHook(jvmtiEnv* jvmti, jint class_count, const jvmtiClassDefinition* class_definitions) {
    jvmtiError result = orig_RedefineClasses(jvmti, class_count, class_definitions);
    fire_listeners();
    return result;
}

jvmtiError RetransformClassesHook(jvmtiEnv* jvmti, jint class_count, const jclass* classes) {
    jvmtiError result = orig_RetransformClasses(jvmti, class_count, classes);
    fire_listeners();
    return result;
}

// This function is automatically called when JNI library is loaded
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
    void* jvmti;
    (*vm)->GetEnv(vm, &jvmti, JVMTI_VERSION_1_0);
    _vm = vm;

    // Change pointers to JVM TI functions, saving their original addresses
    JVMTIFunctions* functions = *(JVMTIFunctions**)jvmti;
    orig_RedefineClasses = functions->RedefineClasses;
    orig_RetransformClasses = functions->RetransformClasses;
    functions->RedefineClasses = RedefineClassesHook;
    functions->RetransformClasses = RetransformClassesHook;

    return JNI_VERSION_1_6;
}

现在在 Java 代码中我们只需要加载这个 JNI 库。 fireListeners 方法将使用 JNI 从本机代码调用。

HotCodeReplace.java

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class HotCodeReplace {
    private static final List<Listener> listeners = new CopyOnWriteArrayList<>();

    public static void addListener(Listener listener) {
        listeners.add(listener);
    }

    public static void removeListener(Listener listener) {
        listeners.remove(listener);
    }

    private static void fireListeners() {
        for (Listener listener : listeners) {
            listener.onReplace();
        }
    }

    public interface Listener {
        void onReplace();
    }

    static {
        System.loadLibrary("HotCodeReplaceListener");
    }
}

如何使用

HotCodeReplace.addListener(() -> System.out.println("Classes changed!"));

更新

除了 JDK 15 中出现的jdk.ClassRedefinitionJFR 事件之外，没有纯 Java API 来获取类重定义的通知：

var rs = new RecordingStream();
rs.enable("jdk.ClassRedefinition");
rs.onEvent("jdk.ClassRedefinition", event -> {
    System.out.println("Classes changed!");
});
rs.startAsync();

最接近的 JDK 8 替代方案是附加一个注册虚拟 ClassFileTransformer 的 Java 代理，以接收每个加载或重新定义的类的回调。这种方法的缺点是每个类都会触发回调，但在实际重新定义之前。但是，如果不需要立即同步通知，您可以使用后台计时器解决此问题。

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class HotCodeReplace {
    private static final List<Listener> listeners = new CopyOnWriteArrayList<>();
    private static final ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);

    public static void addListener(Listener listener) {
        listeners.add(listener);
    }

    public static void removeListener(Listener listener) {
        listeners.remove(listener);
    }

    private static void fireListeners() {
        for (Listener listener : listeners) {
            listener.onReplace();
        }
    }

    public interface Listener {
        void onReplace();
    }

    public static void premain(String args, Instrumentation inst) {
        inst.addTransformer(new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                                    ProtectionDomain pd, byte[] classFile) {
                if (classBeingRedefined != null) {
                    executor.getQueue().clear();
                    executor.schedule(HotCodeReplace::fireListeners, 1, TimeUnit.SECONDS);
                }
                return null;
            }
        }, true);
    }
}

注意：为了使用 Instrumentation API，您必须使用 -javaagent 选项启动 JVM 或使用 Dynamic Attach 在运行时附加代理。