Android React-Native通信数据模型分析
无论是计算机领域还是日常生活中，我们所言的通信，其核心都是数据信息的交换，而数据模型的优劣对通信效率有着决定性的作用。
在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<writablenativearray, readablenativearray> {
static constexpr const char* kjavadescriptor = "lcom/facebook/react/bridge/writablenativearray;";
writablenativearray()
: hybridbase(folly::dynamic({})) {}
static local_ref<jhybriddata> inithybrid(alias_ref<jclass>) {
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<writablenativearray, readablenativearray> {
...
static local_ref<jhybriddata> inithybrid(alias_ref<jclass>) {
return makecxxinstance();
}
...
}
这里的jhybriddata指的就是hybriddata（java）对象，其是通过typedef方式定义在jni/first-party/jni/fbjni/hybrid.h中的。
...
struct hybriddata : public javaclass<hybriddata> {
constexpr static auto kjavadescriptor = "lcom/facebook/jni/hybriddata;";
void setnativepointer(std::unique_ptr<basehybridclass> new_value);
basehybridclass* getnativepointer();
static local_ref<hybriddata> create();
};
...
typedef detail::hybriddata::javaobject jhybriddata;
...
facebook在这里对在jni中创建java对象的过程做了非常高效的封装，即javaclass对象。所有javaclass的子类都通过一个名为kjavadescriptor的字符串指针，来描述相对应的java对象类名。
继续来看makecxxinstance()是如何创建hybriddata（java） 对象的。代码同样在jni/first-party/jni/fbjni/hybrid.h中。
class hybridclass : public detail::hybridtraits<base>::cxxbase {
...
static local_ref<detail::hybriddata> makehybriddata(std::unique_ptr<t> cxxpart) {
auto hybriddata = detail::hybriddata::create();
hybriddata->setnativepointer(std::move(cxxpart));
return hybriddata;
}
template <typename... args>
static local_ref<detail::hybriddata> makecxxinstance(args&&... args) {
return makehybriddata(std::unique_ptr<t>(new t(std::forward<args>(args)...)));
}
...
}
结合下前面的writablenativearray（c++）来看
struct writablenativearray
: public jni::hybridclass<writablenativearray, readablenativearray> {
static constexpr const char* kjavadescriptor = "lcom/facebook/react/bridge/writablenativearray;";
...
static local_ref<jhybriddata> inithybrid(alias_ref<jclass>) {
return makecxxinstance();
}
...
}
在创建hybriddata（java）的时候，模板类hybridclass的第一个泛型t，表示的是writablenativearray（c++）这个结构体。所以，makehybriddata中的new t(std::forward(args)…)新创建的t就是writablenativearray（c++）对象。
继续来看makehybriddata方法，参数cxxpart是刚刚创建的writablenativearray对象的指针。里面通过detail::hybriddata::create()真正创建了hybriddata（java）和hybriddata（c++）对象，并将writablenativearray（c++）对象的指针通过setnativepointer方法注入到了hybriddata（java）中。
接下来，看create和setnativepointer两个方法的细节，在hybrid.cpp中：
local_ref<hybriddata> hybriddata::create() {
return newinstance();
}
void hybriddata::setnativepointer(std::unique_ptr<basehybridclass> new_value) {
static auto pointerfield = getclass()->getfield<jlong>("mnativepointer");
auto* old_value = reinterpret_cast<basehybridclass*>(getfieldvalue(pointerfield));
if (new_value) {
...
} else if (old_value == 0) {
return;
}
delete old_value;
...
setfieldvalue(pointerfield, reinterpret_cast<jlong>(new_value.release()));
}
create里面是通过newinstance方式创建了hybriddata（java） 和hybriddata（c++）对象，具体细节不细说了，读者自行去研究facebook的封装。
hybriddata（c++）的setnativepointer方法中的参数new_value，为writablenativearray（c++）对象的指针， 使用reinterpret_cast关键字将其转换成long型，设置到mnativepointer中。而这里的mnativepointer，就是我们前面谈到的hybriddata（java）类的成员变量了！
有一点需要注意的是，保存writablenativearray（c++）对象指针的时候，会先获取原先保存的指针并删除回收（如果存在的话），主要目的是回收writablenativearray（c++）对象的内存，调用的时机是hybriddata（java）的finalize，也就是writablenativearray（java）和hybriddata（java）被虚拟机gc回收的时候，这说明了一点，就是writablenativearray（c++）对象实例和writablenativearray（java）对象实例的内存释放是完全同步的，都是交由java gc来触发！
到这里我们稍稍梳理一下。
当writablenativearray（java）创建的时候，通过jni调用会先创建writablenativearray（c++）对象，其后会创建hybriddata（java）和hybriddata（c++），同时将writablenativearray（c++）的指针保存到hybriddata（java）的mnativepointer成员变量中，最后把hybriddata（java）保存到writablenativearray（java）对象里面。
这样设计有一个好处。当writablenativearray（java）通过jni的方式传递到c++层时，可以通过保存在其内部的hybriddata（java）对象的mnativepointer的值，还原writablenativearray（c++）对象。
这个还原过程是通过内联函数cthis函数实现的，代码在jni/first-party/jni/fbjni/hybrid.h中：
// 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 <typename t>
inline auto cthis(t jthis) -> decltype(jthis->cthis()) {
return jthis->cthis();
}
inline t* hybridclass<t, b>::javapart::cthis() {
static auto field =
hybridclass<t, b>::javapart::javaclassstatic()->template getfield<detail::hybriddata::javaobject>("mhybriddata");
auto hybriddata = this->getfieldvalue(field);
...
// i'd like to use dynamic_cast here, but -fno-rtti is the default.
t* value = static_cast<t*>(hybriddata->getnativepointer());
...
return value;
};
basehybridclass* hybriddata::getnativepointer() {
static auto pointerfield = getclass()->getfield<jlong>("mnativepointer");
auto* value = reinterpret_cast<basehybridclass*>(getfieldvalue(pointerfield));
...
return value;
}
先提取出writablenativearray（java）对象的mhybriddata，再提取其mnativepointer，最后使用reinterpret_cast还原出writablenativearray（c++）对象。而在writablenativearray（c++）对象中存储着所有push的数据（定义在其父类nativearray中），这样数据的提取工作就完成了。
到此，java传输数据给c++的场景分析完成，下面我们来研究反向过程。
c++传输数据给java的场景，主要是在callnativemodules里面，我们直接来看makejavacall方法，在jni\react\jni\onload.cpp中
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<jexecutortokenholder*>(executortoken.getplatformexecutortoken().get())->getjobj(),
call.moduleid,
call.methodid,
newarray.get());
}
call.arguments是一个封装好的folly::dynamic对象（详见folly开源库），通过newobjectcxxargs方法转换成readablenativearray（c++）对象，实现在jni/first-party/jni/fbjni/hybrid.h中：
template <typename... args>
static local_ref<javapart> newobjectcxxargs(args&&... args) {
auto hybriddata = makecxxinstance(std::forward<args>(args)...);
return javapart::newinstance(hybriddata);
}
template <typename... args>
static local_ref<detail::hybriddata> makecxxinstance(args&&... args) {
return makehybriddata(std::unique_ptr<t>(new t(std::forward<args>(args)...)));
}
template<typename jc, typename... args>
static local_ref<jc> newinstance(args... args) {
static auto cls = jc::javaclassstatic();
static auto constructor = cls->template getconstructor<typename jc::javaobject(args...)>();
return cls->newobject(constructor, args...);
}
创建readablenativearray（c++）对象的过程和前面创建writablenativearray（c++）对象的过程一模一样。先创建hybriddata（java）和hybriddata（c++），同时将readablenativearray（c++）的指针保存到hybriddata（java）的mnativepointer成员变量中。最后readablenativearray（java）对象被封装在javapart中（再次用到facebook用jni创建java对象的封装库），通过get方法获取到真正的实例。
继续来看readablenativearray（java），位于包com.facebook.react.bridge中：
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（java）同样也是一个管道，所有数据仍然是存在c++层，必须全部通过native本地方法来提取，依赖具有了前面说到的两个优点：减少内存和容易回收。
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();
...
jint javaint = static_cast<jint>(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();
}
readablenativearray::getarray(jint index) {
auto& elem = array.at(index);
if (elem.isnull()) {
return jni::local_ref<readablenativearray::jhybridobject>(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),
});
}
对数据的提取，最后仍然是对array对象操作，其是定义在父类nativearray.h中的，不在赘述。
整个数据模型的分析就到此结束了，总结一下有以下几个特点：
1、数据只有一份存储，即在c++中，无论是readablenativearray（java）还是writablenativearray（java）都只是数据存取的管道。
2、readablenativearray和writablenativearray在java层和c++层又都有各自的实例，通过java层实例的hybriddata的mnativepointer作为纽带链接，其存储的是c++层实例的指针。
3、无论是java层还是c++层的readablenativearray和writablenativearray都是统一由java gc进行回收管理。
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！