Weex框架源码分析（Android）（一）

一、weexSDK初始化流程

WXSDKEngine.initialize(Application application,InitConfig config);

//WXSDKEngine的init方法已经被弃用，weex的初始化需要使用下面这个initialize方法

public static void initialize(Application application,InitConfig config){

synchronized (mLock) {

//如果已经初始化过那么直接return

if (mIsInit) {

return;

}

long start = System.currentTimeMillis();

WXEnvironment.sSDKInitStart = start;

if(WXEnvironment.isApkDebugable()){

WXEnvironment.sLogLevel = LogLevel.DEBUG;

}else{

if(WXEnvironment.sApplication != null){

WXEnvironment.sLogLevel = LogLevel.WARN;

}else {

WXLogUtils.e(TAG,"WXEnvironment.sApplication is " + WXEnvironment.sApplication);

}

}

doInitInternal(application,config);

WXEnvironment.sSDKInitInvokeTime = System.currentTimeMillis()-start;

WXLogUtils.renderPerformanceLog("SDKInitInvokeTime", WXEnvironment.sSDKInitInvokeTime);

//监测weex表现的的一个检测器的初始化

WXPerformance.init();

mIsInit = true;

}

}
此方法最终会调用doInitInternal(application,config),其余部分的代码叔要是设置apk的debug和log模式，计算weexSDK初始化所需时间等。那么接下来看doInitInternal(application,config)的代码。

private static void doInitInternal(final Application application,final InitConfig config){

//这里给WXEnvironment中的application赋值，方便后续使用

WXEnvironment.sApplication = application;

if(application == null){//application为空的话报错

WXLogUtils.e(TAG, " doInitInternal application is null");

WXExceptionUtils.commitCriticalExceptionRT(null,

WXErrorCode.WX_KEY_EXCEPTION_SDK_INIT,

"doInitInternal",

WXErrorCode.WX_KEY_EXCEPTION_SDK_INIT.getErrorMsg() + "WXEnvironment sApplication is null",

null);

}

//weex环境初始化标识设置为false

WXEnvironment.JsFrameworkInit = false;

//通过单例模式获取一个WXBridgeManager的唯一实例，使用WXBridgeManager开启一个安全的线程初始化weex框架。

//开启安全线程的细节暂时不深究，这里主要看weex框架的初始化流程

WXBridgeManager.getInstance().post(new Runnable() {

@Override

public void run() {

//开始初始化时间

long start = System.currentTimeMillis();

//获取WXSDKManager实例

WXSDKManager sm = WXSDKManager.getInstance();

//使用sm监听weex框架初始化，我们可以通过WXSDKManager.registerStatisticsListener（）

//注册一个监听器

sm.onSDKEngineInitialize();

//设置weex框架配置项

if(config != null ) {

sm.setInitConfig(config);

}

//初始化so文件加载器，后两个参数分别为初始化时的加载器和监听器。

WXSoInstallMgrSdk.init(application,

sm.getIWXSoLoaderAdapter(),

sm.getWXStatisticsListener());

//加载so库文件，如不设置自定义的IWXSoLoaderAdapter，那么采用系统默认方式加载

boolean isSoInitSuccess = WXSoInstallMgrSdk.initSo(V8_SO_NAME, 1, config!=null?config.getUtAdapter():null);

if (!isSoInitSuccess) {//加载失败报错

WXExceptionUtils.commitCriticalExceptionRT(null,

WXErrorCode.WX_KEY_EXCEPTION_SDK_INIT,

"doInitInternal",

WXErrorCode.WX_KEY_EXCEPTION_SDK_INIT.getErrorMsg() + "isSoInit false",

null);

return;

}

//使用WXSDKManager初始化jsFramwork,就是讲weexSdk中assets下的js文件拷贝到缓存目录中，使用so的native方法执行

sm.initScriptsFramework(config!=null?config.getFramework():null);

//计算初始化所用时间

WXEnvironment.sSDKInitExecuteTime = System.currentTimeMillis() - start;

WXLogUtils.renderPerformanceLog("SDKInitExecuteTime", WXEnvironment.sSDKInitExecuteTime);

}

});

//注册weexSDK内置的一系列Component和Module

register();

}
二、组件（Component）注册流程

按照weex官网的流程，首先我们会调用WXSDKEngine的registerComponent(String type, Class<? extends WXComponent> clazz)方法。

我们在WXSDKEngine源码中找到这个方法：

public static boolean registerComponent(String type, Class<? extends WXComponent> clazz) throws WXException {

return WXComponentRegistry.registerComponent(type, new SimpleComponentHolder(clazz),new HashMap<String, Object>());

}
我们发现该方法实际上是调用了WXComponentRegistry.registerComponent(xx,xx,xx)方法，我们先对SimpleComponentHolder留意，后续会用到。那么我们跟踪到WXComponentRegistry中查看registerComponent方法的实现。

public static synchronized boolean registerComponent(final String type, final IFComponentHolder holder, final Map<String, Object> componentInfo) throws WXException {

if (holder == null || TextUtils.isEmpty(type)) {

return false;

}

//execute task in js thread to make sure register order is same as the order invoke register method.

//在js线程执行这个注册组件的任务，以确保我们注册组件的顺序与调用注册方法的顺序一致。

WXBridgeManager.getInstance()

.post(new Runnable() {

@Override

public void run() {

try {

Map<String, Object> registerInfo = componentInfo;

if (registerInfo == null){

registerInfo = new HashMap<>();

}

//设置注册信息

registerInfo.put("type",type);

//holder是之前让大家留意的SimpleComponentHolder类

registerInfo.put("methods",holder.getMethods());

//生成原生组件映射

registerNativeComponent(type, holder);

//将组件注册信息传递到jsFramwork，生成js中解析vue中原生component是所需的Json映射

registerJSComponent(registerInfo);

//sComponentInfos是js解析需要使用的类，包含所有组件的注册信息

sComponentInfos.add(registerInfo);

} catch (WXException e) {

WXLogUtils.e("register component error:", e);

}

}

});

return true;

}
以上有几行代码需要在跟踪代码进一步分析：

1、holder.getMethods();

此处的holder对象即之前让大家留意的new SimpleComponentHolder(clazz)，我们跟踪源码看一下这个方法的实现

public static Pair<Map<String,Invoker>,Map<String,Invoker>> getMethods(Class clz){

Map<String, Invoker> methods = new HashMap<>();

Map<String, Invoker> mInvokers = new HashMap<>();

Annotation[] annotations;

Annotation anno;

try {

for (Method method : clz.getMethods()) {

try {

annotations = method.getDeclaredAnnotations();

for (int i = 0, annotationsCount = annotations.length;

i < annotationsCount; ++i) {

anno = annotations[i];

if(anno == null){

continue;

}

if (anno instanceof WXComponentProp) {

String name = ((WXComponentProp) anno).name();

methods.put(name, new MethodInvoker(method,true));

break;

}else if(anno instanceof JSMethod){

JSMethod methodAnno = (JSMethod)anno;

String name = methodAnno.alias();

if(JSMethod.NOT_SET.equals(name)){

name = method.getName();

}

mInvokers.put(name, new MethodInvoker(method,methodAnno.uiThread()));

break;

}

}

} catch (ArrayIndexOutOfBoundsException | IncompatibleClassChangeError e) {

//ignore: getDeclaredAnnotations may throw this

}

}

}catch (IndexOutOfBoundsException e){

e.printStackTrace();

//ignore: getMethods may throw this

}

return new Pair<>(methods,mInvokers);

}
代码很简单，我们可以看出这个方法获取了要注册的Component的所有属性和方法，并把它们方法两个map集合中，最后将两个map封装成Pair返回。

时间上就是通过对WXComponent.Class对象的解析获取了其所有的属性和方法（通过WXComponentProp和JSMethod注解）。

获取成功后通过registerInfo.put("methods",holder.getMethods());将这些属性和方法信息放到组件的注册信息中。

2、registerNativeComponent(type, holder);

此方法属于用于生成原生组件的映射，用于对js文件的解析，我们同样来看一下此方法的实现。

//WXComponentRegistry.java

private static boolean registerNativeComponent(String type, IFComponentHolder holder) throws WXException {

try {

holder.loadIfNonLazy();

sTypeComponentMap.put(type, holder);

}catch (ArrayStoreException e){

e.printStackTrace();

//ignore: ArrayStoreException: java.lang.String cannot be stored in an array of type java.util.HashMap$HashMapEntry[]

}

return true;

}
 holder.loadIfNonLazy();这行代码调用了SimpleComponentHolder的loadIfNonLazy方法对holder进行了加载，实际上是将组件属性和方法信息保存在SimpleComponentHolder类型的对象holder中，之后将holder保存到sTypeComponentMap中，这是一个component组件的映射集合Map，它是一个静态变量。后续与sComponentInfos配合实现对js文件中component组件的解析（将编译成的Json对象映射解析成原生组件）。

loadIfNonLazy（）方法实现如下，比较简单，不在详细说明，看注释即可。

//SimpleComponentHolder.java

@Override

public void loadIfNonLazy() {

//获取类中所有注解

Annotation[] annotations = mClz.getDeclaredAnnotations();

for (Annotation annotation :

annotations) {

if (annotation instanceof Component){

if(!((Component) annotation).lazyload() && mMethodInvokers == null){

//通过此方法获得组件类的方法和属性，并保存

generate();

}

return;

}

}

}

private synchronized void generate(){

if(WXEnvironment.isApkDebugable()) {

WXLogUtils.d(TAG, "Generate Component:" + mClz.getSimpleName());

}

//通过getMethods（）方法获取属性和方法信息

Pair<Map<String, Invoker>, Map<String, Invoker>> methodPair = getMethods(mClz);

//保存属性和方法信息到自身

mPropertyInvokers = methodPair.first;

mMethodInvokers = methodPair.second;

}

3、registerJSComponent(registerInfo);

此方法用于将组件的属性和方法信息转换成对象的Json对象。

//WXComponentRegistry.java

private static boolean registerJSComponent(Map<String, Object> componentInfo) throws WXException {

ArrayList<Map<String, Object>> coms = new ArrayList<>();

coms.add(componentInfo);

WXSDKManager.getInstance().registerComponents(coms);

return true;

}
//WXSDKManager.java

public void registerComponents(List<Map<String, Object>> components) {

mBridgeManager.registerComponents(components);

}
最终调用的是WXBridgeManager的invokeRegisterComponents方法。实现如下，我们结合注释说明一下实现过程。

//WXBridgeManager.java

/**
* Registered component
*/

public void registerComponents(final List<Map<String, Object>> components) {

//js线程处理器或者组件的集合为空则之间返回

if (mJSHandler == null || components == null

|| components.size() == 0) {

return;

}

//在JsThred中进行组件注册

post(new Runnable() {

@Override

public void run() {

invokeRegisterComponents(components, mRegisterComponentFailList);

}

}, null);

}

//注册组件

private void invokeRegisterComponents(List<Map<String, Object>> components, List<Map<String, Object>> failReceiver) {

//failReceiver是一个注册失败的组件的集合

if (components == failReceiver) {

throw new RuntimeException("Fail receiver should not use source.");

}

//jsFramwork初始化未完成就将组件放入到注册失败的集合中

if (!isJSFrameworkInit()) {

WXLogUtils.e("[WXBridgeManager] invokeRegisterComponents: framework.js uninitialized.");

for (Map<String, Object> comp : components) {

failReceiver.add(comp);

}

return;

}

if (components == null) {

return;

}

//将通过组件的映射信息将其转化为Json

WXJSObject[] args = {new WXJSObject(WXJSObject.JSON,

WXJsonUtils.fromObjectToJSONString(components))};

try {

//通过调用WXBridge的native方法execJS（）,调用main.js中的registerComponent方法注册组件

mWXBridge.execJS("", null, METHOD_REGISTER_COMPONENTS, args);

} catch (Throwable e) {

WXLogUtils.e("[WXBridgeManager] invokeRegisterComponents ", e);

WXExceptionUtils.commitCriticalExceptionRT(null,

WXErrorCode.WX_KEY_EXCEPTION_INVOKE_REGISTER_CONTENT_FAILED,

METHOD_REGISTER_COMPONENTS,

WXErrorCode.WX_KEY_EXCEPTION_INVOKE_REGISTER_CONTENT_FAILED.getErrorMsg()

+ args.toString()

+ WXLogUtils.getStackTrace(e),

null);

}

}

三、模块（Module）注册流程

下面是相关实现代码，只写一下简单的注释，模块注册流程与组件注册很类似，不再详细说明，感兴趣可以尝试自己阅读源码分析一下。

//WXSDKEngine

public static boolean registerModule(String moduleName, Class<? extends WXModule> moduleClass) throws WXException {

return registerModule(moduleName, moduleClass,false);

}

public static <T extends WXModule> boolean registerModule(String moduleName, Class<T> moduleClass,boolean global) throws WXException {

return moduleClass != null && registerModule(moduleName, new TypeModuleFactory<>(moduleClass), global);

}

public static <T extends WXModule> boolean registerModule(String moduleName, ModuleFactory factory, boolean global) throws WXException {

//在WXSDKEngine中最终调用WXModuleManager.registerModule(moduleName, factory,global)

return WXModuleManager.registerModule(moduleName, factory,global);

}
//WXModuleManager

/**
* Register module to JavaScript and Android
*/

public static boolean registerModule(final String moduleName, final ModuleFactory factory, final boolean global) throws WXException {

if (moduleName == null || factory == null) {

return false;

}

if (TextUtils.equals(moduleName, WXDomModule.WXDOM)) {

WXLogUtils.e("Cannot registered module with name 'dom'.");

return false;

}

try {

//这句代码不知道为啥写，因为后面执行了相同的代码，就是将持有Module类信息的TypeModuleFactory对象保存到sModuleFactoryMap中      //去。不知道是不是源码写错了,有高见的同学请赐教

sModuleFactoryMap.put(moduleName, new ModuleFactoryImpl(factory));

} catch (Throwable e) {

}

//execute task in js thread to make sure register order is same as the order invoke register method.

WXBridgeManager.getInstance()

.post(new Runnable() {

@Override

public void run() {

if (sModuleFactoryMap != null && sModuleFactoryMap.containsKey(moduleName)) {

WXLogUtils.w("WXComponentRegistry Duplicate the Module name: " + moduleName);

}

try {

//原生代码中注册module模块的类信息

registerNativeModule(moduleName, factory);

} catch (WXException e) {

WXLogUtils.e("registerNativeModule" + e);

}

if (global) {

try {

WXModule wxModule = factory.buildInstance();

wxModule.setModuleName(moduleName);

sGlobalModuleMap.put(moduleName, wxModule);

} catch (Exception e) {

WXLogUtils.e(moduleName + " class must have a default constructor without params. ", e);

}

}

registerJSModule(moduleName, factory);

}

});

return true;

}
//原生代码中注册module模块的类信息

static boolean registerNativeModule(String moduleName, ModuleFactory factory) throws WXException {

if (factory == null) {

return false;

}

try {

if (!sModuleFactoryMap.containsKey(moduleName) ) {

//将持有Module类信息的TypeModuleFactory对象保存到sModuleFactoryMap中去

sModuleFactoryMap.put(moduleName, new ModuleFactoryImpl(factory));

}

}catch (ArrayStoreException e){

e.printStackTrace();

//ignore:

//may throw this exception:

//java.lang.String cannot be stored in an array of type java.util.HashMap$HashMapEntry[]

WXLogUtils.e("[WXModuleManager] registerNativeModule Error moduleName:"  + moduleName + " Error:" + e.toString());

}

return true;

}

//在Js中注册module模块的方法和名称信息

static boolean registerJSModule(String moduleName, ModuleFactory factory) {

Map<String, Object> modules = new HashMap<>();

modules.put(moduleName, factory.getMethods());

WXSDKManager.getInstance().registerModules(modules);

return true;

}
//WXBridgeManager

private void invokeRegisterModules(Map<String, Object> modules, List<Map<String, Object>> failReceiver) {

if (modules == null || !isJSFrameworkInit()) {

if (!isJSFrameworkInit()) {

WXLogUtils.d("[WXinvokeRegisterModulesBridgeManager] invokeRegisterModules: framework.js uninitialized.");

}

failReceiver.add(modules);

return;

}

//将modules转换成WXJSObject

WXJSObject[] args = {new WXJSObject(WXJSObject.JSON,

WXJsonUtils.fromObjectToJSONString(modules))};

try {

//调用WXBrige的native方法在js中注册module

mWXBridge.execJS("", null, METHOD_REGISTER_MODULES, args);

try {

Iterator<String> iter = modules.keySet().iterator();

while (iter.hasNext()) {

String module = iter.next();

if (module != null) {

WXModuleManager.resetModuleState(module, true);

WXLogUtils.e("[WXBridgeManager]invokeRegisterModules METHOD_REGISTER_MODULES success module:" + module);

}

}

} catch (Throwable e) {

}

} catch (Throwable e) {

WXExceptionUtils.commitCriticalExceptionRT(null,

WXErrorCode.WX_KEY_EXCEPTION_INVOKE_REGISTER_MODULES,

"invokeRegisterModules", WXErrorCode.WX_KEY_EXCEPTION_INVOKE_REGISTER_MODULES.getErrorMsg() +

" \n " + e.getMessage() + modules.entrySet().toString(),

null );

WXLogUtils.e("[WXBridgeManager] invokeRegisterModules:", e);

}

}
---------------------