优点：

• js 能写业务，跨平台，热更新
• Weex 能用 Vue 的 framework，贴近我们的技术栈
• Weex 比 RN 更轻量，可以分包，每个页面一个实例性能更好
• Weex 解决了 RN 已经存在的一些问题，在 RN 的基础上进行开发
• 有良好的扩展性，比较好扩展新的 Component 和 Module

缺点：

• 文档不全，资料少，社区几乎等于没有，issue 堆积，后台 issue 的方式改到了 JIRA 上，很多开发者都不了解
• bug 多，不稳定，遇到多次断崖式更新
• Component 和 Module 不足以覆盖功能

其实总结起来就是起步晚的国产货，优点就不赘述了。主要看缺点会不会限制住业务场景，有没有对应的解决方案。

相关资料比较少，好在能看到源码，有了源码多花点时间琢磨，肯定是能继续下去的，顺着源码看过去，文档不全的问题也解决了，主要是发现了Weex提供了非常多文档上没有写的好属性和方法。

项目起步比较晚，bug比较多，更新也是断崖式的，我们最后采用源码集成的方法，发现有bug就修源码，并给官方提PR，我们团队提的很多PR也被官方采纳，主要还是每次版本更新比较浪费时间，一方面要看更新日志，还要对源码进行diff，如果官方已经修复了就删除我们自己的补丁。这块确实是会浪费时间一点，但是RN想要自己扩展也是需要经历这个阵痛的。

提供的Component和Module不足以完成业务需求，当然官方也提供了扩展对应插件化的方式，尝试扩展了几个插件具备原生知识扩展起来也比较快，并且我们一开始就决定尽量少用官方的Module，尽量Module都由我们的客户端自己扩展，一方面不会受到官方的Module bug或者不向下兼容时的影响，另一方面在扩展原生Module的同时能了解其机制，还能让扩展的Module都配合我们的业务。

接入成本与学习成本

上图是我们通过改进最后给出的 Eros 开发的方案，以脚手架为核心的开发模式。

开发体验基于Vue的方式，各种语法都已经在脚手架那层抹平了，开发起来和之前的开发模式基本一致，开发调试的方式Weex提供了独立的模块支持，了解原理之后，我们很快做了保存即刷新的功能，加上本身Weex debug提供的debug页面，js也能进行调试，客户端也支持了日志输出，开发体验整体来看还比较流畅，确实是不如web开发那么自然，但是我们通过对脚手架的改造，对客户端支持热刷新功能，及原生提供的一些工具，大大的改善了开发体验。

用户体验方面整体性能对比RN有了提高，站在RN的肩膀上，确实解决了很多性能的问题，首次的白屏时间，我们采用的是内置包，并且配合我们的热更新机制，是能保证客户端打开的时候，一定是有对应的内容的，不需要额外去加载资源，白屏时间也有了保证。页面切换的时候我们采用多页面的方式去实现Weex，配合我们自己扩展的路由机制每个页面是一个单独的Weex实例，所以每个页面单独渲染的性能和效率要更好，并且我们也一直在做预加载的方案，虽然说对于性能改善的效果不是很明显，但是每一小步都是可以减少页面间切换的白屏时间的。

性能监控和容灾处理

Weex自己本身就做了很多性能监控，只需要对性能数据接入我们的监控系统，就能展示出对应的性能数据，目前从监控效果上来看确实实现了Weex对性能的承诺。

容灾处理用于处理jsBundle访问失败的情况，Weex自己具备容灾处理的方案，需要开发者自己做改造进行降级处理，展示页⾯面时，客户端会加载对应如果客户端加载js bundle失败可以启用webView访问，展示HTML端，但是体验会非常不好，我们采用内置包 + 热更新的机制，保证我们不会出现包解析失败或者访问不到的问题，如果发布的包有问题，可以紧急再发布，用户立马会接收到更新，并且根据配置告知用户是否立马更新，想要做的更好，可以保存一个稳定版本的包在用户手机中，遇到解析错误崩溃的问题，立即启用稳定版本的内置包，但是这样会导致包比较大，如果需要稳定的容灾处理可以考虑这样去实现。

在完成了方案调研和简单的demo测试，我们就开始落地，围绕的Weex也做了非常多的周边环境的建设，比如现有脚手架的改造以支持Weex的开发、热更新机制如何构建、客户端底层需要哪些支持、如何做扩展能与源码进行解耦等等。

还是说回正题，接下来介绍一下Weex整体的架构。

Weex 整体架构

从上面这个图可以看出Weex整体的运行原理，这里对流程做一个大概的介绍，后面每一步都会有详细的介绍。

Weex提供不同的framework解析，可以用.we和.vue文件写业务，然后通过webpack进行打包编译生成js bundle，编译过程中主要是用了weex相关的loader，Eros 对打包好的js bundle生成了zip包，还会生成差分包的逻辑。不管生成的是什么文件，最后都是将js bundle部署到服务器或者CDN节点上。

客户端启动时发现引入了Weex sdk，首先会初始化环境及一些监控，接着会运行本地的main.js即js framework，js framework会初始化一些环境，当js framework和客户端都准备好之后，就开始等待客户端什么时候展示页面。

当需要展示页面时，客户端会初始化Weex实例，就是WXSDKInstance，Weex实例会加载对应的js bundle文件，将整个js bundle文件当成一个字符串传给js framework，还会传递一些环境参数。js framework开始在JavaScript Core中执行js bundle，将js bundle执行翻译成virtual DOM，准备好数据双绑，同时将vDOM进行深度遍历解析成vNode，对应成一个个的渲染指令通过js Core传递给客户端。

js framework调用Weex SDK初始化时准备好的callNative、addElement 等方法，将指令传递给 native，找到指令对应的Weex Component执行渲染绘制，每渲染一个组件展示一个，Weex性能瓶颈就是来自于逐个传递组件的过程，调用module要稍微复杂一些，后面会详解，事件绑定后面也会详解。至此一个页面就展示出来了。

Weex SDK

上面我们分析了大概的Weex架构，也简单介绍了一下运行起来的流程，接下来我们基于 Eros 的源码来详细看一下每一步是如何进行的，Eros 是基于Weex的二次封装，客户端运行的第一个部分就是初始化Weex的sdk。

初始化Weex sdk主要完成下面四个事情：

• 关键节点记录监控信息
• 初始化 SDK 环境，加载并运行 js framework
• 注册 Components、Modules、Handlers
• 如果是在开发环境初始化模拟器尝试连接本地 server

Eros 在Weex的基础上做了很多扩展，Weex的主要流程就是上面一些，Eros 主要的代码流程就是下面这样的。

+ (void)initWeexSDK
{
    [WXSDKEngine initSDKEnvironment];
    
    [BMConfigManager registerBmHandlers];
    [BMConfigManager registerBmComponents];
    [BMConfigManager registerBmModules];
    
#ifdef DEBUG
    [WXDebugTool setDebug:YES];
    [WXLog setLogLevel:WeexLogLevelLog];
    [[BMDebugManager shareInstance] show];
//    [[ATManager shareInstance] show];
    
#else
    [WXDebugTool setDebug:NO];
    [WXLog setLogLevel:WeexLogLevelError];
#endif
}

Components 注册

小白同学可能会比较疑惑为什么Weex只支持一些特定的标签，不是HTML里的所有标签都支持，首先标签的解析肯定需要与原生有一个对应关系，这些对应关系的标签才能支持。这个对应关系从哪儿来，就是首先 Weex 会初始化一些Components，首先要告诉Weex SDK我支持哪些标签，这其中就包括Weex提供的一些标签，和我们通过Weex Component的扩展方法扩展出来的标签。

我们来看看Components是怎么注册的，就是上面方法中的_registerDefaultComponents，下面是这些方法的部分代码

+ (void)registerComponent:(NSString *)name withClass:(Class)clazz withProperties:(NSDictionary *)properties
{
    if (!name || !clazz) {
        return;
    }

    WXAssert(name && clazz, @"Fail to register the component, please check if the parameters are correct ！");
    // 注册组件的方法
    [WXComponentFactory registerComponent:name withClass:clazz withPros:properties];
    
    // 遍历出组件的异步方法
    NSMutableDictionary *dict = [WXComponentFactory componentMethodMapsWithName:name];
    dict[@"type"] = name;
    
    // 将组件放到 bridge 中，准备注册到 js framework 中。
    if (properties) {
        NSMutableDictionary *props = [properties mutableCopy];
        if ([dict[@"methods"] count]) {
            [props addEntriesFromDictionary:dict];
        }
        [[WXSDKManager bridgeMgr] registerComponents:@[props]];
    } else {
        [[WXSDKManager bridgeMgr] registerComponents:@[dict]];
    }
}

首先看一下参数，name为注册在jsfm中Component的名字（即标签的名字），clazz为Component对应的类，properties为一些扩展属性；

在这个方法中又调用了WXComponentFactory的方法registerComponent:name withClass:clazz withPros:properties来注册Component，WXComponentFactory是一个单例，负责解析Component的方法，并保存所有注册的Component对应的方法；继续到 WXComponentFactory 中看一下 registerComponent:name withClass:clazz withPros:properties方法的实现：

// 类
- (void)registerComponent:(NSString *)name withClass:(Class)clazz withPros:(NSDictionary *)pros
{
    WXAssert(name && clazz, @"name or clazz must not be nil for registering component.");
    
    WXComponentConfig *config = nil;
    [_configLock lock];
    config = [_componentConfigs objectForKey:name];
    
    if(config){
        WXLogInfo(@"Overrider component name:%@ class:%@, to name:%@ class:%@",
                  config.name, config.class, name, clazz);
    }
    
    // 实例 WXComponentConfig 并保存到 _componentConfigs 中
    config = [[WXComponentConfig alloc] initWithName:name class:NSStringFromClass(clazz) pros:pros];
    [_componentConfigs setValue:config forKey:name];
    [config registerMethods];
    
    [_configLock unlock];
}

该方法中会实例化一个 WXComponentConfig对象 config，每个 Component都会有一个与之绑定的 WXComponentConfig实例，然后将 config实例作为 value， key为 Component的 name保存到 _componentConfigs中（ _componentConfigs 是一个字典）， config中保存了 Component的所有暴露给js的方法，继续看一下 WXComponentConfig的 registerMethods方法：

- (void)registerMethods
{
	 // 获取类 
    Class currentClass = NSClassFromString(_clazz);
    
    if (!currentClass) {
        WXLogWarning(@"The module class [%@] doesn't exit！", _clazz);
        return;
    }
    
    while (currentClass != [NSObject class]) {
        unsigned int methodCount = 0;
        // 获取方法列表
        Method *methodList = class_copyMethodList(object_getClass(currentClass), &methodCount);
        // 遍历方法列表
        for (unsigned int i = 0; i < methodCount; i++) {
        	  // 获取方法名称
            NSString *selStr = [NSString stringWithCString:sel_getName(method_getName(methodList[i])) encoding:NSUTF8StringEncoding];
            BOOL isSyncMethod = NO;
            // 同步方法
            if ([selStr hasPrefix:@"wx_export_method_sync_"]) {
                isSyncMethod = YES;
            // 异步方法
            } else if ([selStr hasPrefix:@"wx_export_method_"]) {
                isSyncMethod = NO;
            // 其他未暴露方法
            } else {
                continue;
            }
            
            NSString *name = nil, *method = nil;
            SEL selector = NSSelectorFromString(selStr);
            // 获取方法实现
            if ([currentClass respondsToSelector:selector]) {
                method = ((NSString* (*)(id, SEL))[currentClass methodForSelector:selector])(currentClass, selector);
            }
            
            if (method.length <= 0) {
                WXLogWarning(@"The module class [%@] doesn't has any method！", _clazz);
                continue;
            }
            
            NSRange range = [method rangeOfString:@":"];
            if (range.location != NSNotFound) {
                name = [method substringToIndex:range.location];
            } else {
                name = method;
            }
            
            // 将方法保持到对应的字典中
            NSMutableDictionary *methods = isSyncMethod ? _syncMethods : _asyncMethods;
            [methods setObject:method forKey:name];
        }
        
        free(methodList);
        currentClass = class_getSuperclass(currentClass);
    }
    
}

WXComponentConfig中有两个字典 _asyncMethods与 _syncMethods，分别保存异步方法和同步方法； registerMethods方法中就是通过遍历 Component类获取所有暴露给 jsfm的方法；然后让我们在回到 WXSDKEngine的 registerComponent:withClass:withProperties:方法中。

+ (void)registerComponent:(NSString *)name withClass:(Class)clazz withProperties:(NSDictionary *)properties
{
    if (!name || !clazz) {
        return;
    }

    WXAssert(name && clazz, @"Fail to register the component, please check if the parameters are correct ！");
    
    [WXComponentFactory registerComponent:name withClass:clazz withPros:properties];
    // ↑ 到这里 Component 的方法已经解析完毕，并保持到了 WXComponentFactory 中
    
    // 获取 Component 的异步方法
    NSMutableDictionary *dict = [WXComponentFactory componentMethodMapsWithName:name];
    dict[@"type"] = name;
    // 最后将 Component 注册到 jsfm 中
    if (properties) {
        NSMutableDictionary *props = [properties mutableCopy];
        if ([dict[@"methods"] count]) {
            [props addEntriesFromDictionary:dict];
        }
        [[WXSDKManager bridgeMgr] registerComponents:@[props]];
    } else {
        [[WXSDKManager bridgeMgr] registerComponents:@[dict]];
    }
}

Component解析完毕后，会调用 WXSDKManager中的 bridgeMgr的 registerComponents:方法； WXSDKManager持有一个 WXBridgeManager，这个 WXBridgeManager又有一个的属性是 WXBridgeContext， WXBridgeContext又持有一个 js Bridge的引用，这个就是我们常说的 Bridge。下面是相关的主要代码和 bridge之间的关系。（现在 WXDebugLoggerBridge已经不存在了）

- (void)callJSMethod:(NSString *)method args:(NSArray *)args
{
   // 如果 js frameworkLoadFinished 就立即注入 Component
   if (self.frameworkLoadFinished) {
       [self.jsBridge callJSMethod:method args:args];
   } else {
   // 如果没有执行完，就将方法放到 _methodQueue 队列中
       [_methodQueue addObject:@{@"method":method, @"args":args}];
   }
}

- (void)callJSMethod:(NSString *)method args:(NSArray *)args onContext:(JSContext*)context completion:(void (^)(JSValue * value))complection
{
   NSMutableArray *newArg = nil;
   if (!context) {
       if ([self.jsBridge isKindOfClass:[WXJSCoreBridge class]]) {
          context = [(NSObject*)_jsBridge valueForKey:@"jsContext"];
       }
   }
   if (self.frameworkLoadFinished) {
       newArg = [args mutableCopy];
       if ([newArg containsObject:complection]) {
           [newArg removeObject:complection];
       }
       WXLogDebug(@"Calling JS... method:%@, args:%@", method, args);
       JSValue *value = [[context globalObject] invokeMethod:method withArguments:args];
       if (complection) {
           complection(value);
       }
   } else {
       newArg = [args mutableCopy];
       if (complection) {
           [newArg addObject:complection];
       }
       [_methodQueue addObject:@{@"method":method, @"args":[newArg copy]}];
   }
}

// 当 js framework 执行完毕之后会回来调用 WXJSCoreBridge 这个方法
- (JSValue *)callJSMethod:(NSString *)method args:(NSArray *)args
{
   WXLogDebug(@"Calling JS... method:%@, args:%@", method, args);
   return [[_jsContext globalObject] invokeMethod:method withArguments:args];
}

+ (void)_registerDefaultModules
{
    [self registerModule:@"dom" withClass:NSClassFromString(@"WXDomModule")];
    [self registerModule:@"locale" withClass:NSClassFromString(@"WXLocaleModule")];
    ...
}

+ (void)registerModule:(NSString *)name withClass:(Class)clazz
{
    WXAssert(name && clazz, @"Fail to register the module, please check if the parameters are correct ！");
    if (!clazz || !name) {
        return;
    }
    NSString *moduleName = [WXModuleFactory registerModule:name withClass:clazz];
    NSDictionary *dict = [WXModuleFactory moduleMethodMapsWithName:moduleName];
    
    [[WXSDKManager bridgeMgr] registerModules:dict];
}

@interface WXModuleFactory ()

@property (nonatomic, strong)  NSMutableDictionary  *moduleMap;
@property (nonatomic, strong)  NSLock   *moduleLock;

@end

- (NSString *)_registerModule:(NSString *)name withClass:(Class)clazz
{
    WXAssert(name && clazz, @"Fail to register the module, please check if the parameters are correct ！");
    
    [_moduleLock lock];
    //allow to register module with the same name;
    WXModuleConfig *config = [[WXModuleConfig alloc] init];
    config.name = name;
    config.clazz = NSStringFromClass(clazz);
    [config registerMethods];
    [_moduleMap setValue:config forKey:name];
    [_moduleLock unlock];
    
    return name;
}

- (NSMutableDictionary *)_moduleMethodMapsWithName:(NSString *)name
{
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    NSMutableArray *methods = [self _defaultModuleMethod];
    
    [_moduleLock lock];
    [dict setValue:methods forKey:name];
    
    WXModuleConfig *config = _moduleMap[name];
    void (^mBlock)(id, id, BOOL *) = ^(id mKey, id mObj, BOOL * mStop) {
        [methods addObject:mKey];
    };
    [config.syncMethods enumerateKeysAndObjectsUsingBlock:mBlock];
    [config.asyncMethods enumerateKeysAndObjectsUsingBlock:mBlock];
    [_moduleLock unlock];
    
    return dict;
}

- (NSMutableArray*)_defaultModuleMethod
{
    return [NSMutableArray arrayWithObjects:@"addEventListener",@"removeAllEventListeners", nil];
}

- (void)registerModules:(NSDictionary *)modules
{
    WXAssertBridgeThread();
    
    if(!modules) return;
    
    [self callJSMethod:@"registerModules" args:@[modules]];
}

@protocol WXResourceRequestHandler <NSObject>

// Send a resource request with a delegate
- (void)sendRequest:(WXResourceRequest *)request withDelegate:(id<WXResourceRequestDelegate>)delegate;

@optional

// Cancel the ongoing request
- (void)cancelRequest:(WXResourceRequest *)request;

@end

//
//	WXResourceRequestHandlerDefaultImpl.m
//

#pragma mark - WXResourceRequestHandler

- (void)sendRequest:(WXResourceRequest *)request withDelegate:(id<WXResourceRequestDelegate>)delegate
{
    if (!_session) {
        NSURLSessionConfiguration *urlSessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
        if ([WXAppConfiguration customizeProtocolClasses].count > 0) {
            NSArray *defaultProtocols = urlSessionConfig.protocolClasses;
            urlSessionConfig.protocolClasses = [[WXAppConfiguration customizeProtocolClasses] arrayByAddingObjectsFromArray:defaultProtocols];
        }
        _session = [NSURLSession sessionWithConfiguration:urlSessionConfig
                                                 delegate:self
                                            delegateQueue:[NSOperationQueue mainQueue]];
        _delegates = [WXThreadSafeMutableDictionary new];
    }
    
    NSURLSessionDataTask *task = [_session dataTaskWithRequest:request];
    request.taskIdentifier = task;
    [_delegates setObject:delegate forKey:task];
    [task resume];
}

- (void)cancelRequest:(WXResourceRequest *)request
{
    if ([request.taskIdentifier isKindOfClass:[NSURLSessionTask class]]) {
        NSURLSessionTask *task = (NSURLSessionTask *)request.taskIdentifier;
        [task cancel];
        [_delegates removeObjectForKey:task];
    }
}

    |-- api：冻结原型链，提供给原生调用的方法，比如 registerModules
    |-- bridge：和客户端相关的接口调用，调用客户端的时候有一个任务调度
    |-- entries：客户端执行 js  framework 的入口文件，WXSDKEngine 调用的方法
    |-- frameworks：核心文件，初始化 js bundle 实例，对实例进行管理，dom 调度转换等
    |-- services：js  service 存放，broadcast 调度转换等
    |-- shared：polyfill  和 console 这些差异性的方法
    |-- vdom：将 VDOM  转化成客户端能渲染的指令

   |-- index.js：入口文件
    |-- legacy：关于 VM 相关的主要方法
    |   |-- api：相关 vm 定义的接口
    |   |-- app：管理页面间页面实例的方法
    |   |-- core：实现数据监听的方法
    |   |-- static：静态方法
    |   |-- util：工具类函数
    |   |-- vm：解析指令相关
    |-- vanilla：与客户端交互的一些方法

// WXSDKEngine
[[WXSDKManager bridgeMgr] executeJsFramework:script];

// WXBridgeManager
- (void)executeJsFramework:(NSString *)script
{
    if (!script) return;
    
    __weak typeof(self) weakSelf = self;
    WXPerformBlockOnBridgeThread(^(){
        [weakSelf.bridgeCtx executeJsFramework:script];
    });
}

// WXBridgeContext
- (void)executeJsFramework:(NSString *)script
{
    WXAssertBridgeThread();
    WXAssertParam(script);
    
    WX_MONITOR_PERF_START(WXPTFrameworkExecute);
    // 真正的执行 js framework
    [self.jsBridge executeJSFramework:script];
    
    WX_MONITOR_PERF_END(WXPTFrameworkExecute);
    
    if ([self.jsBridge exception]) {
        NSString *exception = [[self.jsBridge exception] toString];
        NSMutableString *errMsg = [NSMutableString stringWithFormat:@"[WX_KEY_EXCEPTION_SDK_INIT_JSFM_INIT_FAILED] %@",exception];
        [WXExceptionUtils commitCriticalExceptionRT:@"WX_KEY_EXCEPTION_SDK_INIT" errCode:[NSString stringWithFormat:@"%d", WX_KEY_EXCEPTION_SDK_INIT] function:@"" exception:errMsg extParams:nil];
        WX_MONITOR_FAIL(WXMTJSFramework, WX_ERR_JSFRAMEWORK_EXECUTE, errMsg);
    } else {
        WX_MONITOR_SUCCESS(WXMTJSFramework);
        //the JSFramework has been load successfully.
        // 执行完 js
        self.frameworkLoadFinished = YES;
        
        // 执行缓存在 _jsServiceQueue 中的方法
        [self executeAllJsService];
        
        // 获取 js framework 版本号
        JSValue *frameworkVersion = [self.jsBridge callJSMethod:@"getJSFMVersion" args:nil];
        if (frameworkVersion && [frameworkVersion isString]) {
            [WXAppConfiguration setJSFrameworkVersion:[frameworkVersion toString]];
        }
        
        // 计算 js framework 的字节大小
        if (script) {
             [WXAppConfiguration setJSFrameworkLibSize:[script lengthOfBytesUsingEncoding:NSUTF8StringEncoding]];
        }
        
        //execute methods which has been stored in methodQueue temporarily.
        // 开始执行之前缓存在队列缓存在 _methodQueue 的方法
        for (NSDictionary *method in _methodQueue) {
            [self callJSMethod:method[@"method"] args:method[@"args"]];
        }
        
        [_methodQueue removeAllObjects];
        
        WX_MONITOR_PERF_END(WXPTInitalize);
    };
}

/**
 * Setup frameworks with runtime.
 * You can package more frameworks by
 *  passing them as arguments.
 */
export default function (frameworks) {
  const { init, config } = runtime
  config.frameworks = frameworks
  const { native, transformer } = subversion

  for (const serviceName in services) {
    runtime.service.register(serviceName, services[serviceName])
  }

  runtime.freezePrototype()

  // register framework meta info
  global.frameworkVersion = native
  global.transformerVersion = transformer

  // init frameworks
  const globalMethods = init(config)

  // set global methods
  for (const methodName in globalMethods) {
    global[methodName] = (...args) => {
      const ret = globalMethods[methodName](...args)
      if (ret instanceof Error) {
        console.error(ret.toString())
      }
      return ret
    }
  }
}

// /runtime/frameworks/legacy/static/register.js
export function registerComponents (components) {
  if (Array.isArray(components)) {
    components.forEach(function register (name) {
      /* istanbul ignore if */
      if (!name) {
        return
      }
      if (typeof name === 'string') {
        nativeComponentMap[name] = true
      }
      /* istanbul ignore else */
      else if (typeof name === 'object' && typeof name.type === 'string') {
        nativeComponentMap[name.type] = name
      }
    })
  }
}

创建于客户端通信桥

js framework是客户端和前端业务代码沟通的桥梁，所以更重要的也是bridge，基本的桥的设计上一篇也讲了，Weex选择的是直接提供方法供js调用，也直接调用js的方法。

客户端调用js直接使用callJs，callJs是js提供的方法，放在当前线程中，供客户端调用，包括DOM事件派发、module调用时的时间回调，都是通过这个接口通知js framework，然后再调用缓存在js framework中的方法。

js调用客户端使用callNative，客户端也会提供很多方法给js framework供，framework调用，这些方法都可以在WXBridgeContext中看到，callNative只是其中的一个方法，实际代码中还有很多方法，比如addElement、updateAttrs等等

弥补环境差异

除了用于完成功能的主要方法，客户端还提供一些方法来弥补上层框架在js中调用时没有的方法，就是环境的差异，弥补兼容性的差异，setTimeout、nativeLog等，客户端提供了对应的方法，js framework也无法像在浏览器中调用这些方法一样去调用这些方法，所以需要双方采用兼容性的方式去支持。

还有一些ployfill的方法，比如Promise，Object.assign，这些ployfill能保证一部分环境和浏览器一样，降低我们写代码的成本。

执行完毕

执行js framework其他的过程就不一一展开了，主要是一些前端代码之间的互相调用，这部分也承接了很多Weex历史遗留的一些兼容问题，有时候发现一些神奇的写法，可能是当时为了解决一些神奇的bug吧，以及各种istanbul ignore的注释。

执行完js framework之后客户端frameworkLoadFinished会被置位 YES，之前遗留的任务也都会在js framework执行完毕之后执行，以完成整个初始化的流程。

客户端会先执行js-service，因为js-service只是需要在JavaScript Core中执行字符串，所以直接执行executeAllJsService就行了，并不需要调用js framework的方法，只是让当前内存环境中有js service的变量对象。

然后将_methodQueue中的任务拿出来遍历执行。这里就是执行缓存队列中的registerComponents、registerModules、registerMethods。上面也提到了具体两者是怎么调用的，详细的代码都是在这里。

执行完毕之后，按理说这个js Thread应该关闭，然后被回收，但是我们还需要让这个js framework一直运行在js Core中，所以这个就需要给js Thread开启了一个runloop，让这个js Thread一直处于执行状态

Weex 实例初始化

前面铺垫了非常多的初始化流程，就是为了在将一个页面是如何展示的过程中能清晰一点，前面相当于在做准备工作，这个时候我们来看Weex实例的初始化。Eros 通过配置文件将首页的 URL 配置在配置文件中，客户端能直接拿到首页直接进行初始化。

客户端通过 _renderWithURL去加载首页的URL，这个URL不管是放在本地还是服务器上，其实就是一个js bundle文件，就是一个经过特殊loader打包的js文件，加载到这个文件之后，将这个调用到js framework中的 createInstance。

主要的还是initAPP这个方法，这个方法中做了很多补全原型链的方法，比如bundleDefine、bundleBootstrap等等，这些都挺重要的，大家可以看看 init 方法，就完成了上述的操作。

最主要的还是下面这个方法，这里会是最终执行js bundle的地方。执行完成之后将 Weex的单个页面的实例放在instanceMap，new Function是最核心的方法，这里就是将整个JS bundle由代码到执行生成VDOM，然后转换成一个个VNode发送到原生模块进行渲染。

 const globalObjects = Object.assign({
    define: bundleDefine,
    require: bundleRequire,
    bootstrap: bundleBootstrap,
    register: bundleRegister,
    render: bundleRender,
    __weex_define__: bundleDefine, // alias for define
    __weex_bootstrap__: bundleBootstrap, // alias for bootstrap
    __weex_document__: bundleDocument,
    __weex_require__: bundleRequireModule,
    __weex_viewmodel__: bundleVm,
    weex: weexGlobalObject
  }, timerAPIs, services)

上述这些代码是被执行的核心部分， bundleDefine 部分，这里是解析组件的部分，分析哪些是和Weex对应的Component，哪些是用户自定义的Component，这里就是一个递归遍历的过程。

bundleRequire和bundleBootstrap，这里调用到了 bootstrap和 Vm，这里有一步我不是很明白。bootstrap主要的功能是校验参数和环境信息，这部分大家可以看一下源码。

Vm是根据Component新建对应的ViewModel，这部分做的事情就非常多了，基本上是解析整个VM的核心。主要完成了初始化生命周期、数据双绑、构建模板、UI绘制。

// bind events and lifecycles
  initEvents(this, externalEvents)

  console.debug(`[JS Framework] "init" lifecycle in Vm(${this._type})`)
  this.$emit('hook:init')
  this._inited = true

  // proxy data and methods
  // observe data and add this to vms
  this._data = typeof data === 'function' ? data() : data
  if (mergedData) {
    extend(this._data, mergedData)
  }
  initState(this)

  console.debug(`[JS Framework] "created" lifecycle in Vm(${this._type})`)
  this.$emit('hook:created')
  this._created = true

  // backward old ready entry
  if (options.methods && options.methods.ready) {
    console.warn('"exports.methods.ready" is deprecated, ' +
      'please use "exports.created" instead')
    options.methods.ready.call(this)
  }

  if (!this._app.doc) {
    return
  }

  // if no parentElement then specify the documentElement
  this._parentEl = parentEl || this._app.doc.documentElement
  build(this)

初始化生命周期

代码实现；这个过程中初始化了4个生命周期的钩子，init、created、ready、destroyed。除了生命周期，这里还绑定了vm的事件机制，组件间互相通信的方式。

数据双绑

代码实现；Vue DSL数据双绑可以参考一下Vue的数据双绑实现原理，Rax也是大同小异，将数据进行代理，然后添加数据监听，初始化计算属性，挂载_method方法，创建getter/setter，重写数组的方法，递归绑定...这部分主要是Vue的内容，之前也有博客详细说明了Vue的数据双绑机制。

模板解析

代码实现；这里也是Vue的模板解析机制之一，大部分是对Vue模板语法的解析，比如v-for、:class解析语法的过程是一个深度遍历的过程，这个过程完成之后js bundle就变成了VDOM，这个VDOM更像是符合某种约定格式的JSON数据，因为客户端和js framework可共用的数据类型不多，JSON是最好的方式，所以最终将模板转换成JSON的描述方式传递给客户端。

绘制 Native UI

代码实现；通过differ.flush调用，会触发VDOM 的对比，对比的过程是一个同级对比的过程，将节点也就是VNode逐一diff传递给客户端。先对比外层组件，如果有子节点再递归子节点，对比不同的部分都传递给客户端，首次渲染全是新增，后面更新UI的时候会有用到remove、update等API。

最终绘制调用 appendChild，这里封装了所有和native有交互的方法。DOM操作大致就是addElement、removeElement等方法，调用taskCenter.send，这里是一个任务调度，最终所有的方法都是通过这里调用客户端提供的对应的接口。

send (type, params, args, options) {
    const { action, component, ref, module, method } = params

    // normalize args and options
    args = args.map(arg => this.normalize(arg))
    if (typof(options) === 'Object') {
      options = this.normalize(options, true)
    }

    switch (type) {
      case 'dom':
        return this[action](this.instanceId, args)
      case 'component':
        return this.componentHandler(this.instanceId, ref, method, args, Object.assign({ component }, options))
      default:
        return this.moduleHandler(this.instanceId, module, method, args, options)
    }
  }

调用客户端之后，回顾之前Weex SDK初始化的时候，addElement是已经在客户端注入的方法，然后将对应的Component映射到对应的解析原生方法中。原生再找到对应Component进行渲染。

由于Weex渲染完成父级之后才会渲染子，所以传递的顺序是先传父，再传子，父渲染完成之后，任务调度给一个渲染完成的回调，然后再进行递归，渲染子节点的指令，这样可能会比较慢，上面提到注册Component的时候会有两个参数append=tree和istemplate=true，这两种方式都是优化性能的方案，上面提到在Components注册的时候有这两个参数。

append=tree

BOOL appendTree = !appendingInTree && [component.attributes[@"append"] isEqualToString:@"tree"];
// if ancestor is appending tree, child should not be laid out again even it is appending tree.
for(NSDictionary *subcomponentData in subcomponentsData){
    [self _recursivelyAddComponent:subcomponentData toSupercomponent:component atIndex:-1 appendingInTree:appendTree || appendingInTree];
}

[component _didInserted];

if (appendTree) {
    // If appending tree，force layout in case of too much tasks piling up in syncQueue
    [self _layoutAndSyncUI];
}

Weex的渲染方式有两种一种是node，一种是tree，node是先渲染父节点，再渲染子节点，而tree是先渲染子节点，最后一次性layout渲染父节点。渲染性能上讲，刚开始的绘制时间，append="node"比较快，但是从总的时间来说，append="tree"用的时间更少。

如果当前Component有{@"append":@"tree"}属性并且它的父Component没有这个属性将会强制对页面进行重新布局。可以看到这样做是为了防止UI绘制任务太多堆积在一起影响同步队列任务的执行。

istemplate=true

WXComponentConfig *config = [WXComponentFactory configWithComponentName:type];
BOOL isTemplate = [config.properties[@"isTemplate"] boolValue] || (supercomponent && supercomponent->_isTemplate);
if (isTemplate) {
    bindingProps = [self _extractBindingProps:&attributes];
    bindingStyles = [self _extractBindings:&styles];
    bindingAttibutes = [self _extractBindings:&attributes];
    bindingEvents = [self _extractBindingEvents:&events];
}

那么客户端在渲染的时候，会将整个Component子节点获取过来，然后通过DataBinding转换成表达式，存在bindingMap中，相关的解析都在WXJSASTParser.m文件中，涉及到比较复杂的模板解析，表达式解析和转换，绑定数据与原生UI的关系。

渲染过程中客户端和js framework还有事件的沟通，通过桥传递createFinished和renderFinished事件，js framework会去执行Weex实例对应的生命周期方法。

至此页面就已经渲染出来了，页面渲染完成之后，那么点击事件是怎么做的呢？

事件传递

全局事件

在了解事件如何发生传递之前，我们先看看事件有几种类型，Eros 封装了路由的事件，将这些事件封装在组件上，在Vue模板上提供一个 Eros 对象，在Weex创建实例的时候绑定这些方法注入回调等待客户端回调，客户端在发生对应的事件的手通过全局事件来通知到js framework执行weex实例上的回调方法。

// https://github.com/apache/incubator-weex/blob/master/runtime/frameworks/legacy/vm/compiler.js
if (!vm._rootEl) {
    vm._rootEl = element
    // bind event earlier because of lifecycle issues
    const binding = vm._externalBinding || {}
    const target = binding.template
    const parentVm = binding.parent
    if (target && target.events && parentVm && element) {
      for (const type in target.events) {
        const handler = parentVm[target.events[type]]
        if (handler) {
          element.addEvent(type, bind(handler, parentVm))
        }
      }
    }
  }
  
  // https://github.com/apache/incubator-weex/blob/master/runtime/vdom/Element.js
  addEvent (type, handler, params) {
    if (!this.event) {
      this.event = {}
    }
    if (!this.event[type]) {
      this.event[type] = { handler, params }
      const taskCenter = getTaskCenter(this.docId)
      if (taskCenter) {
        taskCenter.send(
          'dom',
          { action: 'addEvent' },
          [this.ref, type]
        )
      }
    }
  }

上面可以看出只传递了一个ref过去，绑定完毕至所有组件渲染完成之后，当视图发生对应的事件之后，客户端捕获到了事件之后通过fireEvent将对应的事件，传递四个参数，ref、type、event、domChanges，通过bridge将这些参数传递给js framework的bridge，但是到底层的时候还会携带一个Weex实例的ID，因为此时可能存在多个weex实例，通过Weex ID找到对应的weex`实例。

如果事件绑定有多个ref，还需要遍历递归一下，也是一个深度遍历的过程，然后找到对应的事件，触发对应的事件，事件里可能有对双绑数据的改变，进而改变DOM，所以事件触发之后再次进行differ.flush。对比生成新的VDOM，然后渲染新的页面样式。

事件触发

// https://github.com/apache/incubator-weex/blob/master/runtime/frameworks/legacy/app/ctrl/misc.js
export function fireEvent (app, ref, type, e, domChanges) {
  console.debug(`[JS Framework] Fire a "${type}" event on an element(${ref}) in instance(${app.id})`)
  if (Array.isArray(ref)) {
    ref.some((ref) => {
      return fireEvent(app, ref, type, e) !== false
    })
    return
  }
  const el = app.doc.getRef(ref)
  if (el) {
    const result = app.doc.fireEvent(el, type, e, domChanges)
    app.differ.flush()
    app.doc.taskCenter.send('dom', { action: 'updateFinish' }, [])
    return result
  }
  return new Error(`invalid element reference "${ref}"`)
}

app.doc.fireEvent(el, type, e, domChanges)主要来看看这个方法，首先是获取到当时的事件回调，然后执行事件回调，原生的组件不会有事件冒泡，但是 js是有事件冒泡机制的，所以下面模拟了一个事件冒泡机制，继续触发了父级的 fireEvent，逐个冒泡到父级，这部分是在 js framework中完成的。

// https://github.com/apache/incubator-weex/blob/master/runtime/vdom/Element.js
fireEvent (type, event, isBubble, options) {
    let result = null
    let isStopPropagation = false
    const eventDesc = this.event[type]
    if (eventDesc && event) {
      const handler = eventDesc.handler
      event.stopPropagation = () => {
        isStopPropagation = true
      }
      if (options && options.params) {
        result = handler.call(this, ...options.params, event)
      }
      else {
        result = handler.call(this, event)
      }
    }

    if (!isStopPropagation
      && isBubble
      && (BUBBLE_EVENTS.indexOf(type) !== -1)
      && this.parentNode
      && this.parentNode.fireEvent) {
      event.currentTarget = this.parentNode
      this.parentNode.fireEvent(type, event, isBubble) // no options
    }

    return result
  }

上述就完成了一次完整的事件触发，如果是简单的事件，类似click这样的一次传递完成一次事件回调，不会有太大的问题，但是如果是滚动这样的事件传递难免会有性能问题，所以客户端在处理滚动事件的时候，肯定会有一个最小时间间隔，肯定不是无时无刻的触发。

更好的处理是Weex也引入了expression binding，将js的事件回调处理成表达式，在绑定的时候一并传给客户端，由于是表达式，所以客户端也可以识别表达式，客户端在监听原生事件触发的时候，就直接执行表达式。这样就省去了传递的过程。Weex的bingdingX也是可以用来处理类似频繁触发的js和客户端之间的交互的，比如动画。

module 的使用

 const globalObjects = Object.assign({
    ...
    weex: weexGlobalObject
  }, timerAPIs, services)

// https://github.com/apache/incubator-weex/blob/master/runtime/frameworks/legacy/app/ctrl/misc.js
export function callTasks (app, tasks) {
  let result

  /* istanbul ignore next */
  if (typof(tasks) !== 'array') {
    tasks = [tasks]
  }

  tasks.forEach(task => {
    result = app.doc.taskCenter.send(
      'module',
      {
        module: task.module,
        method: task.method
      },
      task.args
    )
  })

  return result
}

完成调用之后就等待客户端处理，客户端处理完成之后进行返回。这里虽然是一个forEach的遍历，但是返回的result都是同步的最后一个result。这里不是很严谨，但是我们看上层结构又不会有问题，tasks传过来一般是一个一个的任务，不会传array过来，并且大部分的客户端调用方法都是异步的，很少有同步回调，所以只能说不严谨。

总结

通过上面的梳理，我们可以看到Weex运行原理的细节，整体流程也梳理清楚了，我们通过一年的实践，不管是纯Weex应用还是现有APP接入都有实践，支撑了我们上百个页面的业务，同时开发效率得到了非常大的提升，也完善了我们基于Vue的前端技术栈。

现在Weex本身也在不断的更新，至少我们的业务上线之后让我们相信Weex是可行的，虽然各种缺点不断的被诟病，但是哪个优秀的技术的没有经历这样的发展呢。摘掉我们前端技术的鄙视链眼镜，让技术更好的为业务服务。

最后我们在通过业务实践和积累之后，也归纳总结出了基于Weex的技术解决方案 Eros并开源出来，解决了被大家所诟病的环境问题，提供更多丰富的Component和Module解决实际的业务问题。目前已有上千开发者有过开发体验，在不断吐槽中改进我们的方案，稳定了底层方案，构建了新的插件化方式，目前已经有开发者贡献了一些插件，也收集到开发者已上线的40+ APP的案例，还有非常多的APP在开发过程中。希望我们的方案能帮助到APP开发中的你。

下面是一些通过 Eros 上线的APP案例