小草33
小草33

ReactNative Android源码分析

这篇文章针对于对rn有些基础的同学，没有基础的同学可以先了解一下rn以后再看这篇文章。要想深入理解 React Native 的工作原理，有两个部分的源码需要阅读：rn的初始化和java与js通信的过程，首先分析rn的初始化过程。

一、RN的初始化过程

从官方rn的demo入手，看rn是如何一步步如何初始化的：

public class MainActivity extends ReactActivity {

／**

*  用来返回要显示的js端的组件的名称，这个要和js端注册的Component名称一一对应。

*／

@Override

protected String getMainComponentName() {

return "AwesomeProject";

}
}

MainActivity继承于ReactActivity，ReactActivity是rn中页面显示的入口，负责页面的显示，下面就进入源码看它怎么实现的：
进入ReactActivity的onCreate中发现ReactActivity只是一个空壳子，所有的逻辑都交给ReactActivityDelegate类实现，这是典型的代理模式，这样做的好处：1、实现和接口分开；2、可以在FragmentActivity也同样可以使用，不用维护两套逻辑。
接着查看ReactActivityDelegate的onCreate方法，这个函数中最重要的逻辑就是loadApp方法：

protected void loadApp(String appKey) {
   ...
    mReactRootView = createRootView();
    mReactRootView.startReactApplication(
      getReactNativeHost().getReactInstanceManager(),
      appKey,
      getLaunchOptions());
    getPlainActivity().setContentView(mReactRootView);
  }

这个函数主要实现两个功能：
1、创建ReactRootView，并将这个view设置为activity的根view。ReactRootView继承FrameLayout，它主要负责native端事件（键盘事件、touch事件、页面大小变化等）的监听并将结果传递给js端以及负责页面元素的重新绘制。
2、调用ReactRootView的startReactApplication方来，来启动整个rn流。
startReactApplication函数：

 public void startReactApplication(
      ReactInstanceManager reactInstanceManager,
      String moduleName,
      @Nullable Bundle launchOptions) {
    ...
    ／／rn的上下文没有创建
    if (!mReactInstanceManager.hasStartedCreatingInitialContext()) {
    ／／创建rn的上下文ReactContext对象
      mReactInstanceManager.createReactContextInBackground();
    }
    if (mWasMeasured) {
      attachToReactInstanceManager();
    }
  }

由于是第一次调用，hasStartedCreatingInitialContext函数返回false，此时，进入mReactInstanceManager.createReactContextInBackground()函数，在分析这个函数之前，先介绍一下两个类：
ReactInstanceManager，rn的java端的控制器，它主要的功能是创建和管理CatalystInstance实例并和ReactActivity的生命周期保持一致。
CatalystInstance：jsc桥梁接口类，为java和js相互通信提供环境。
进入createReactContextInBackground函数，发现函数最后会走到recreateReactContextInBackgroundInner（）函数。

recreateReactContextInBackgroundInner函数：

private void recreateReactContextInBackgroundInner() {
    ...
     ／／是否使用开发者模式，默认情况下是true
    if (mUseDeveloperSupport && mJSMainModuleName != null) {
      final DeveloperSettings devSettings = mDevSupportManager.getDevSettings();

      // 本地bundle文件是最新的并且不开启远程js调试，用本地的bundle文件
      if (mDevSupportManager.hasUpToDateJSBundleInCache() &&
          !devSettings.isRemoteJSDebugEnabled()) {
        onJSBundleLoadedFromServer();
      } else if (mBundleLoader == null) {
        mDevSupportManager.handleReloadJS();
      } else {
      //调用okHttp下载bundle文件
        mDevSupportManager.isPackagerRunning(
            new DevServerHelper.PackagerStatusCallback() {
              @Override
              public void onPackagerStatusFetched(final boolean packagerIsRunning) {
                UiThreadUtil.runOnUiThread(
                    new Runnable() {
                      @Override
                      public void run() {
                        if (packagerIsRunning) {
                          mDevSupportManager.handleReloadJS();
                        } else {
                        
                          devSettings.setRemoteJSDebugEnabled(false);
                          recreateReactContextInBackgroundFromBundleLoader();
                        }
                      }
                    });
              }
            });
      }
      return;
    }

    recreateReactContextInBackgroundFromBundleLoader();
  }

recreateReactContextInBackgroundFromBundleLoader函数：

private void recreateReactContextInBackgroundFromBundleLoader() {
    recreateReactContextInBackground(
        new JSCJavaScriptExecutor.Factory(mJSCConfig.getConfigMap()),
        mBundleLoader);
  }

JSCJavaScriptExecutor：是JavaScriptExecutor的子类，是js执行器。
JSCJavaScriptExecutor.Factory：工厂模式，产生JSCJavaScriptExecutor实例。

public class JSCJavaScriptExecutor extends JavaScriptExecutor {
  public static class Factory implements JavaScriptExecutor.Factory {
    private ReadableNativeArray mJSCConfig;

    public Factory(WritableNativeMap jscConfig) {
      array.pushMap(jscConfig);
      mJSCConfig = array;
    }

   ／／创建JSCJavaScriptExecutor实例
    @Override
    public JavaScriptExecutor create() throws Exception {
      return new JSCJavaScriptExecutor(mJSCConfig);
    }
  }

  public JSCJavaScriptExecutor(ReadableNativeArray jscConfig) {
    super(initHybrid(jscConfig));
  }

  private native static HybridData initHybrid(ReadableNativeArray jscConfig);
}

JSCJavaScriptExecutor的构造函数中调用initHybridn函数，这个函数在rn中反复的出现，它的主要作用是找到于java相对应的c++类并调用其构造方法生成对象，把new出来对象的地址放到java的HybridData对象中。其中与JSCJavaScriptExecutor对应的C++类是JSCJavaScriptExecutorHolder（后面再介绍）。接着往下看，发现函数最后会调用ReactContextInitAsyncTask的doInBackground方法：

@Override
    protected Result doInBackground(ReactContextInitParams... params) {
      ...
      try {
        ／／创建JavaScriptExecutor实例
        JavaScriptExecutor jsExecutor = params[0].getJsExecutorFactory().create();
        return Result.of(createReactContext(jsExecutor, params[0].getJsBundleLoader()));
      } catch (Exception e) {
        return Result.of(e);
      }
    }

createReactContext函数比较长，此处选择比较重要的功能进行分析，剩下的可以自自行阅读，在分析代码之前，先看几个重要的类：
JSBundleLoader：bundle.js文件加载器，在rn中有三种加载方式：1、加载本地文件；2、加载网络文件，并将文件缓存；3、加载网络文件，用于debug调试。
ModuleSpec：NativeModule的包装类，主要是为了实现module的懒加载，由于rn中native module比较多，为了节省成本，rn中采用时懒加载的策略，只有相应的module使用时才进行创建。
JavaScriptModule接口类，用于java调用js的接口，在rn中没有实现类，具体如何使用后面再介绍。
JavaScriptModuleRegistry：JavaScriptModule的注册表。
NativeModuleRegistry:NativeModule的注册表，用于管理NativeModule列表。
NativeModule:java暴露给js调用的api接口，如果想创建自己的module，需要继承这个接口。
ReactPackage:组件配置接口类，通过createNativeModules、createJSModules和createViewManagers等API去创建本地模块，JS模块及视图组件等。ReactPackage分为rn核心的CoreModulesPackage和业务方可选的基础MainReactPackage类，其中CoreModulesPackage封装了大部分通信功能。
createReactContext函数：

  private ReactApplicationContext createReactContext(
      JavaScriptExecutor jsExecutor,
      JSBundleLoader jsBundleLoader) {
    ...
    //初始化ReactApplicationContext实例
    final ReactApplicationContext reactContext = new ReactApplicationContext(mApplicationContext);
   try {
      CoreModulesPackage coreModulesPackage =
        new CoreModulesPackage(
          this,
          mBackBtnHandler,
          mUIImplementationProvider,
          mLazyViewManagersEnabled);
      //将ReactPackage配置的modeles添加到nativeRegistryBuilder和jsModulesBuilder中
      processPackage(
        coreModulesPackage,
        reactContext,
        moduleSpecs,
        reactModuleInfoMap,
        jsModulesBuilder);
    } finally {
      ...
    }
    ...
    
    CatalystInstanceImpl.Builder catalystInstanceBuilder = new CatalystInstanceImpl.Builder()
     .setReactQueueConfigurationSpec(ReactQueueConfigurationSpec.createDefault())
        .setJSExecutor(jsExecutor)
        .setRegistry(nativeModuleRegistry)
        .setJSModuleRegistry(jsModulesBuilder.build())
        .setJSBundleLoader(jsBundleLoader)
        .setNativeModuleCallExceptionHandler(exceptionHandler);

    final CatalystInstance catalystInstance;
    try {
      catalystInstance = catalystInstanceBuilder.build();
    } finally {
      ...
    }

    reactContext.initializeWithInstance(catalystInstance);
    catalystInstance.runJSBundle();

    return reactContext;
  }

这个函数主要有三个功能：
1、根据ReactPackage生成js module和native module的注册表
2、创建CatalystInstance实例
3、加载bundle文件

生成注册表代码比较简单，这里就不做介绍了，下面我们看CatalystInstanceImpl的构造函数：

  private CatalystInstanceImpl(
      final ReactQueueConfigurationSpec ReactQueueConfigurationSpec,
      final JavaScriptExecutor jsExecutor,
      final NativeModuleRegistry registry,
      final JavaScriptModuleRegistry jsModuleRegistry,
      final JSBundleLoader jsBundleLoader,
      NativeModuleCallExceptionHandler nativeModuleCallExceptionHandler) {
    ...
    //native函数，主要是为了将创建C++实例并将指针地址保存到java中
    
    mHybridData = initHybrid();
    
    mReactQueueConfiguration = ReactQueueConfigurationImpl.create(
        ReactQueueConfigurationSpec,
        new NativeExceptionHandler());
    mBridgeIdleListeners = new CopyOnWriteArrayList<>();
    mJavaRegistry = registry;
    mJSModuleRegistry = jsModuleRegistry;
    mJSBundleLoader = jsBundleLoader;
    mNativeModuleCallExceptionHandler = nativeModuleCallExceptionHandler;
    mTraceListener = new JSProfilerTraceListener(this);

    initializeBridge(
      new BridgeCallback(this),
      jsExecutor,
      mReactQueueConfiguration.getJSQueueThread(),
      mReactQueueConfiguration.getNativeModulesQueueThread(),
      mJavaRegistry.getModuleRegistryHolder(this));
    mMainExecutorToken = getMainExecutorToken();
  }

构造函数有有两个重要的参数：
1、ReactQueueConfigurationSpec：用于配置消息线程，在rn中有三个消息线程：UI线程、JS线程、Native线程，其中native调用js的代码会JS线程运行，JS调用native的代码会在Native线程中执行。

2、ModuleRegistryHolder：Native Module的封装类，将java层Native Module信息传递给c++层。

public class ModuleRegistryHolder {
  private final HybridData mHybridData;
  private static native HybridData initHybrid(
    CatalystInstanceImpl catalystInstanceImpl,
    Collection javaModules,
    Collection cxxModules);

  public ModuleRegistryHolder(CatalystInstanceImpl catalystInstanceImpl,
                              Collection javaModules,
                              Collection cxxModules) {
    mHybridData = initHybrid(catalystInstanceImpl, javaModules, cxxModules);
  }
}

上面已经说过initHybrid的工作，此处会在创建C++中ModuleRegistryHolder对象。接着调用initializeBridge函数来初始化，initializeBridge是native方法：

CatalystInstanceImpl.cpp

void CatalystInstanceImpl::initializeBridge(
    jni::alias_ref callback,
    // This executor is actually a factory holder.
    JavaScriptExecutorHolder* jseh,
    jni::alias_ref jsQueue,
    jni::alias_ref moduleQueue,
    ModuleRegistryHolder* mrh) {

  instance_->initializeBridge(folly::make_unique(callback),
                              jseh->getExecutorFactory(),
                              folly::make_unique(jsQueue),
                              folly::make_unique(moduleQueue),
                              mrh->getModuleRegistry());
}

JavaScriptExecutorHolder:对应于java层中的JavaScriptExecutor的C++对象，getExecutorFactory（）返回JSCExecutorFactory对象，用于生成js解析器。
ModuleRegistryHolder：java中native module的包装类，其构造函数：

ModuleRegistryHolder.cpp
ModuleRegistryHolder::ModuleRegistryHolder(
    CatalystInstanceImpl* catalystInstanceImpl,
    jni::alias_ref::javaobject> javaModules,
    jni::alias_ref::javaobject> cxxModules) {
  std::vector> modules;
  std::weak_ptr winstance(catalystInstanceImpl->getInstance());
  for (const auto& jm : *javaModules) {
    modules.emplace_back(folly::make_unique(jm));
  }
  for (const auto& cm : *cxxModules) {
    modules.emplace_back(
      folly::make_unique(winstance, std::move(cthis(cm)->getModule())));
  }

  registry_ = std::make_shared(std::move(modules));
}
}

将java层的对象分装成JavaNativeModule和CxxNativeModule对象，并将生成的对象注册到ModuleRegistry对象中，ModuleRegistry和上面提高的NativeModuleRegistry功能相似，是C++端module的注册表。继续往下走，会调用Instance的initializeBridge函数：

Instance.cpp
void Instance::initializeBridge(
    std::unique_ptr callback,
    std::shared_ptr jsef,
    std::shared_ptr jsQueue,
    std::unique_ptr nativeQueue,
    std::shared_ptr moduleRegistry) {
  callback_ = std::move(callback);

  jsQueue->runOnQueueSync(
    [this, &jsef, moduleRegistry, jsQueue,
     nativeQueue=folly::makeMoveWrapper(std::move(nativeQueue))] () mutable {
      nativeToJsBridge_ = folly::make_unique(
          jsef.get(), moduleRegistry, jsQueue, nativeQueue.move(), callback_);

      std::lock_guard lock(m_syncMutex);
      m_syncReady = true;
      m_syncCV.notify_all();
    });
}

MessageQueueThread对应于java层MessageQueueThread，进行线程转换变成js thread，在这个函数会调用NativeToJsBridge的构造函数，NativeToJsBridge：Native调用JS的桥梁。

NativeToJsBridge.cpp

NativeToJsBridge::NativeToJsBridge(
    JSExecutorFactory* jsExecutorFactory,
    std::shared_ptr registry,
    std::shared_ptr jsQueue,
    std::unique_ptr nativeQueue,
    std::shared_ptr callback)
    : m_destroyed(std::make_shared(false))
    , m_mainExecutorToken(callback->createExecutorToken())
    , m_delegate(
      std::make_shared(
        this, registry, std::move(nativeQueue), callback)) {
  std::unique_ptr

  mainExecutor =
    jsExecutorFactory->createJSExecutor(m_delegate, jsQueue);
  
  m_mainExecutor = mainExecutor.get();
  registerExecutor(m_mainExecutorToken, std::move(mainExecutor), jsQueue);
}

m_delegate是JsToNativeBridge，用于JS调用Native函数，和NativeToJsBridge一起作为连接java和js通信的桥梁。这个构造函数的主要是创建js的执行器，这里的mainExecutor对象对应于JSCExecutor对象，JSCExecutor构造函数中对js的执行环境进行初始化，并且向JavaScriptCore中注册了几个c++的方法供js端调用，这里就不做介绍了，有兴趣的可以自己阅读代码。到这里initializeBridge整个函数就全部介绍完毕了。
下面回到ReactInstanceManager中的createReactContext函数中，接着调用CatalystInstanceImpl的runJSBundle方法，接着看runJSBundle函数，发现runJSBundle函数会调用JSBundleLoader的loadScript方法，前面我们介绍过JSBundleLoader有三种方式，我们假设使用的时文件加载的方式，跟着函数一步步走下去，最后会走到CatalystInstanceImpl的loadScriptFromFile函数，这个又是一个native方法，查看CatalystInstanceImpl.cpp的代码，最后进入NativeToJsBridge.cpp中loadApplication方法:

NativeToJsBridge.cpp

void NativeToJsBridge::loadApplication(
    std::unique_ptr unbundle,
    std::unique_ptr startupScript,
    std::string startupScriptSourceURL) {
    //进行线程转换，把函数抛到js thread的队列中
  runOnExecutorQueue(
      m_mainExecutorToken,
      [unbundleWrap=folly::makeMoveWrapper(std::move(unbundle)),
       startupScript=folly::makeMoveWrapper(std::move(startupScript)),
       startupScriptSourceURL=std::move(startupScriptSourceURL)]
        (JSExecutor* executor) mutable {

    auto unbundle = unbundleWrap.move();
    if (unbundle) {
      executor->setJSModulesUnbundle(std::move(unbundle));
    }
    executor->loadApplicationScript(std::move(*startupScript),
                                    std::move(startupScriptSourceURL));
  });
}

JSCExecutor.cpp中的loadApplicationScript函数：

JSCExecutor.cpp

void JSCExecutor::loadApplicationScript(std::unique_ptr script, std::string sourceURL) {
／／JavaScriptCore函数，执行js代码
evaluateScript(m_context, jsScript, jsSourceURL);

  if (m_delegate) {
    bindBridge();
    flush();
  }
}

m_delegate为上面介绍的JsToNativeBridge对象，这里不为null，后面就会执行bindBridge函数：

JSCExecutor.cpp
void JSCExecutor::bindBridge() throw(JSException) {
  
  auto global = Object::getGlobalObject(m_context);
  auto batchedBridgeValue = global.getProperty("__fbBatchedBridge");
  if (batchedBridgeValue.isUndefined()) {
    throwJSExecutionException("Could not get BatchedBridge, make sure your bundle is packaged correctly");
  }

  auto batchedBridge = batchedBridgeValue.asObject();
  m_callFunctionReturnFlushedQueueJS = batchedBridge.getProperty("callFunctionReturnFlushedQueue").asObject();
  m_invokeCallbackAndReturnFlushedQueueJS = batchedBridge.getProperty("invokeCallbackAndReturnFlushedQueue").asObject();
  m_flushedQueueJS = batchedBridge.getProperty("flushedQueue").asObject();
  m_callFunctionReturnResultAndFlushedQueueJS = batchedBridge.getProperty("callFunctionReturnResultAndFlushedQueue").asObject();
}

这个函数主要实现下面几个功能：
1、从js执行环境中取出全局变量__fbBatchedBridge放到global变量中。
2、将global中某些特定的函数对象映射到C++对象中，这样我们就可以通过C++对象调用js的代码，假设我们想要调用js端__fbBatchedBridge的flushQueue方法，在C++中就可以使用m_flushedQueueJS->callAsFunction（）就可以实现，那么__fbBatchedBridge在js端到底是个什么东西那？
查看js代码，在BatchBridge.js中找到了__fbBatchedBridge的定义

const MessageQueue = require('MessageQueue');
const BatchedBridge = new MessageQueue();
...
Object.defineProperty(global, '__fbBatchedBridge', {
  configurable: true,
  value: BatchedBridge,
});

从上面可以看出__fbBatchedBridge就是MessageQueue对象，后面再介绍MessageQueue。
到这里整个rn的初始化和bundle加载就基本上介绍完毕了，下面介绍一下java和js之间如何通信的。

二、java和js之间通信的过程

2.1 java调用js过程

举一个列子：假设我们想要执行js端AppRegistry.runApplication()函数，我们应该怎么办那？

首先要拿到ReactContext实例，然后调用getJSModule方法拿到AppRegistry实例，最后调用runApplication方法就可以了，很简单吧，那么看代码里面如何实现的？
ReactContext.getJSModule函数：

public  T getJSModule(Class jsInterface) {
    ...
    return mCatalystInstance.getJSModule(jsInterface);
  }

ReactContext中的getJSModule很简单，直接调用CatalystInstanceImpl的JavaScriptModule方法：

 @Override
  public  T getJSModule(ExecutorToken executorToken, Class jsInterface) {
    return Assertions.assertNotNull(mJSModuleRegistry)
        .getJavaScriptModule(this, executorToken, jsInterface);
  }

调用JavaScriptModuleRegistry的getJavaScriptModule方法，
JavaScriptModuleRegistry前面提过，是管理js module的注册表，接着看一下内部实现：

JavaScriptModuleRegistry.java

  public synchronized  T getJavaScriptModule(
    CatalystInstance instance,
    ExecutorToken executorToken,
    Class moduleInterface) {
    HashMap, JavaScriptModule> instancesForContext =
        mModuleInstances.get(executorToken);
    if (instancesForContext == null) {
      instancesForContext = new HashMap<>();
      mModuleInstances.put(executorToken, instancesForContext);
    }

    JavaScriptModule module = instancesForContext.get(moduleInterface);
    if (module != null) {
      return (T) module;
    }

    JavaScriptModuleRegistration registration =
        Assertions.assertNotNull(
            mModuleRegistrations.get(moduleInterface),
            "JS module " + moduleInterface.getSimpleName() + " hasn't been registered!");
    JavaScriptModule interfaceProxy = (JavaScriptModule) Proxy.newProxyInstance(
        moduleInterface.getClassLoader(),
        new Class[]{moduleInterface},
        new JavaScriptModuleInvocationHandler(executorToken, instance, registration));
    instancesForContext.put(moduleInterface, interfaceProxy);
    return (T) interfaceProxy;
  }

这个函数的流程比较简单：首先判断js module是否已经生成了，如果已经生成了就直接返回内存中的对象，假设我们是第一次调用，那么就会执行后面的方法，使用java的动态代理来生成js module的实例，关于动态代理，我们知道实际的处理逻辑都在InvocationHandler中invoke方法中执行，直接看InvocationHandler的实现类JavaScriptModuleInvocationHandler中的invoke函数：

@Override
    public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args) throws Throwable {
      ExecutorToken executorToken = mExecutorToken.get();
      ...
      NativeArray jsArgs = args != null ? Arguments.fromJavaArgs(args) : new WritableNativeArray();
      mCatalystInstance.callFunction(
        executorToken,
        mModuleRegistration.getName(),
        method.getName(),
        jsArgs
      );
      return null;
    }

invoke方法比较简单，直接调用mCatalystInstance的callFunction（...）方法，看着这里就比较明白了，调用AppRegistery的runApplictaion(args)方法实际上是调用CatalystInstance的callFuction(,"AppRegistry","runApplictaion",args)方法。其中NativeArray类，用于rn中java端和C++端进行数据传递的数据结构，主要目的是节省内存，便于管理，有兴趣的可以自行阅读源码。
这时大概java层流程就大概清楚了，我们看C++层，一步步往下走，最后会到NativeToJsBridge中的callFunction函数：

NativeToJsBridge.cpp
void NativeToJsBridge::callFunction(
    ExecutorToken executorToken,
    std::string&& module,
    std::string&& method,
    folly::dynamic&& arguments) {

  runOnExecutorQueue(executorToken, [module = std::move(module), method = std::move(method), arguments = std::move(arguments), tracingName = std::move(tracingName), systraceCookie] (JSExecutor* executor) {
    executor->callFunction(module, method, arguments);
  });
}

runOnExecutorQueue的函数讲过，不清楚请往前看，后面会执行JSExecutor的callFunction函数，其中module是想要调用js端对象的名称，method是js对象中的方法名称，arguments是方法参数。JSCExecutor::callFunction函数：

JSCExecutor.cpp

void JSCExecutor::callFunction(const std::string& moduleId, const std::string& methodId, const folly::dynamic& arguments) {
 
  auto result = [&] {
    try {
      return m_callFunctionReturnFlushedQueueJS->callAsFunction({
        Value(m_context, String::createExpectingAscii(m_context, moduleId)),
        Value(m_context, String::createExpectingAscii(m_context, methodId)),
        Value::fromDynamic(m_context, std::move(arguments))
      });
    } catch (...) {
      
    }
  }();

  callNativeModules(std::move(result));
}

m_callFunctionReturnFlushedQueueJS是js全局对象_fbBatchedBridge中的callFunctionReturnFlushedQueue对象，对它调用callAsFunction方法来，相当于执行_fbBatchedBridge.callFunctionReturnFlushedQueue函数。callNativeModules函数主要的功能是将js的执行结果返回给native函数，这里需要注意的是这个过程不是线性的，前面说过_fbBatchedBridge是MessageQueue对象，查看MessageQueue.js中的callFunctionReturnFlushedQueue函数：

MessageQueue.js
MessageQueue
callFunctionReturnFlushedQueue(module: string, method: string, args: Array) {
／／es6的新特性箭头函数
    guard(() => {
      this.__callFunction(module, method, args);
      this.__callImmediates();
    });
    return this.flushedQueue();
  }

MessageQueued的__callFunction函数：

__callFunction(module: string, method: string, args: Array) {
    ...
    const moduleMethods = this._callableModules[module];
    ...
    const result = moduleMethods[method].apply(moduleMethods, args);
    ...
    return result;
  }

MessageQueue内部有一个js模块的配置数组，每个js模块会在js加载时将自己注册到MessageQueue配置表_callableModules中,它以moduleId为key，module对象为value进行存储，此时这个函数的功能就是调用js中module模块中method方法。
到这里还有个问题：这个配置表是如何生成的？这里还是以AppRegistry为例，查看AppRegistry.js的代码：

BatchedBridge.registerCallableModule(
  'AppRegistry',
  AppRegistry
);

在加载AppRegistry.js时会调用BatchedBridge.registerCallableModule方法，前面我们讲过BatchedBridge对象就是MessageQueue对象，会调用MessageQueue.registerCallableModule函数：

registerCallableModule(name: string, module: Object) {
    this._callableModules[name] = module;
  }

js端配置表如何生成到这里也就结束了，总结来说，就是js文件加载时每个模块会将通过key和value的形式注册到MessageQueue中，工java端调用。在java调用接口时需要注意的时模块名称必须和js注册的名称完全一样，否则就会找不到这个module，执行不成功。到这里整个java调用js的过程就就结束了。接着介绍js到native的调用过程。

2.2 js调用native过程

还是一个例子来介绍这一过程，在Android中有个常用的控件Toast，那么js中如何调用native的Toast那？在rn中对这个过程进行了封装，我们想显示hello world，在js中只需要调用ToastAndroid.show('hello world', ToastAndroid.SHORT);就可以了，那么它是如何实现的那？查看ToastAndroid.js的代码：

ar RCTToastAndroid = require('NativeModules').ToastAndroid;
var ToastAndroid = {
  SHORT: RCTToastAndroid.SHORT,
  LONG: RCTToastAndroid.LONG,
  TOP: RCTToastAndroid.TOP,
  BOTTOM: RCTToastAndroid.BOTTOM,
  CENTER: RCTToastAndroid.CENTER,

  show: function (
    message: string,
    duration: number
  ): void {
    RCTToastAndroid.show(message, duration);
  },

  showWithGravity: function (
    message: string,
    duration: number,
    gravity: number,
  ): void {
    RCTToastAndroid.showWithGravity(message, duration, gravity);
  },
};

module.exports = ToastAndroid;

调用ToastAndroid的show函数就会RCTToastAndroid中的show函数，RCTToastAndroid是NativeModules.js中NativeModules对象，查看NativeModules.js的代码NativeModules是一个空的hashmap对象，key为moduleName的名称，value为module的对象，下面看一下NativeModules是如何生成的：

NativeModules.js
if (global.nativeModuleProxy) {
  NativeModules = global.nativeModuleProxy;
} else {
  const bridgeConfig = global.__fbBatchedBridgeConfig;

  (bridgeConfig.remoteModuleConfig || []).forEach((config: ModuleConfig, moduleID: number) => {
    const info = genModule(config, moduleID);
    if (!info) {
      return;
    }

    if (info.module) {
      NativeModules[info.name] = info.module;
    } else {
      defineLazyObjectProperty(NativeModules, info.name, {
        get: () => loadModule(info.name, moduleID)
      });
    }
  });
}

上面解析过BatchBridge.js，里面对全局的global对象进行赋值为MessageQueue，查看MessageQueue是否nativeModuleProxy对象，发现整个js中没有找到nativeModuleProxy，但是有一点我们需要注意的是我们在JSCExecutor注册了很多C++的函数供js端调用，global中函数对象包含JSCExecutor注册的C++中的函数，在JSCExecutor.cpp中nativeModuleProxy对应这个C++端的getNativeModule函数，查看getNativeModule函数：

JSCExecutor.cpp
JSValueRef JSCExecutor::getNativeModule(JSObjectRef object, JSStringRef propertyName) {
  ...
  return m_nativeModules.getModule(m_context, propertyName);
}

m_nativeModules是SCJNativeModules类对象，getModule函数：

SCJNativeModules
JSValueRef JSCNativeModules::getModule(JSContextRef context, JSStringRef jsName) {
  std::string moduleName = String::ref(context, jsName).str();

／／缓存中是否存在，如果存在直接返回缓存的配置表
  const auto it = m_objects.find(moduleName);
  if (it != m_objects.end()) {
    return static_cast(it->second);
  }

／／如果缓存中没有则生成
  auto module = createModule(moduleName, context);
  if (!module.hasValue()) {
    return Value::makeUndefined(context);
  }

 ...
  return static_cast(result->second);
}

createModule函数：

JSCNativeModules.cpp
folly::Optional JSCNativeModules::createModule(const std::string& name, JSContextRef context) {
／／没有产生过native配置表
  if (!m_genNativeModuleJS) {
    auto global = Object::getGlobalObject(context);
    获取js全局对象中__fbGenNativeModule属性
    m_genNativeModuleJS = global.getProperty("__fbGenNativeModule").asObject();
    m_genNativeModuleJS->makeProtected();
    ／／通过C++中NativeModule包装类调用java端的代码，生成native module实例，前面已经说过，native module是采用懒惰加载的方式加载的，在这块可以体会到
    m_moduleRegistry->moduleNames();
  }

 ／／生成配置表，这个配置表中有三类信息：常量，函数和函数类型
  auto result = m_moduleRegistry->getConfig(name);
  if (!result.hasValue()) {
    return nullptr;
  }

 ／／调用js中的__fbGenNativeModule函数将生成的配置表中的函数信息传递到js中
  Value moduleInfo = m_genNativeModuleJS->callAsFunction({
    Value::fromDynamic(context, result->config),
    Value::makeNumber(context, result->index)
  });
  return moduleInfo.asObject().getProperty("module").asObject();
}


生成配置表的函数比较简单，这里不做分析，感兴趣的同学可以自行阅读代码，生成配置结构大致如下：
 生成的配置表的格式大概是：


{ 'module名称', ,{ '常量key':'常量value'} { 'show', 'showWithGravity' },
 }
 后面会回调给global对象的__fbGenNativeModule方法，生成NativeModules列表，这里就不做介绍，解感兴趣的可以自行阅读源码，RCTToastAndroid.show(message, duration);最后实际上会变成MessageQueue.enqueueNativeCall(1,"show",{"hello world",0},null,null)函数;
 MessageQueue.js中的enqueueNativeCall函数：


MessageQueue.js
enqueueNativeCall(moduleID: number, methodID: number, params: Array < any > , onFail: ? Function, onSucc : ? Function) {
  ...
  //判断是否可以调用native的方法，当两个相继调用的函数超过MIN_TIME_BETWEEN_FLUSHES_MSs才会调用nativeFlushQueueImmediate方法
  const now = new Date().getTime();
  if (global.nativeFlushQueueImmediate &&
    now - this._lastFlush >= MIN_TIME_BETWEEN_FLUSHES_MS) {
    global.nativeFlushQueueImmediate(this._queue);
    this._queue = [
      [],
      [],
      [], this._callID
    ];
    this._lastFlush = now;
  }
  ...
}



nativeFlushQueueImmediate是C++注册的本地函数，对应于JSCExecutor::nativeFlushQueueImmediate函数，一步步往下走下去最后会执行java端JavaModuleWrapper类中的invoke方法：


JavaModuleWrapper.java
@DoNotStrip
  public void invoke(ExecutorToken token, int methodId, ReadableNativeArray parameters) {
    
    mMethods.get(methodId).invoke(mCatalystInstance, token, parameters);
  }



mMethods：native module中包含的的函数；
 methodId：js端要执行的函数名称；
 parameters：js端传递过来的参数；
 这个方法最后会调用ToastModule的show方法，整个js调用native流程到这里就介绍完毕了。
























你可能感兴趣的:(ReactNative Android源码分析)






    

  • reactnative 获取定位_React-native实现定位的功能
weixin_39644915
reactnative获取定位

    1、在React-native中实现定位的功能的几种方式。(1).使用rn中的自带的Geolocation实现定位。(2).用第三放库react-native-location实现定位。2.用rn中自带的Geolocation实现定位的详细步骤：(1).如果是android进行定位手下是需要权限的通过以下代码设置权限：(2).直接通过navigator.geolocation来进行定位，示例代码如
    

    • 

  • 基于react native的锚点
miao_zz
Reactreact-nativereactnativeandroidreact.js

    基于reactnative的锚点效果示例图示例代码效果示例图示例代码/*eslint-disablereact-native/no-inline-styles*/importReact,{useEffect,useRef,useState}from'react';import{Image,ImageBackground,ScrollView,StyleSheet,Text,TouchableOpa
    

    • 

  • cross-plateform 跨平台应用程序-08-Ionic 介绍
老马啸西风
java

    跨平台系列cross-plateform跨平台应用程序-01-概览cross-plateform跨平台应用程序-02-有哪些主流技术栈？cross-plateform跨平台应用程序-03-如果只选择一个框架，应该选择哪一个?cross-plateform跨平台应用程序-04-ReactNative介绍cross-plateform跨平台应用程序-05-Flutter介绍cross-platefor
    

    • 

  • cross-plateform 跨平台应用程序-09-phonegap/Apache Cordova 介绍
老马啸西风
java

    跨平台系列cross-plateform跨平台应用程序-01-概览cross-plateform跨平台应用程序-02-有哪些主流技术栈？cross-plateform跨平台应用程序-03-如果只选择一个框架，应该选择哪一个?cross-plateform跨平台应用程序-04-ReactNative介绍cross-plateform跨平台应用程序-05-Flutter介绍cross-platefor
    

    • 

  • cross-plateform 跨平台应用程序-10-naitvescript 介绍
老马啸西风
java

    跨平台系列cross-plateform跨平台应用程序-01-概览cross-plateform跨平台应用程序-02-有哪些主流技术栈？cross-plateform跨平台应用程序-03-如果只选择一个框架，应该选择哪一个?cross-plateform跨平台应用程序-04-ReactNative介绍cross-plateform跨平台应用程序-05-Flutter介绍cross-platefor
    

    • 

  • cross-plateform 跨平台应用程序-02-有哪些主流技术栈？
老马啸西风
java

    跨平台系列cross-plateform跨平台应用程序-01-概览cross-plateform跨平台应用程序-02-有哪些主流技术栈？cross-plateform跨平台应用程序-03-如果只选择一个框架，应该选择哪一个?cross-plateform跨平台应用程序-04-ReactNative介绍cross-plateform跨平台应用程序-05-Flutter介绍cross-platefor
    

    • 

  • cross-plateform 跨平台应用程序-01-概览
老马啸西风
java

    跨平台系列cross-plateform跨平台应用程序-01-概览cross-plateform跨平台应用程序-02-有哪些主流技术栈？cross-plateform跨平台应用程序-03-如果只选择一个框架，应该选择哪一个?cross-plateform跨平台应用程序-04-ReactNative介绍cross-plateform跨平台应用程序-05-Flutter介绍cross-platefor
    

    • 

  • cross-plateform 跨平台应用程序-05-Flutter 介绍
老马啸西风
java

    跨平台系列cross-plateform跨平台应用程序-01-概览cross-plateform跨平台应用程序-02-有哪些主流技术栈？cross-plateform跨平台应用程序-03-如果只选择一个框架，应该选择哪一个?cross-plateform跨平台应用程序-04-ReactNative介绍cross-plateform跨平台应用程序-05-Flutter介绍cross-platefor
    

    • 

  • 【App】React Native
卿卿qing
reactnativereact.jsjavascript

    ReactNative的优势：开发体验好用统一的代码规范开发移动端程序，不用关注移动端的差异.开发成本低开发一次，可以生成Android和IOS俩个系统上的App学习成本低只要掌握JavaScript和React就可以进行移动端开发ReactNative的不足：不成熟性能差整体性能仍不如原生兼容性差设计底层的功能，需要针对Android和IOS双端单独开发ReactNative的核心组件核心组件R
    

    • 

  • 在ReactNative中使用CodePush 热更新
执念1012
ReactNativereactnativereact.jsjavascript

    ReactNative热更新使用react-native-update，这个库是在RN中文网上推广的。鉴于测试、使用改库，我们还可以自建codepush服务，不过这个后面会详细讲到，官网地址。基础环境1.全局安装update-cli先全局安装命令行工具，每台电脑只用装一次npmi-greact-native-update-cli2.项目初始化然后在项目目录中安装热更新模块0.71及以上版本使用最新
    

    • 

  • ReactNative SDK 库之 react-native-dev-sdk
执念1012
reactnativereact.jsjavascript

    react-native-dev-sdk封装大部业务中常用组件，方法、方便项目中适用安装依赖使用，安装需要将dev嵌入项目.npmi@react-native-async-storage/async-storage@react-navigation/nativeaxiosreact-native-root-toast@react-navigation/native-stack@react-navi
    

    • 

  • React Native通讯原理
zbl_zbl
androidReactNativ

    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    

    • 

  • 一个Android开发者的React Native之路
青灯明月
RNAndroidReactandroidreactnative

    这是一个Android开发者一个月以来学习ReactNative的一些经验和感悟，如有错漏之处敬请指出~1.什么是ReactNativeReactNative是Facebook在2015年开源的一个项目，用官方的话来解释就是：ReactNativeletsyoubuildmobileappsusingonlyJavaScriptReactNative让你只用JavaScript就能编写移动端App
    

    • 

  • React Native新架构系列-C++实现跨平台Turbo Native Module
林克在思考
ReactNativereactnativec++react.js

    今天我们介绍在ReactNative新架构中如何C++代码实现一个跨平台的C++TurboNativeModule扩展API。阅读本文前建议阅读上一篇文章。本系列基于ReactNative0.73.4版本，从一名Android开发者的视角进行介绍。本系列介绍的内容默认读者对ReactNative有一定的了解，对基础的开发内容不再赘述。在上一篇文章中ReactNative新架构系列-自定义Turbo
    

    • 

  • ReactNative 常用开源组件
2401_84875852
程序员reactnative开源react.js

    WebStormReactNative的代码模板插件,包括:1.组件名称2.Api名称3.所有StyleSheets属性4.组件属性https://github.com/virtoolswebplayer/ReactNative-LiveTemplateReact-native调用cordova插件https://github.com/axemclion/react-native-cordova-
    

    • 

  • 高频面试题：ReactNative前端面试频率较高的面试题和答案（十六）
夲奋亻Jay
高频面试题react跨端reactnative前端面试

    ReactNative是一个由Facebook开发的框架，它允许使用React来开发原生移动应用。以下是一些在前端面试中可能会问到的关于ReactNative的高频面试题及答案：ReactNative是什么？答案：ReactNative是一个基于React构建的框架，允许使用JavaScript和React的编程方式来开发原生移动应用。ReactNative与React有什么不同？答案：React
    

    • 

  • 求教大佬们react native 如何实现fiexd固定列
小时候丶_2e0a

    上图是我用reactnative封装的一个table，但是固定列没有同步滚动fiexd的固定列，我的思路是将表格分为左右两个flatlist，分别放fiexd和非fiexd列，然后滚动右边的flatlist监听onScroll事件，并设置scrollEventThrottle频率次数，然后在onScroll的自定义方法里去同步更改左边的flatlist偏移。结果，数据量很少的时候还看不出什么，数据
    

    • 

  • React Native Date Picker 使用教程
喻季福

    ReactNativeDatePicker使用教程react-native-date-pickerReactNativeDatePickerisdatetimepickerforAndroidandiOS.Itincludesdate,timeanddatetimepickermodes.Thedatepickeriscustomizableandissupportingdifferentlang
    

    • 

  • react native和java_Expo和React Native有什么区别？
weixin_39860166
reactnative和java

    BrentVatne的答案很好，但我想补充一些细节.Expo扩展了ReactNative的API表面ReactNative没有提供开箱即用的所有JSAPI，只提供了大多数原始功能.ReactNative开发人员应该使用AndroidStudio/XCode链接其他本机库.Expo旨在增强RN并提供您最常见需求所需的所有JSAPI.它基本上是一组定义良好的原始库，已经为您打包在一个库中：ExpoKi
    

    • 

  • react native中ScrollView嵌套WebView导致的闪退（rn版本0.70.0）
诚实可靠王大锤
前端reactnativejavascript

    reactnative中ScrollView嵌套WebView导致的闪退（rn版本0.70.0）网上找了一圈，WebView的问题区也看了一圈，没有可以解决我的闪退的问题，重复进出页面后依然会闪退，最终解决方案1.在ScrollView中添加overScrollMode=“never”2.在退出页面时卸载包含WebView的组件，可以用公共变量进行控制，退出时卸载，进入后重新加载3.在webvie
    

    • 

  • 前端宝典二十七：React Native最佳实践实例推荐
桃子叔叔
大厂进阶前端深度解析系列reactnative前端react.js

    可供推荐的ReactNative实例1.Exponent介绍：一个用于快速构建ReactNative应用的平台，提供了很多实用的工具和服务，帮助开发者轻松地将应用部署到多个平台。亮点：简化了ReactNative应用的开发和部署流程，提供了强大的热重载功能，方便开发者实时查看代码更改的效果。2.Airbnb的AirbnbApp介绍：Airbnb使用ReactNative开发了他们的移动应用，为用户
    

    • 

  • Flutter 原理
AiFlutter
flutter

    一、简介与用于构建移动应用程序的其他大多数框架不同，Flutter是重写了一整套包括底层渲染逻辑和上层开发语言的完整解决方案。这样不仅可以保证视图渲染在Android和iOS上的高度一致性（即高保真），在代码执行效率和渲染性能上也可以媲美原生App的体验（即高性能）。这就是Flutter和其他跨平台方案的本质区别：ReactNative之类的框架，只是通过JavaScript虚拟机扩展调用系统组件
    

    • 

  • 推荐使用：react-qr-code - 灵活高效的React和React Native二维码组件
纪亚钧

    推荐使用：react-qr-code-灵活高效的React和ReactNative二维码组件react-qr-codeAQRcodegeneratorforReactandReactNative.项目地址:https://gitcode.com/gh_mirrors/re/react-qr-code1、项目介绍react-qr-code是一个专为React框架设计的二维码组件库，同时也支持Reac
    

    • 

  • React Native优质开源项目推荐与解析
concisedistinct
移动开发reactnativeReact移动开发iosAndroid

    目录2.ReactNative的优势2.1.跨平台开发2.2.热更新2.3.丰富的社区资源2.4.优秀的性能3.优质开源项目推荐3.1.ReactNavigation3.1.1项目简介3.1.2特点和优势3.1.3应用场景3.2.Redux3.2.1项目简介3.2.2特点和优势3.2.3应用场景3.3.ReactNativeElements3.3.1项目简介3.3.2特点和优势3.3.3应用场景3
    

    • 

  • 浅谈Vue和React对比
时倾௸
vue.jsreact.js

    这里就做几个简单的类比吧，当然没有好坏之分，只是使用场景不同相同点都有组件化思想都支持服务器端渲染都有VirtualDOM（虚拟dom）数据驱动视图都有支持native的方案：Vue的weex、React的Reactnative都有自己的构建工具：Vue的vue-cli、React的CreateReactApp区别数据变化的实现原理不同。react使用的是不可变数据，而Vue使用的是可变的数据组件
    

    • 

  • React-Native优质开源项目
换个网名有点难
reactnative

    ReactNative是一个由Facebook开发的开源框架，允许开发者使用JavaScript和React来构建原生移动应用。它允许开发者编写一次代码，然后可以在iOS和Android平台上运行，而无需为每个平台单独编写代码。以下是ReactNative的一些关键特点和优势：跨平台开发：使用ReactNative，开发者可以为iOS和Android创建应用，而不需要分别学习Swift或Java/
    

    • 

  • 推荐：React Native 邮件组件 —— react-native-mail
乌昱有Melanie

    推荐：ReactNative邮件组件——react-native-mailreact-native-mailAwrapperontopofMFMailComposeViewControllerfromiOSandMailIntentonandroid项目地址:https://gitcode.com/gh_mirrors/re/react-native-mail在移动应用开发中，集成发送邮件功能是一
    

    • 

  • EXPO 结合 Alova请求库 快速搭建ReactNative开发平台
番茄小酱001
ReactNativeAlovareactnativereact.jsjavascript

    alova是一个轻量级的请求策略库，目标是让接口的管理和使用变得非常简单。1、安装npminstallalova--save2、使用useRequest发送一个请求import{useRequest}from'alova'const{send:followAuthor}=useRequest((wtNo,status)=>follow({wtNo,status}),{immediate:false
    

    • 

  • 通过RN框架实现跳转到微信落地页
番茄小酱001
ReactNativereactnativereact.jsjavascript

    在使用Expo搭建的ReactNative应用中，要实现分享到微信后点击分享链接进入指定落地页，需要做如下几个步骤：1.**创建分享链接**：当用户点击分享按钮时，生成一个特定的分享链接，该链接应该包含信息用于标识用户点击的是哪个内容或页面。2.**设置落地页**：确保你有一个可以处理这个分享链接的落地页或路由。当用户点击链接时，应用能够识别并导航到相应的页面。3.**获取分享链接**：使用Exp
    

    • 

  • Android源码分析--启动时序图
linuxMinx
Android源码分析Android源码分析

    为什么Android系统启动比较慢Build的产物中最重要的是三个镜像文件，位于/out/target/product//目录下ramdisk.img:在启动时将被Linux内核挂载为只读分区，它包含了/init文件和一些配置文件。它用来挂载其他系统镜像并启动init进程。解析步骤：Init.c(system\core\init)Init.c{main(......init_parse_confi
    

    • 

  • PHP如何实现二维数组排序？
IT独行者
二维数组PHP排序　

    二维数组在PHP开发中经常遇到，但是他的排序就不如一维数组那样用内置函数来的方便了，（一维数组排序可以参考本站另一篇文章【PHP中数组排序函数详解汇总】）。二维数组的排序需要我们自己写函数处理了，这里UncleToo给大家分享一个PHP二维数组排序的函数：
代码：
functionarray_sort($arr,$keys,$type='asc'){
$keysvalue= $new_arr
    

    • 

  • 【Hadoop十七】HDFS HA配置
bit1129
hadoop

    基于Zookeeper的HDFS HA配置主要涉及两个文件,core-site和hdfs-site.xml。
 
测试环境有三台
hadoop.master
hadoop.slave1
hadoop.slave2
 
hadoop.master包含的组件NameNode, JournalNode, Zookeeper，DFSZKFailoverController
    

    • 

  • 由wsdl生成的java vo类不适合做普通java vo
darrenzhu
VOwsdlwebservicerpc

    开发java webservice项目时，如果我们通过SOAP协议来输入输出，我们会利用工具从wsdl文件生成webservice的client端类，但是这里面生成的java data model类却不适合做为项目中的普通java vo类来使用，当然有一中情况例外，如果这个自动生成的类里面的properties都是基本数据类型，就没问题，但是如果有集合类，就不行。原因如下：
1)使用了集合如Li
    

    • 

  • JAVA海量数据处理之二（BitMap）
周凡杨
java算法bitmapbitset数据

           路漫漫其修远兮，吾将上下而求索。想要更快，就要深入挖掘 JAVA 基础的数据结构，从来分析出所编写的 JAVA 代码为什么把内存耗尽，思考有什么办法可以节省内存呢？ 啊哈！算法。这里采用了 BitMap 思想。
 
首先来看一个实验：
指定 VM 参数大小： -Xms256m -Xmx540m 
    

    • 

  • java类型与数据库类型
g21121
java

    很多时候我们用hibernate的时候往往并不是十分关心数据库类型和java类型的对应关心，因为大多数hbm文件是自动生成的，但有些时候诸如：数据库设计、没有生成工具、使用原始JDBC、使用mybatis(ibatIS)等等情况，就会手动的去对应数据库与java的数据类型关心，当然比较简单的数据类型即使配置错了也会很快发现问题，但有些数据类型却并不是十分常见，这就给程序员带来了很多麻烦。
&nb
    

    • 

  • Linux命令
510888780
linux命令

    系统信息
arch 显示机器的处理器架构(1)
uname -m 显示机器的处理器架构(2)
uname -r 显示正在使用的内核版本
dmidecode -q 显示硬件系统部件 - (SMBIOS / DMI)
hdparm -i /dev/hda 罗列一个磁盘的架构特性
hdparm -tT /dev/sda 在磁盘上执行测试性读取操作
cat /proc/cpuinfo 显示C
    

    • 

  • java常用JVM参数
墙头上一根草
javajvm参数

    -Xms：初始堆大小，默认为物理内存的1/64(<1GB)；默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制
-Xmx：最大堆大小，默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制
-Xmn：新生代的内存空间大小，注意：此处的大小是（eden+ 2
    

    • 

  • 我的spring学习笔记9-Spring使用工厂方法实例化Bean的注意点
aijuans
Spring 3

    方法一：
<bean id="musicBox" class="onlyfun.caterpillar.factory.MusicBoxFactory"
factory-method="createMusicBoxStatic"></bean>
方法二：

    

    • 

  • mysql查询性能优化之二
annan211
UNIONmysql查询优化索引优化

    
1 union的限制
有时mysql无法将限制条件从外层下推到内层，这使得原本能够限制部分返回结果的条件无法应用到内层
查询的优化上。
如果希望union的各个子句能够根据limit只取部分结果集，或者希望能够先排好序在
合并结果集的话，就需要在union的各个子句中分别使用这些子句。
例如 想将两个子查询结果联合起来，然后再取前20条记录，那么mys
    

    • 

  • 数据的备份与恢复
百合不是茶
oraclesql数据恢复数据备份

     数据的备份与恢复的方式有: 表,方案 ,数据库;
 
 
数据的备份:
导出到的常见命令;
参数 说明
USERID 确定执行导出实用程序的用户名和口令
BUFFER 确定导出数据时所使用的缓冲区大小，其大小用字节表示
FILE 指定导出的二进制文
    

    • 

  • 线程组
bijian1013
java多线程threadjava多线程线程组

    有些程序包含了相当数量的线程。这时，如果按照线程的功能将他们分成不同的类别将很有用。
       线程组可以用来同时对一组线程进行操作。
       创建线程组：ThreadGroup g = new ThreadGroup(groupName);
 &nbs
    

    • 

  • top命令找到占用CPU最高的java线程
bijian1013
javalinuxtop

    上次分析系统中占用CPU高的问题，得到一些使用Java自身调试工具的经验，与大家分享。 (1)使用top命令找出占用cpu最高的JAVA进程PID:28174 (2)如下命令找出占用cpu最高的线程
top -Hp 28174 -d 1 -n 1
32694 root 20 0 3249m 2.0g 11m S 2 6.4 3:31.12 java 
    

    • 

  • 【持久化框架MyBatis3四】MyBatis3一对一关联查询
bit1129
Mybatis3

     
当两个实体具有1对1的对应关系时，可以使用One-To-One的进行映射关联查询
  One-To-One示例数据
以学生表Student和地址信息表为例，每个学生都有都有1个唯一的地址(现实中，这种对应关系是不合适的，因为人和地址是多对一的关系)，这里只是演示目的
 
学生表
 
CREATE TABLE STUDENTS
(

    

    • 

  • C/C++图片或文件的读写
bitcarter
写图片

    先看代码：
/*strTmpResult是文件或图片字符串
* filePath文件需要写入的地址或路径
*/
int writeFile(std::string &strTmpResult,std::string &filePath)
{
int i,len = strTmpResult.length();
unsigned cha
    

    • 

  • nginx自定义指定加载配置
ronin47

    进入 /usr/local/nginx/conf/include 目录，创建 nginx.node.conf 文件，在里面输入如下代码：
upstream nodejs {
server 127.0.0.1:3000;
#server 127.0.0.1:3001;
keepalive 64;
}
server {
liste
    

    • 

  • java-71-数值的整数次方.实现函数double Power(double base, int exponent)，求base的exponent次方
bylijinnan
double

    
public class Power {
/**
*Q71-数值的整数次方
*实现函数double Power(double base, int exponent)，求base的exponent次方。不需要考虑溢出。
*/
private static boolean InvalidInput=false;
public static void main(
    

    • 

  • Android四大组件的理解
Cb123456
android四大组件的理解

     分享一下，今天在Android开发文档-开发者指南中看到的:         
       
          App components are the essential building blocks of an Android 
    

    • 

  • [宇宙与计算]涡旋场计算与拓扑分析
comsci
计算

    
     怎么阐述我这个理论呢？ 。。。。。。。。。
      首先： 宇宙是一个非线性的拓扑结构与涡旋轨道时空的统一体。。。。
      我们要在宇宙中寻找到一个适合人类居住的行星，时间非常重要，早一个刻度和晚一个刻度，这颗行星的
    

    • 

  • 同一个Tomcat不同Web应用之间共享会话Session
cwqcwqmax9
session

    实现两个WEB之间通过session 共享数据
查看tomcat 关于 HTTP Connector 中有个emptySessionPath 其解释如下：
If set to true, all paths for session cookies will be set to /. This can be useful for portlet specification impleme
    

    • 

  • springmvc Spring3 MVC，ajax，乱码
dashuaifu
springjquerymvcAjax

     
springmvc Spring3 MVC @ResponseBody返回，jquery ajax调用中文乱码问题解决  
Spring3.0 MVC @ResponseBody 的作用是把返回值直接写到HTTP response body里。具体实现AnnotationMethodHandlerAdapter类handleResponseBody方法，具体实
    

    • 

  • 搭建WAMP环境
dcj3sjt126com
wamp

    这里先解释一下WAMP是什么意思。W:windows，A：Apache，M：MYSQL，P：PHP。也就是说本文说明的是在windows系统下搭建以apache做服务器、MYSQL为数据库的PHP开发环境。 
    工欲善其事，必须先利其器。因为笔者的系统是WinXP，所以下文指的系统均为此系统。笔者所使用的Apache版本为apache_2.2.11-
    

    • 

  • yii2 使用raw http request
dcj3sjt126com
http

    Parses a raw HTTP request using yii\helpers\Json::decode()
 
To enable parsing for JSON requests you can configure yii\web\Request::$parsers using this class:
'request' =&g
    

    • 

  • Quartz-1.8.6 理论部分
eksliang
quartz

    转载请出自出处：http://eksliang.iteye.com/blog/2207691 一.概述
基于Quartz-1.8.6进行学习，因为Quartz2.0以后的API发生的非常大的变化，统一采用了build模式进行构建；
什么是quartz?
 
答：简单的说他是一个开源的java作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。并且还能和Sp
    

    • 

  • 什么是POJO？
gupeng_ie
javaPOJO框架Hibernate

    POJO--Plain Old Java Objects(简单的java对象)
 
POJO是一个简单的、正规Java对象，它不包含业务逻辑处理或持久化逻辑等，也不是JavaBean、EntityBean等，不具有任何特殊角色和不继承或不实现任何其它Java框架的类或接口。
 
POJO对象有时也被称为Data对象，大量应用于表现现实中的对象。如果项目中使用了Hiber
    

    • 

  • jQuery网站顶部定时折叠广告
ini
JavaScripthtmljqueryWebcss

    效果体验：http://hovertree.com/texiao/jquery/4.htmHTML文件代码：
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>网页顶部定时收起广告jQuery特效 - HoverTree<
    

    • 

  • Spring boot内嵌的tomcat启动失败
kane_xie
spring boot

    根据这篇guide创建了一个简单的spring boot应用，能运行且成功的访问。但移植到现有项目（基于hbase）中的时候，却报出以下错误：
 
 
SEVERE: A child container failed during start
java.util.concurrent.ExecutionException: org.apache.catalina.Lif
    

    • 

  • leetcode: sort list
michelle_0916
Algorithmlinked listsort

    Sort a linked list in O(n log n) time using constant space complexity.
====analysis=======
mergeSort for singly-linked list 
====code=======   /**
* Definition for sin
    

    • 

  • nginx的安装与配置,中途遇到问题的解决
qifeifei
nginx

    我使用的是ubuntu13.04系统，在安装nginx的时候遇到如下几个问题，然后找思路解决的，nginx 的下载与安装
 
wget http://nginx.org/download/nginx-1.0.11.tar.gz
tar zxvf nginx-1.0.11.tar.gz
./configure
make
make install
 
安装的时候出现
    

    • 

  • 用枚举来处理java自定义异常
tcrct
javaenumexception

    在系统开发过程中，总少不免要自己处理一些异常信息，然后将异常信息变成友好的提示返回到客户端的这样一个过程，之前都是new一个自定义的异常，当然这个所谓的自定义异常也是继承RuntimeException的，但这样往往会造成异常信息说明不一致的情况，所以就想到了用枚举来解决的办法。
1，先创建一个接口，里面有两个方法，一个是getCode, 一个是getMessage
public 
    

    • 

  • erlang supervisor分析
wudixiaotie
erlang

    当我们给supervisor指定需要创建的子进程的时候，会指定M,F,A,如果是simple_one_for_one的策略的话，启动子进程的方式是supervisor:start_child(SupName, OtherArgs),这种方式可以根据调用者的需求传不同的参数给需要启动的子进程的方法。和最初的参数合并成一个数组，A ++ OtherArgs。那么这个时候就有个问题了，既然参数不一致，那
    

    •