详解JNA中的回调方法

目录

• 简介
• JNA 中的 Callback
• callback 的应用
• callback 的定义
• callback 的获取和应用
• 在多线程环境中使用 callback
• 总结

简介

什么是 callback 呢？简单点说 callback 就是回调通知，当我们需要在某个方法完成之后，或者某个事件触发之后，来通知进行某些特定的任务就需要用到 callback 了。

最有可能看到 callback 的语言就是 javascript 了，基本上在 javascript 中，callback 无处不在。为了解决 callback 导致的回调地狱的问题，ES6 中特意引入了 promise 来解决这个问题。

为了方便和 native 方法进行交互，JNA 中同样提供了 Callback 用来进行回调。JNA 中回调的本质是一个指向 native 函数的指针，通过这个指针可以调用 native 函数中的方法，一起来看看吧。

JNA 中的 Callback

先看下 JNA 中 Callback 的定义：

public interface Callback {
    interface UncaughtExceptionHandler {
        void uncaughtException(Callback c, Throwable e);
    }
 
    String METHOD_NAME = "callback";
 
    List FORBIDDEN_NAMES = Collections.unmodifiableList(
            Arrays.asList("hashCode", "equals", "toString"));
}

所有的 Callback 方法都需要实现这个 Callback 接口。Callback 接口很简单，里面定义了一个 interface 和两个属性。

先来看这个 interface,interface 名字叫做 UncaughtExceptionHandler, 里面有一个 uncaughtException 方法。这个 interface 主要用于处理 JAVA 的 callback 代码中没有捕获的异常。

注意，在 uncaughtException 方法中，不能抛出异常，任何从这个方法抛出的异常都会被忽略。

METHOD_NAME 这个字段指定了 Callback 要调用的方法。

如果 Callback 类中只定义了一个 public 的方法，那么默认 callback 方法就是这个方法。如果 Callback 类中定义了多个 public 方法，那么会选择 METHOD_NAME = “callback” 的这个方法作为 callback。

最后一个属性就是 FORBIDDEN_NAMES。表示在这个列表里面的名字是不能作为 callback 方法使用的。

目前看来是有三个方法名不能够被使用，分别是：”hashCode”, “equals”, “toString”。

Callback 还有一个同胞兄弟叫做 DLLCallback，我们来看下 DLLCallback 的定义：

public interface DLLCallback extends Callback {
    @java.lang.annotation.Native
    int DLL_FPTRS = 16;
}

DLLCallback 主要是用在 Windows API 的访问中。

对于 callback 对象来说，需要我们自行负责对 callback 对象的释放工作。如果 native 代码尝试访问一个被回收的 callback，那么有可能会导致 VM 崩溃。

callback 的应用

callback 的定义

因为 JNA 中的 callback 实际上映射的是 native 中指向函数的指针。首先看一下在 struct 中定义的函数指针：

struct _functions {
  int (*open)(const char*,int);
  int (*close)(int);
};

在这个结构体中，定义了两个函数指针，分别带两个参数和一个参数。

对应的 JNA 的 callback 定义如下：

public class Functions extends Structure {
  public static interface OpenFunc extends Callback {
    int invoke(String name, int options);
  }
  public static interface CloseFunc extends Callback {
    int invoke(int fd);
  }
  public OpenFunc open;
  public CloseFunc close;
}

我们在 Structure 里面定义两个接口继承自 Callback，对应的接口中定义了相应的 invoke 方法。

然后看一下具体的调用方式：

Functions funcs = new Functions();
lib.init(funcs);
int fd = funcs.open.invoke("myfile", 0);
funcs.close.invoke(fd);

另外 Callback 还可以作为函数的返回值，如下所示：

typedef void (*sig_t)(int);
sig_t signal(int signal, sig_t sigfunc);

对于这种单独存在的函数指针，我们需要自定义一个 Library, 并在其中定义对应的 Callback，如下所示：

public interface CLibrary extends Library {
    public interface SignalFunction extends Callback {
        void invoke(int signal);
    }
    SignalFunction signal(int signal, SignalFunction func);
}

callback 的获取和应用

如果 callback 是定义在 Structure 中的，那么可以在 Structure 进行初始化的时候自动实例化，然后只需要从 Structure 中访问对应的属性即可。

如果 callback 定义是在一个普通的 Library 中的话，如下所示：

    public static interface TestLibrary extends Library {
        interface VoidCallback extends Callback {
            void callback();
        }
        interface ByteCallback extends Callback {
            byte callback(byte arg, byte arg2);
        }
        void callVoidCallback(VoidCallback c);
        byte callInt8Callback(ByteCallback c, byte arg, byte arg2);
    }

上例中，我们在一个 Library 中定义了两个 callback，一个是无返回值的 callback，一个是返回 byte 的 callback。

JNA 提供了一个简单的工具类来帮助我们获取 Callback，这个工具类就是 CallbackReference，对应的方法是 CallbackReference.getCallback, 如下所示：

Pointer p = new Pointer("MultiplyMappedCallback".hashCode());
Callback cbV1 = CallbackReference.getCallback(TestLibrary.VoidCallback.class, p);
Callback cbB1 = CallbackReference.getCallback(TestLibrary.ByteCallback.class, p);
log.info("cbV1:{}",cbV1);
log.info("cbB1:{}",cbB1);

输出结果如下：

INFO com.flydean.CallbackUsage - cbV1:Proxy interface to native function@0xffffffffc46eeefc (com.flydean.CallbackUsageTestLibraryVoidCallback)
INFO com.flydean.CallbackUsage - cbB1:Proxy interface to native function@0xffffffffc46eeefc (com.flydean.CallbackUsageTestLibraryByteCallback)

可以看出，这两个 Callback 实际上是对 native 方法的代理。如果详细看 getCallback 的实现逻辑：

private static Callback getCallback(Class type, Pointer p, boolean direct) {
        if (p == null) {
            return null;
        }
 
        if (!type.isInterface())
            throw new IllegalArgumentException("Callback type must be an interface");
        Map map = direct ? directCallbackMap : callbackMap;
        synchronized(pointerCallbackMap) {
            Reference[] array = pointerCallbackMap.get(p);
            Callback cb = getTypeAssignableCallback(type, array);
            if (cb != null) {
                return cb;
            }
            cb = createCallback(type, p);
            pointerCallbackMap.put(p, addCallbackToArray(cb,array));
 
            // No CallbackReference for this callback
            map.remove(cb);
            return cb;
        }
    }

可以看到它的实现逻辑是首先判断 type 是否是 interface，如果不是 interface 则会报错。然后判断是否是 direct mapping。实际上当前 JNA 的实现都是 interface mapping，所以接下来的逻辑就是从 pointerCallbackMap 中获取函数指针对应的 callback。然后按照传入的类型来查找具体的 Callback。

如果没有查找到，则创建一个新的 callback，最后将这个新创建的存入 pointerCallbackMap 中。

大家要注意， 这里有一个关键的参数叫做 Pointer，实际使用的时候，需要传入指向真实 naitve 函数的指针。上面的例子中，为了简便起见，我们是自定义了一个 Pointer，这个 Pointer 并没有太大的实际意义。

如果真的要想在 JNA 中调用在 TestLibrary 中创建的两个 call 方法：callVoidCallback 和 callInt8Callback，首先需要加载对应的 Library：

TestLibrary lib = Native.load("testlib", TestLibrary.class);

然后分别创建 TestLibrary.VoidCallback 和 TestLibrary.ByteCallback 的实例如下，首先看一下 VoidCallback：

final boolean[] voidCalled = { false };
        TestLibrary.VoidCallback cb1 = new TestLibrary.VoidCallback() {
            @Override
            public void callback() {
                voidCalled[0] = true;
            }
        };
        lib.callVoidCallback(cb1);
        assertTrue("Callback not called", voidCalled[0]);

这里我们在 callback 中将 voidCalled 的值回写为 true 表示已经调用了 callback 方法。

再看看带返回值的 ByteCallback:

final boolean[] int8Called = {false};
        final byte[] cbArgs = { 0, 0 };
        TestLibrary.ByteCallback cb2 = new TestLibrary.ByteCallback() {
            @Override
            public byte callback(byte arg, byte arg2) {
                int8Called[0] = true;
                cbArgs[0] = arg;
                cbArgs[1] = arg2;
                return (byte)(arg + arg2);
            }
        };
 
final byte MAGIC = 0x11;
byte value = lib.callInt8Callback(cb2, MAGIC, (byte)(MAGIC*2));

我们直接在 callback 方法中返回要返回的 byte 值即可。

在多线程环境中使用 callback

默认情况下， callback 方法是在当前的线程中执行的。如果希望 callback 方法是在另外的线程中执行，则可以创建一个 CallbackThreadInitializer, 指定 daemon,detach,name, 和 threadGroup 属性：

        final String tname = "VoidCallbackThreaded";
        ThreadGroup testGroup = new ThreadGroup("Thread group for callVoidCallbackThreaded");
        CallbackThreadInitializer init = new CallbackThreadInitializer(true, false, tname, testGroup);

然后创建 callback 的实例：

TestLibrary.VoidCallback cb = new TestLibrary.VoidCallback() {
            @Override
            public void callback() {
                Thread thread = Thread.currentThread();
                daemon[0] = thread.isDaemon();
                name[0] = thread.getName();
                group[0] = thread.getThreadGroup();
                t[0] = thread;
                if (thread.isAlive()) {
                    alive[0] = true;
                }
 
                ++called[0];
                if (THREAD_DETACH_BUG && called[0] == 2) {
                    Native.detach(true);
                }
            }
        };

然后调用:

 Native.setCallbackThreadInitializer(cb, init);

将 callback 和 CallbackThreadInitializer 进行关联。

最后调用 callback 方法即可：

lib.callVoidCallbackThreaded(cb, 2, 2000, "callVoidCallbackThreaded", 0);

总结

JNA 中的 callback 可以实现向 native 方法中传递方法的作用，在某些情况下用处还是非常大的。

本文的代码：https://github.com/ddean2009/learn-java-base-9-to-20.git

到此这篇关于JNA中的回调方法的文章就介绍到这了,更多相关jna回调内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！