Java中的动态反射信号处理器

如果有其他信号可用，如何安装信号处理逻辑

背景 我的第一代代码假设信号处理可用，看起来像这样：

class MyApp {
    public static void main(String[] args) {
        ...
        Signal.handle(term_sig, new SignalHandler() {
            public void handle(Signal sig) { ... }
        });
        ...
    }
}

我相信我了解如何反射式测试和使用信号处理程序--

Class.forName（“sun.misc.signal”）

，反射式调用

signal.handle

，等等

我只是想用动态获取的

SignalHandler

类实例化另一个匿名内部类，但我认为这只是一厢情愿的语法。

您需要使用来实现SignalHandler接口。剩下的只是基本的反映

更新

这是你怎么做的。注意，我省略了需要包装所有这些内容的try-catch

        Class<?> handlerCl = Class.forName("sun.misc.SignalHandler");
        Class<?> signalCl = Class.forName("sun.misc.Signal");

        Constructor signalCtor = signalCl.getConstructor(String.class);
        Method signalHandle = signalCl.getMethod("handle", signalCl, handlerCl);

        // Create a proxy class that implements SignalHandler
        Class<?> proxyClass = Proxy.getProxyClass(signalCl.getClassLoader(),
            handlerCl);

        // This is used by the instance of proxyClass to dispatch method calls
        InvocationHandler invHandler = new InvocationHandler()
        {
            public Object invoke(Object proxy,
                Method method, Object[] args) throws Throwable
            {
                // proxy is the SignalHandler's "this" rederence
                // method will be the handle(Signal) method
                // args[0] will be an instance of Signal
                // If you're using this object for multiple signals, you'll
                // you'll need to use the "getName" method to determine which
                // signal you have caught.
                return null;
            }
        };

        // Get the constructor and create an instance of proxyClass
        Constructor<?> proxyCtor = proxyClass.getConstructor(InvocationHandler.class);
        Object handler = proxyCtor.newInstance(invHandler);

        // Create the signal and call Signal.handle to bind handler to signal
        Object signal = signalCtor.newInstance("TERM");
        signalHandle.invoke(null, signal, handler);

Class handlerCl=Class.forName（“sun.misc.SignalHandler”）；
Class signalCl=Class.forName（“sun.misc.Signal”）；
构造函数signalCtor=signalCl.getConstructor（String.class）；
方法signalHandle=signalCl.getMethod（“handle”，signalCl，handlerCl）；
//创建一个实现SignalHandler的代理类
Class proxyClass=Proxy.getProxyClass（signalCl.getClassLoader（），
handlerCl）；
//proxyClass实例使用它来分派方法调用
InvocationHandler invHandler=新的InvocationHandler（）
{
公共对象调用（对象代理，
方法，对象[]args）抛出Throwable
{
//代理是信号处理器的“此”重部署
//方法将是句柄（信号）方法
//args[0]将是信号的一个实例
//如果将此对象用于多个信号，则
//您需要使用“getName”方法来确定
//你抓到的信号。
返回null；
}
};
//获取构造函数并创建proxyClass的实例
构造函数proxyCtor=proxyClass.getConstructor（InvocationHandler.class）；
对象处理程序=proxyCtor.newInstance（invHandler）；
//创建signal并调用signal.handle将处理程序绑定到signal
对象信号=signalCtor.newInstance（“术语”）；
调用（null，signal，handler）；

在这种情况下，动态代理会是什么样子？谢谢，这正是我想要的特定指导！很酷，这将是我第一次使用代理类。