React-Native系列Android——通信數據模型分析

無論是計算機領域還是日常生活中，我們所言的通信，其核心都是數據信息的交換，而數據模型的優劣對通信效率有著決定性的作用。

在React-Native項目中，Javascript語言與Native兩種語言（Java或OC等）間存在著大量的數據交換，也就是所謂的通信。眾所周知，移動APP對性能的要求無比苛刻，如果通信數據模型設計地不合理，很可能引起多線程下的數據安全問題，以及應用性能問題，比如內存洩漏，UI繪制緩慢等。

前面幾篇博客我們詳細分析過React-Native的通信機制，主要有兩個方向： Java->Bridge->Javascript和Javascript->Bridge->Java。所以，真正的數據交換其實發生在Java與Bridge，Javascript與Bridge兩個環節。

Javascript與Bridge間的數據通信是借助於Webkit使用Json完成，簡單實用，水到渠成，不多分析。而Java與Bridge間的數據通信相比之下就復雜多了，作為真正運行在設備上的程序語言，這恰恰是決定整個通信過程效率高低最核心的一環，也是本篇博客研究的內容。

Java是Android應用程序的本地開發語言，而Bridge是使用C++開發的動態鏈接庫，由Java語言通過JNI的方式調用。Java與Bridge間的數據通信，實質是Java和C++兩種程序語言間的數據傳輸，而傳遞的方向又分為兩個場景：Java傳輸數據給C++ 和C++ 傳輸數據給Java。

我們先來看第一種場景。

Java主動向Javascript通信，主要是通過ReactBridge.java類的callFunction方法，將需要調用的組件（moduleId）、功能（methodId）、數據（arguments）三者傳遞到Bridge。

package com.facebook.react.bridge;

public class ReactBridge extends Countable {

  static final String REACT_NATIVE_LIB = "reactnativejni";

  static {
    SoLoader.loadLibrary(REACT_NATIVE_LIB);
  }

  ...

  public native void callFunction(int moduleId, int methodId, NativeArray arguments);

  ...

}

我們可以看到，傳輸的數據類型是NativeArray，來瞧下具體的代碼，位於com.facebook.react.bridge包下：

public abstract class NativeArray {
  static {
    SoLoader.loadLibrary(ReactBridge.REACT_NATIVE_LIB);
  }

  protected NativeArray(HybridData hybridData) {
    mHybridData = hybridData;
  }

  @Override
  public native String toString();

  @DoNotStrip
  private HybridData mHybridData;
}

NativeArray是一個抽象類，其中，只有一個HybridData類型成員變量，由其構造方法賦值初始化。

NativeArray還有一個名為ReadableNativeArray的直接子類，和一個名為WritableNativeArray的間接子類，後者是繼承於前者。顧名思義，一個是用於讀數據，一個是用於寫數據。

Java向Bridge傳輸數據，自然就是寫數據了，所以我們先來看WritableNativeArray。

package com.facebook.react.bridge;

public class WritableNativeArray extends ReadableNativeArray implements WritableArray {

  static {
    SoLoader.loadLibrary(ReactBridge.REACT_NATIVE_LIB);
  }

  public WritableNativeArray() {
    super(initHybrid());
  }

  @Override
  public native void pushNull();
  @Override
  public native void pushBoolean(boolean value);
  @Override
  public native void pushDouble(double value);
  @Override
  public native void pushInt(int value);
  @Override
  public native void pushString(String value);

  @Override
  public void pushArray(WritableArray array) {
    Assertions.assertCondition(
        array == null || array instanceof WritableNativeArray, "Illegal type provided");
    pushNativeArray((WritableNativeArray) array);
  }

  @Override
  public void pushMap(WritableMap map) {
    Assertions.assertCondition(
        map == null || map instanceof WritableNativeMap, "Illegal type provided");
    pushNativeMap((WritableNativeMap) map);
  }

  private native static HybridData initHybrid();
  private native void pushNativeArray(WritableNativeArray array);
  private native void pushNativeMap(WritableNativeMap map);
}

裡面有7個寫數據的native方法，涵蓋了int、string，array，map等不同的數據類型和結構。

還有一個名為initHybrid()的native方法，用於創建HybridData類的實例，然後通過構造方法給其超父類NativeArray的mHybridData成員變量賦值，具體作用後面來分析，先略過。

接下來，我們來驗證一下WritableNativeArray是否是真正傳輸給Bridge的數據類型。

Java調用Javascript組件，都是由名為JavaScriptModuleInvocationHandler的動態代理類統一攔截處理的嗎？來回顧一下代碼，位於com.facebook.react.bridge.JavaScriptModuleRegistry.java：

  private static class JavaScriptModuleInvocationHandler implements InvocationHandler {

    private final CatalystInstanceImpl mCatalystInstance;
    private final JavaScriptModuleRegistration mModuleRegistration;

    public JavaScriptModuleInvocationHandler(
        CatalystInstanceImpl catalystInstance,
        JavaScriptModuleRegistration moduleRegistration) {
      mCatalystInstance = catalystInstance;
      mModuleRegistration = moduleRegistration;
    }

    @Override
    public @Nullable Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      String tracingName = mModuleRegistration.getTracingName(method);
      mCatalystInstance.callFunction(
          mModuleRegistration.getModuleId(),
          mModuleRegistration.getMethodId(method),
          Arguments.fromJavaArgs(args),
          tracingName);
      return null;
    }
  }

callFunction方法傳遞的參數類型是Arguments.fromJavaArgs(args)，具體代碼又如下：

  public static WritableNativeArray fromJavaArgs(Object[] args) {
    WritableNativeArray arguments = new WritableNativeArray();
    for (int i = 0; i < args.length; i++) {
      Object argument = args[i];
      if (argument == null) {
        arguments.pushNull();
        continue;
      }

      Class argumentClass = argument.getClass();
      if (argumentClass == Boolean.class) {
        arguments.pushBoolean(((Boolean) argument).booleanValue());
      } else if (argumentClass == Integer.class) {
        arguments.pushDouble(((Integer) argument).doubleValue());
      } else if (argumentClass == Double.class) {
        arguments.pushDouble(((Double) argument).doubleValue());
      } else if (argumentClass == Float.class) {
        arguments.pushDouble(((Float) argument).doubleValue());
      } else if (argumentClass == String.class) {
        arguments.pushString(argument.toString());
      } else if (argumentClass == WritableNativeMap.class) {
        arguments.pushMap((WritableNativeMap) argument);
      } else if (argumentClass == WritableNativeArray.class) {
        arguments.pushArray((WritableNativeArray) argument);
      } else {
        throw new RuntimeException("Cannot convert argument of type " + argumentClass);
      }
    }
    return arguments;
  }

正如我們猜測的一般，fromJavaArgs靜態方法返回的是一個新創建的WritableNativeArray對象實例，然後按照數據類型，調用相應的push方法。有些特殊的是，int型和float型都當成了double型來處理，這樣做並不會造成數據的損害。

剛剛說到，WritableNativeArray的所有寫入數據的方法都是native方法，即Java層面的通信數據全部是直接寫入到Bridge層的，換言之，WritableNativeArray僅僅起到了數據傳輸管道的作用。這樣做，有兩個好處：

1、數據只在C++存有一份，這樣避免了數據具有多個副本，節省了一部分的內存。
2、減小對WritableNativeArray對象的依賴，使其容易釋放，可以由虛擬機GC自動回收內存。

那麼，在Bridge層中，C++又是如何處理push過來的數據的呢？

先來看一下WritableNativeArray中native方法在JNI中動態注冊的代碼，位於react/jni/OnLoad.cpp中

static void registerNatives() {
    jni::registerNatives("com/facebook/react/bridge/WritableNativeArray", {
        makeNativeMethod("initHybrid", WritableNativeArray::initHybrid),
        makeNativeMethod("pushNull", WritableNativeArray::pushNull),
        makeNativeMethod("pushBoolean", WritableNativeArray::pushBoolean),
        makeNativeMethod("pushDouble", WritableNativeArray::pushDouble),
        makeNativeMethod("pushInt", WritableNativeArray::pushInt),
        makeNativeMethod("pushString", WritableNativeArray::pushString),
        makeNativeMethod("pushNativeArray", WritableNativeArray::pushNativeArray),
        makeNativeMethod("pushNativeMap", "(Lcom/facebook/react/bridge/WritableNativeMap;)V",
                         WritableNativeArray::pushNativeMap),
    });
  }

很明顯，在C++中也存在著一個名為WritableNativeArray的類，具有與著native方法相對應的方法，巧的是，它也是繼承於ReadableNativeArray類（注意HybridClass模板類的第二個泛型表示父類）：

struct WritableNativeArray
    : public jni::HybridClass {
  static constexpr const char* kJavaDescriptor = "Lcom/facebook/react/bridge/WritableNativeArray;";

  WritableNativeArray()
      : HybridBase(folly::dynamic({})) {}

  static local_ref initHybrid(alias_ref) {
    return makeCxxInstance();
  }

  void pushNull() {
    ...
    array.push_back(nullptr);
  }

  void pushBoolean(jboolean value) {
    ...
    array.push_back(value == JNI_TRUE);
  }

  void pushDouble(jdouble value) {
    ...
    array.push_back(value);
  }

  void pushInt(jint value) {
    ...
    array.push_back(value);
  }

  void pushString(jstring value) {
    ...
    array.push_back(wrap_alias(value)->toStdString());
  }

  void pushNativeArray(WritableNativeArray* otherArray) {
    ...
    array.push_back(std::move(otherArray->array));
    otherArray->isConsumed = true;
  }

  void pushNativeMap(jobject jmap) {
    ...
    array.push_back(std::move(map->map));
    map->isConsumed = true;
  }
  ...
}

看到這裡，我們不禁會猜測，C++中的ReadableNativeArray類很可能也是繼承於NativeArray。

當然，事實確實是這樣的。在C++中存在著與Java中完全呼應的三個類：NativeArray、ReadableNativeArray、WritableNativeArray，命名和繼承關系都是完全一致的！

而且可以看到，所有的數據都被存儲到父類NativeArray的array變量中。

不過，問題來了！

C++中的WritableNativeArray對象和Java中的WritableNativeArray兩個同名對象間是否存在著某種聯系呢，比如一一映射的關系？

答案是肯定的! 因為每當一個Java層的WritableNativeArray對象被創建，在C++層都會有一個相應的WritableNativeArray對象被創建，用來接收Java層push過來的數據。

再來回顧下WritableNativeArray.java創建的過程。

public class WritableNativeArray extends ReadableNativeArray implements WritableArray {
   ...
   public WritableNativeArray() {
      super(initHybrid());
   }
   ...
   private native static HybridData initHybrid();
   ...
}

在構造WritableNativeArray的時候，會通過initHybrid方法創建一個HybridData對象，並保存到其超父類NativeArray的成員變量mHybridData中。

而HybridData對象又是什麼呢？

public class HybridData {
    // Private C++ instance
    private long mNativePointer = 0;
    public HybridData() {
       Prerequisites.ensure();
    }
    public native void resetNative();

   protected void finalize() throws Throwable {
      resetNative();
      super.finalize();
   }
}

public class Prerequisites {
   ...
   public static void ensure() {
       SoLoader.loadLibrary("fbjni");
   }
   ...
}

構造函數中Prerequisites.ensure()，是用來加載fbjni動態鏈接庫的。

在HybridData 類中，有一個long的私有成員變量，根據注釋和名字可以猜測與C++指針相關，具體是不是這樣呢？我們來看HybridData對象通過initHybrid()初始化的過程。

代碼位於react/jni/OnLoad.cpp中：

struct WritableNativeArray
    : public jni::HybridClass {
   ...

  static local_ref initHybrid(alias_ref) {
      return makeCxxInstance();
  }

   ... 
}

這裡的jhybriddata指的就是HybridData（Java）對象，其是通過typedef方式定義在jni/first-party/jni/fbjni/Hybrid.h中的。

...

struct HybridData : public JavaClass {
   constexpr static auto kJavaDescriptor = "Lcom/facebook/jni/HybridData;";
   void setNativePointer(std::unique_ptr new_value);
   BaseHybridClass* getNativePointer();
   static local_ref create();
};

...

typedef detail::HybridData::javaobject jhybriddata;

...

template 
class HybridClass : public detail::HybridTraits::CxxBase {
   ...

   static local_ref makeHybridData(std::unique_ptr cxxPart) {
      auto hybridData = detail::HybridData::create();
      hybridData->setNativePointer(std::move(cxxPart));
      return hybridData;
    }

    template 
    static local_ref makeCxxInstance(Args&&... args) {
       return makeHybridData(std::unique_ptr(new T(std::forward(args)...)));
    }

   ...
}

struct WritableNativeArray
    : public jni::HybridClass {
  static constexpr const char* kJavaDescriptor = "Lcom/facebook/react/bridge/WritableNativeArray;";

   ...

   static local_ref initHybrid(alias_ref) {
      return makeCxxInstance();
   }

   ...
}

local_ref HybridData::create() {
  return newInstance();
}

void HybridData::setNativePointer(std::unique_ptr new_value) {
  static auto pointerField = getClass()->getField("mNativePointer");
  auto* old_value = reinterpret_cast(getFieldValue(pointerField));
  if (new_value) {
    ...
  } else if (old_value == 0) {
    return;
  }
  delete old_value;
  ...
  setFieldValue(pointerField, reinterpret_cast(new_value.release()));
}

// Given a *_ref object which refers to a hybrid class, this will reach inside
// of it, find the mHybridData, extract the C++ instance pointer, cast it to
// the appropriate type, and return it.
template 
inline auto cthis(T jthis) -> decltype(jthis->cthis()) {
   return jthis->cthis();
}

template 
inline T* HybridClass::JavaPart::cthis() {
  static auto field = HybridClass::JavaPart::javaClassStatic()->template getField("mHybridData");
  auto hybridData = this->getFieldValue(field);
  ...
  // I'd like to use dynamic_cast here, but -fno-rtti is the default.
  T* value = static_cast(hybridData->getNativePointer());
  // This would require some serious programmer error.
  FBASSERTMSGF(value != 0, "Incorrect C++ type in hybrid field");
  return value;
};

BaseHybridClass* HybridData::getNativePointer() {
  static auto pointerField = getClass()->getField("mNativePointer");
  auto* value = reinterpret_cast(getFieldValue(pointerField));
  ...
  return value;
}

static void makeJavaCall(JNIEnv* env, ExecutorToken executorToken, jobject callback, const MethodCall& call) {
  if (call.arguments.isNull()) {
    return;
  }

  ...

  auto newArray = ReadableNativeArray::newObjectCxxArgs(std::move(call.arguments));
  env->CallVoidMethod(
      callback,
      gCallbackMethod,
      static_cast(executorToken.getPlatformExecutorToken().get())->getJobj(),
      call.moduleId,
      call.methodId,
      newArray.get());
}

  template 
  static local_ref newObjectCxxArgs(Args&&... args) {
    auto hybridData = makeCxxInstance(std::forward(args)...);
    return JavaPart::newInstance(hybridData);
  }

  template 
  static local_ref makeCxxInstance(Args&&... args) {
    return makeHybridData(std::unique_ptr(new T(std::forward(args)...)));
  }

template
static local_ref newInstance(Args... args) {
  static auto cls = JC::javaClassStatic();
  static auto constructor = cls->template getConstructor();
  return cls->newObject(constructor, args...);
}

public class ReadableNativeArray extends NativeArray implements ReadableArray {
   static {
      SoLoader.loadLibrary(ReactBridge.REACT_NATIVE_LIB);
   }

   protected ReadableNativeArray(HybridData hybridData) {
      super(hybridData);
   }

   @Override
   public native int size();
   @Override
   public native boolean isNull(int index);
   @Override
   public native boolean getBoolean(int index);
   @Override
   public native double getDouble(int index);
   @Override
   public native int getInt(int index);
   @Override
   public native String getString(int index);
   @Override
   public native ReadableNativeArray getArray(int index);
   @Override
   public native ReadableNativeMap getMap(int index);
   @Override
   public native ReadableType getType(int index);
}

ReadableNativeArray::ReadableNativeArray(folly::dynamic array)
    : HybridBase(std::move(array)) {}

...

jint ReadableNativeArray::getSize() {
  return array.size();
}

jboolean ReadableNativeArray::isNull(jint index) {
  return array.at(index).isNull() ? JNI_TRUE : JNI_FALSE;
}

jboolean ReadableNativeArray::getBoolean(jint index) {
  return array.at(index).getBool() ? JNI_TRUE : JNI_FALSE;
}

jdouble ReadableNativeArray::getDouble(jint index) {
  const folly::dynamic& val = array.at(index);
  if (val.isInt()) {
    return val.getInt();
  }
  return val.getDouble();
}

jint ReadableNativeArray::getInt(jint index) {
  auto integer = array.at(index).getInt();
  static_assert(std::is_same::value,
                "folly::dynamic int is not int64_t");
  jint javaint = static_cast(integer);
  if (integer != javaint) {
    throwNewJavaException(
      exceptions::gUnexpectedNativeTypeExceptionClass,
      "Value '%lld' doesn't fit into a 32 bit signed int", integer);
  }
  return javaint;
}

const char* ReadableNativeArray::getString(jint index) {
  const folly::dynamic& dyn = array.at(index);
  if (dyn.isNull()) {
    return nullptr;
  }
  return dyn.getString().c_str();
}

jni::local_ref ReadableNativeArray::getArray(jint index) {
  auto& elem = array.at(index);
  if (elem.isNull()) {
    return jni::local_ref(nullptr);
  } else {
    return ReadableNativeArray::newObjectCxxArgs(elem);
  }
}

jobject ReadableNativeArray::getMap(jint index) {
  return createReadableNativeMapWithContents(Environment::current(), array.at(index));
}

jobject ReadableNativeArray::getType(jint index) {
  return type::getType(array.at(index).type());
}

void ReadableNativeArray::registerNatives() {
  jni::registerNatives("com/facebook/react/bridge/ReadableNativeArray", {
    makeNativeMethod("size", ReadableNativeArray::getSize),
    makeNativeMethod("isNull", ReadableNativeArray::isNull),
    makeNativeMethod("getBoolean", ReadableNativeArray::getBoolean),
    makeNativeMethod("getDouble", ReadableNativeArray::getDouble),
    makeNativeMethod("getInt", ReadableNativeArray::getInt),
    makeNativeMethod("getString", ReadableNativeArray::getString),
    makeNativeMethod("getArray", ReadableNativeArray::getArray),
    makeNativeMethod("getMap", "(I)Lcom/facebook/react/bridge/ReadableNativeMap;",
                     ReadableNativeArray::getMap),
    makeNativeMethod("getType", "(I)Lcom/facebook/react/bridge/ReadableType;",
                     ReadableNativeArray::getType),
  });
}