Java-C++ jni交互新范式：fbjni 设计与使用

1// 传统 JNI：签名字符串手写，三项对不齐只能等运行时 NoSuchMethodError2static jint nativeSum(JNIEnv*, jobject, jint a, jint b) { return a + b; }3static JNINativeMethod methods[] = {4    {"sum", "(II)I", (void*)nativeSum},5};6env->RegisterNatives(clazz, methods, 1);

1// fbjni：签名从 nativeSum 的函数指针类型直接推导，写错类型编译不过2jint nativeSum(alias_ref<jobject>, jint a, jint b) { return a + b; }3registerNatives("com/example/Foo", {4    makeNativeMethod("sum", nativeSum),5});

1// 传统 JNI：New/Delete 要手动配对2jobject globalObj = env->NewGlobalRef(localObj);3// ... 使用 globalObj4env->DeleteGlobalRef(globalObj); // 忘记这一行就是引用泄漏

1// fbjni：生命周期绑定到 C++ 对象，析构自动 DeleteGlobalRef2global_ref<jobject> globalObj = make_global(localObj);3// 离开作用域自动释放，不需要手写清理代码

1// 传统 JNI：C++ 异常裸露到 JNI 边界，进程直接崩溃2extern "C" JNIEXPORT void JNICALL3Java_com_example_Foo_nativeMethod(JNIEnv*, jobject) {4  throw std::runtime_error("boom"); // std::terminate5}

1// fbjni：FunctionWrapper 的 catch(...) 兜底，自动转成 RuntimeException2void nativeMethod(alias_ref<jobject>) {3  throw std::runtime_error("boom"); // 被翻译成 java.lang.RuntimeException4}

1// 传统 JNI：手动 Attach/Detach，忘记 Detach 或提前退出都会出问题2JNIEnv* env;3vm->AttachCurrentThread(&env, nullptr);4// ... 调用 Java 方法5vm->DetachCurrentThread(); // 忘记调用，或者中途 return 跳过这一行

1// fbjni：RAII 守卫，析构自动 Detach，还能拿到应用类加载器2ThreadScope::WithClassLoader([&] {3  javaObj->someMethod(); // 挂载和类加载器都由 fbjni 处理4});

1DemoCase(2    "Primitives",3    "sumPrimitives",4    "byte/short/int/long into C++, which calls Java's doubler() back",5) {6    "sumPrimitives(1, 2, 3, 4) = ${NativeBridge.sumPrimitives(1, 2, 3, 4)}  " +7        "(1+2+3+4 + doubler(3))"8},

1public static native long sumPrimitives(byte b, short s, int i, long l);2 3@DoNotStrip4static long doubler(int i) {5  return 2L * i;6}

1jlong JNativeBridge::sumPrimitives(2    alias_ref<JClass> clazz,3    jbyte b,4    jshort s,5    jint i,6    jlong l) {7  // C++ -> Java: look the static method up once, then call it.8  static const auto doubler = clazz->getStaticMethod<jlong(jint)>("doubler");9  return b + s + i + l + doubler(clazz, i);10}

1makeNativeMethod("sumPrimitives", JNativeBridge::sumPrimitives),

1jint initialize(JavaVM* const vm, std::function<void()>&& init_fn) noexcept {2  Environment::initialize(vm);3 4  try {5    init_fn();6  } catch ([[maybe_unused]] const std::exception& e) {7    FBJNI_LOGE("error %s", e.what());8    translatePendingCppExceptionToJavaException();9  } catch (...) {10    translatePendingCppExceptionToJavaException();11  }12  return JNI_VERSION_1_6;13}

1JavaVM* ROAI g_vm = nullptr;2 3struct EnvironmentInitializer final {4  EnvironmentInitializer(JavaVM* const vm) noexcept {5    FBJNI_ASSERT(!g_vm);6    FBJNI_ASSERT(vm);7    g_vm = vm;8  }9};10 11/* static */12void Environment::initialize(JavaVM* const vm) noexcept {13  static EnvironmentInitializer init(vm);14}

1public static synchronized void load() {2  if (sLoaded) {3    return;4  }5  if (!NativeLoader.isInitialized()) {6    NativeLoader.init(new SystemDelegate());7  }8  NativeLoader.loadLibrary("fbjni");9  NativeLoader.loadLibrary("foojni");10  sLoaded = true;11}

1JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {2  return facebook::jni::initialize(vm, [] {3    HybridDataOnLoad();4    JNativeRunnable::OnLoad();5    ThreadScope::OnLoad();6    registerNatives(7        "com/facebook/jni/FbjniExceptionConfig",8        {makeNativeMethod(9            "setFixReleaseThrowableLeak", setFixReleaseThrowableLeak_jni)});10  });11}

1extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {2  return facebook::jni::initialize(vm, [] {3    foojni::JNativeBridge::registerNatives();4    foojni::NativeCounter::registerNatives();5  });6}

1#define makeNativeMethod2(name, func)                                         \2  {const_cast<char*>(name ""),                                                \3   const_cast<char*>(::facebook::jni::detail::makeDescriptor(&func).c_str()), \4   ::facebook::jni::detail::exceptionWrapJNIMethod<decltype(&func), &func>(   \5       &func)}6 7#define makeNativeMethodN(a, b, c, count, ...) makeNativeMethod##count8#define makeNativeMethod(...) \9  FBJNI_MACRO_EXPAND(makeNativeMethodN(__VA_ARGS__, 3, 2)(__VA_ARGS__))

1template <typename F, typename C, typename R, typename... Args>2struct FunctionWrapper {3  using jniRet = typename Converter<R>::jniType;4  static jniRet call(5      JNIEnv* env,6      jobject obj,7      typename Converter<Args>::jniType... args,8      F funcPtr) {9    detail::JniEnvCacher jec(env);10    try {11      return CallWithJniConversions<F, R, JniType<C>, Args...>::call(12          static_cast<JniType<C>>(obj), args..., funcPtr);13    } catch (...) {14      translatePendingCppExceptionToJavaException();15      return CreateDefault<jniRet>::create();16    }17  }18};

1global_ref<JString>& globalStash() {2  static auto* stash = new global_ref<JString>();3  return *stash;4}5 6weak_ref<jobject>& weakStash() {7  static auto* stash = new weak_ref<jobject>();8  return *stash;9}

1// Given a class:2// struct Foo : JavaClass<Foo> {3//   static constexpr auto kJavaDescriptor = "Lcom/example/package/Foo;";4// };5template <typename T, typename Base = JObject, typename JType = void>6class JavaClass : public Base {7  using JObjType = typename detail::JTypeFor<T, Base, JType>;8 9 public:10  using _javaobject = typename JObjType::_javaobject;11  using javaobject = typename JObjType::javaobject;12  using JavaBase = JavaClass;13 14  static alias_ref<JClass> javaClassStatic();15  static local_ref<JClass> javaClassLocal();16 17 protected:18  template <typename... Args>19  static local_ref<T> newInstance(Args... args) {20    return detail::newInstance<T>(args...);21  }22 23  javaobject self() const noexcept;24};

1template <typename T>2struct jtype_traits {3 private:4  using Repr = ReprType<T>;5  static constexpr auto descriptor() {6    constexpr auto len = Repr::kJavaDescriptor7        ? detail::constexpr_strlen(Repr::kJavaDescriptor)8        : Repr::get_instantiated_java_descriptor().size();9    // ...10  }11 12 public:13  static constexpr descriptorType kDescriptor = descriptor();14  static constexpr basenameType kBaseName = base_name();15};

1DEFINE_FIELD_AND_ARRAY_TRAIT(jboolean, Z)2DEFINE_FIELD_AND_ARRAY_TRAIT(jbyte, B)3DEFINE_FIELD_AND_ARRAY_TRAIT(jint, I)4DEFINE_FIELD_AND_ARRAY_TRAIT(jlong, J)5// ...

1struct JPoint : JavaClass<JPoint> {2  static constexpr auto kJavaDescriptor =3      "Lcom/example/foojni/nativebridge/Point;";4 5  static local_ref<JPoint> create(jint x, jint y) {6    return newInstance(x, y);7  }8 9  jint getX() const {10    static const auto field = javaClassStatic()->getField<jint>("x");11    return getFieldValue(field);12  }13 14  jint sum() const {15    static const auto method = javaClassStatic()->getMethod<jint()>("sum");16    return method(self());17  }18};

1struct HybridData : public JavaClass<HybridData> {2  constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridData;";3  static local_ref<HybridData> create();4  static local_ref<HybridData> create(BaseHybridClass* ptr);5};

1template <typename T, typename Base = detail::BaseHybridClass>2class HybridClass : public detail::HybridTraits<Base>::CxxBase {3 public:4  struct JavaPart5      : JavaClass<JavaPart, typename detail::HybridTraits<Base>::JavaBase> {6    using HybridType = T;7    T* cthis() const;8    friend class HybridClass;9    friend T;10  };11 12  using jhybridobject = typename JavaPart::javaobject;13 14 protected:15  static local_ref<detail::HybridData> makeHybridData(16      std::unique_ptr<T> cxxPart) {17    auto hybridData = detail::HybridData::create();18    setNativePointer(hybridData, std::move(cxxPart));19    return hybridData;20  }21 22 public:23  template <typename... Args>24  static local_ref<JavaPart> newObjectCxxArgs(Args&&... args) {25    auto cxxPart = std::unique_ptr<T>(new T(std::forward<Args>(args)...));26    // ... 走 setNativePointer 或 JavaPart::newInstance(hybridData)27  }28};

1template <typename T, typename B>2inline T* HybridClass<T, B>::JavaPart::cthis() const {3  detail::BaseHybridClass* result = nullptr;4  static const auto hybridDataField = detectHybrid<T, B>(this->getClass());5  result = getHybridDataFromField(this, hybridDataField);6  return static_cast<T*>(result);7}

1std::atomic<int> NativeCounter::sLiveInstances{0};2 3NativeCounter::NativeCounter(jint initial) : value_(initial) {4  sLiveInstances.fetch_add(1, std::memory_order_relaxed);5}6 7NativeCounter::~NativeCounter() {8  sLiveInstances.fetch_sub(1, std::memory_order_relaxed);9}10 11local_ref<NativeCounter::jhybriddata> NativeCounter::initHybrid(12    alias_ref<jhybridobject>,13    jint initial) {14  return makeCxxInstance(initial);15}16 17local_ref<NativeCounter::jhybridobject> NativeCounter::createFromCpp(18    alias_ref<jclass>,19    jint initial) {20  return newObjectCxxArgs(initial);21}22 23void NativeCounter::addFrom(alias_ref<jhybridobject> other) {24  value_ += cthis(other)->value_;25}26 27void NativeCounter::registerNatives() {28  registerHybrid({29      makeNativeMethod("initHybrid", NativeCounter::initHybrid),30      makeNativeMethod("createFromCpp", NativeCounter::createFromCpp),31      makeNativeMethod("add", NativeCounter::add),32      // ...33  });34}

1local_ref<JThrowable> convertCppExceptionToJavaException(2    std::exception_ptr ptr) {3  local_ref<JThrowable> current;4  try {5    std::rethrow_exception(ptr);6  } catch (JniException& ex) {7    current = ex.releaseThrowable();8  } catch (const std::ios_base::failure& ex) {9    current = JIOException::create(ex.what());10  } catch (const std::invalid_argument& ex) {11    current = JIllegalArgumentException::create(ex.what());12  } catch (const std::bad_alloc& ex) {13    current = JOutOfMemoryError::create(ex.what());14  } catch (const std::out_of_range& ex) {15    current = JArrayIndexOutOfBoundsException::create(ex.what());16  } catch (const std::runtime_error& ex) {17    current = JRuntimeException::create(ex.what());18  } catch (const std::exception& ex) {19    current = JCppException::create(ex.what());20  } catch (...) {21    // 兜底成 JUnknownCppException,尽量带上 RTTI 里的类型名22  }23  addCppStacktraceToJavaException(current, ptr);24  return current;25}

1void JNativeBridge::throwDemoExceptionFromCpp(2    alias_ref<JClass>,3    std::string m) {4  throwNewJavaException(5      "com/example/foojni/nativebridge/DemoException", "%s", m.c_str());6}

1class JniException : public std::exception {2 public:3  JniException();4  explicit JniException(alias_ref<jthrowable> throwable);5 6  local_ref<JThrowable> getThrowable() const noexcept;7  local_ref<JThrowable> releaseThrowable() noexcept;8  const char* what() const noexcept override;9 10 private:11  global_ref<JThrowable> throwable_;12};

1std::string JNativeBridge::catchJavaException(alias_ref<JClass> clazz) {2  try {3    static const auto method = clazz->getStaticMethod<void()>("alwaysThrows");4    method(clazz);5  } catch (const JniException& e) {6    auto throwable = e.getThrowable();7    auto message = throwable->getMessage();8    return "caught:" + throwable->getClass()->toString() + ":" +9        (message ? message->toStdString() : std::string("<none>"));10  }11  return "no-exception";12}

1tls_key_t getTLKey() {2  static tls_key_t key = makeKey();3  return key;4}5 6inline JNIEnv* cachedOrNull() {7  detail::TLData* pdata = getTLData(getTLKey());8  return (pdata ? pdata->env : nullptr);9}

1ThreadScope::ThreadScope() : thisAttached_(false) {2  if (g_vm == nullptr) {3    throw std::runtime_error(4        "fbjni is uninitialized; no thread can be attached.");5  }6  JNIEnv* env;7  auto result = getEnv(&env);8  if (result == JNI_OK) {9    return; // 已经挂载过了,什么都不做10  }11  // ... 设置 TLS,调用 attachCurrentThread()12  data_.attached = true;13  thisAttached_ = true;14}15 16ThreadScope::~ThreadScope() {17  if (!thisAttached_) {18    return;19  }20  g_vm->DetachCurrentThread();21  setTLData(key, nullptr);22}

1void ThreadScope::WithClassLoader(std::function<void()>&& runnable) {2  if (cachedOrNull() == nullptr) {3    ThreadScope ts;4    JThreadScopeSupport::runStdFunction(std::move(runnable));5  } else {6    runnable();7  }8}