[关闭]
@zyl06 2019-01-21T12:47:40.000000Z 字数 9799 阅读 1086

ColorTouch class 机制

Lua 动态化

0 类的定义

  1. module("PublicCameraViewController", package.seeall)
  3. local BaseViewController = require "Base.BaseViewController"
  4. local screenWidth = getApplication():getViewportWidth()
  6. require "PublicCamera.PopMenuMixin"
  7. ....
  9. PublicCameraViewController = Class.Class("PublicCameraViewController",
  10.         {
  11.             base = BaseViewController,
  12.             properties={
  13.                 deviceId = Class.undefined,
  14.                 model = Class.undefined,
  16.                 rightImagePath = "app://icon_more.png",
  17.                 bShowNaviBar = true,
  18.                 bShowBackBtn = true,                                      
  19.                 ......                            
  20.                 --判断摄像头是否失效
  21.                 isPublicCameraValid = true,
  22.             },
  23.         },
  24.         mixins = {   
  25.             popMenu = PopMenuMixin,                                     
  26.             .....
  27.         }
  28. })
  31. function PublicCameraViewController.prototype:init(inlineprops, ...)
  32.    BaseViewController.prototype.init(self, inlineprops, ...)
  33.    ...
  34.    self:addEventListener("popped",
  35.             function()
  36.                 self._isDataInited = false
  37.                 self._groupDisposable.dispose()
  38.         end)
  40.    self:addEventListener("resumed",function()
  41.         self:hideInputMethod(nil)
  42.         if not self._isLoaded then
  43.           self:showLoading()
  44.         end
  45.         self:initData()
  46.         self:queryForCommentTotalCount()
  47.     end)
  48. end
  50. -- override
  51. function PublicCameraViewController.prototype:rightBtnEvent()
  52.     self:showPopMenu(self)
  53. end
  1. 定义类 PublicCameraViewController
  2. 基类由 base 属性指定 BaseViewController，表示是一个 VC / Activity
  3. 由 properties 设置基类属性 bShowBackBtn 等和自定义属性 isPublicCameraValid 等
  4. 由 mixins 设置模块类（category）
  5. 定义类初始化接口 init
  6. 定义类的自定义方法 rightBtnEvent

1 类实例的创建和使用

  1. require "PublicCamera.PublicCameraViewController"
  2. local nextVC = PublicCameraViewController.PublicCameraViewController{
  3.     deviceId = self._cellDto.deviceId,
  4.     enterPublicTime = os.date(os.time()),
  5. }
  6. vc:pushViewController(nextVC, true)
  1. 引入 module，并创建实例 nextVC
  2. 打开 VC/Activity

2 类机制的简单介绍

2.1 类创建

  1. -- Class.lua
  2. Class = function(name, config)
  3.    if name == nil then
  4.       name = "Anonymous" .. nameId
  5.       nameId = nameId + 1
  6.    end
  8.    return MetaClass(name, config)
  9. end

可见 Class.Class("PublicCameraViewController", {...}) 是一个方法调用

  1. -- Class.lua
  2. MetaClass = {}
  3. MetaClass.className = "MetaClass"
  4. MetaClass.prototype = MetaClassProto
  5. MetaClassProto.constructor = MetaClass
  7. -- MetaClass继承自Object
  8. MetaClass.superclass = Object
  9. setmetatableAndCopyMetaMethods(MetaClassProto, Object.prototype)
  11. -- MetaClass' class is MetaClass
  12. MetaClass.class = MetaClass
  13. setmetatable(MetaClass, MetaClassProto)
  1. 创建 MetaClass table，并且设置 MetaClassProto 为 MetaClass.prototype
  2. 设置 MetaClassProto 为 MetaClass 的 metatable
  3. MetaClassProto.__call 被定义，所以当调用 MetaClass(name, config) 时，会调用到 MetaClass metatable （即 MetaClassProto） 的 __call 方法
  1. MetaClassProto.__call = function(self, name, config)
  2.    config = config and config or {}
  3.    local base = config.base and config.base  or Object
  4.    local properties = config.properties and config.properties or {}
  5.    local mixins = config.mixins and config.mixins or {}
  6.    local statics = config.statics
  7.    local methods = config.methods
  9.    logClassStyle("create class, base:%s", base:address())
  11.    local newCls, newClsProto = createClass(base, name)
  12.    logClassStyle("newed class:%s, classproto:%s", newCls:address(), newCls.prototype:address())
  13.    newCls.className = name
  15.    --process mixins
  16.    processMixins(newCls, mixins)
  18.    --process properties
  19.    processClassProperties(newCls, properties)
  21.    --process methods
  22.    processMethods(newCls, methods)
  24.    --process static methods
  25.    processStaticMethods(newCls, statics)
  27.    return newCls
  28. end
  1. function createClass(base, clsName)
  2.    --construct new class
  3.    local newClsProto = {}
  4.    local newCls = {}
  5.    newClsProto.constructor = newCls
  6.    newCls.prototype = newClsProto
  7.    newClsProto.__index = newClsProto
  9.    --derive from base
  10.    newCls.superclass = base
  11.    setmetatableAndCopyMetaMethods(newClsProto, base.prototype)
  13.    --metaclass
  14.    local newMetacls = {}
  15.    local newMetaclsProto = {}
  16.    newMetacls.className = "Meta" ..  clsName
  17.    newMetacls.prototype = newMetaclsProto
  18.    newMetaclsProto.constructor = newMetacls
  19.    newMetaclsProto.__index = newMetaclsProto
  21.    --newcls需要构造函数，这在lua中必须设置其metacls protype的__call字段
  22.    newMetaclsProto.__call = base.class.prototype.__call
  24.    --metaclass is derive from base's metaclass
  25.    newMetacls.superclass = base.class
  26.    setmetatableAndCopyMetaMethods(newMetaclsProto, base.class.prototype)
  28.    --newmetaclass's class is metaclass
  29.    newMetacls.class = MetaClass
  30.    setmetatable(newMetacls, MetaClass.prototype)
  32.    newCls.class = newMetacls
  33.    setmetatable(newCls, newMetaclsProto)
  35.    return newCls, newClsProto
  36. end
  1. 创建 newCls，newClsProto 对象，其中 newCls 的 metatable 为 newMetaclsProto，newMetaclsProto 的 __call 属性为 base.class.prototype.__call。由此在创建 newCls 的实例时，会调用基类 prototype.__call 方法，进而实现基类的各个属性的初始化

  2. setmetatableAndCopyMetaMethods(newMetaclsProto, base.class.prototype) 设置基类 prototype 为 newMetaclsProto 的 metatable，为此 newCls 继承了基类 base.class.prototype 中的全部属性

    • 当取 newCls 的属性 a，在 newCls 中查找，找到则返回
    • 找不到，则查找 newMetaclsProto.__index table（也就是 newMetaclsProto 自己），找到则返回
    • 找不到，则查找 base.class.prototype.__index 中的属性，根据递归特性，__index 就是 base.class.prototype 自身，即在 base.class.prototype 查找属性
    • 一层层查找 super class prototype 中的属性，直到找到

2.2 初始化 mixin

  1. --processMixins(newCls, mixins)
  3. function processMixins(cls, mixins)
  4.    --1. collection all mixins
  5.    local superCls = cls.superclass
  6.    local allmixins = table.shallowcopy(mixins)
  8.    while superCls do
  9.       if superCls.__mixins then
  10.          for k, v in pairs(superCls.__mixins) do
  11.             if allmixins[k] == nil then
  12.                allmixins[k] = v
  13.             end
  14.          end
  15.       end
  17.       superCls = superCls.superclass
  18.    end
  20.    --2. 将mixins中所有导出的方法平坦到cls.prototype中，superclass的mixins不需要平坦
  21.    table.each(allmixins, 
  22.               function(mixin, name)
  23.                  local methods = mixin:methods()
  24.                  table.each(methods,
  25.                             function(method)
  26.                                cls.prototype[method] = function(obj, ...)
  27.                                   local mixin = obj.mixins[name]
  28.                                   return mixin[method](mixin, ...)
  29.                                end
  30.                  end)
  31.    end)
  33.    cls.__mixins = allmixins
  34. end
  1. 将 cls 自身和全部基类的 mixins 收集到 allmixins
  2. 将 allmixnins 中的方法设置给 cls.prototype
    • 即当 cls 调用一个 mixin 方法时，自身找不到，则查找 metatable __index table（即 prototype）中的属性，则查找到前面的 prototype 中设置的 mixin method 属性中指定的方法，即可调用
  1. -- PopMenuMixin.lua
  2. PopMenuMixin = Class.Class("PopMenuMixin",
  3.                     {
  4.                         base = Mixin,
  5.                         properties = {
  6.                             vc = Class.undefined,
  7.                             popMenu = Class.undefined,
  8.                             preVC = Class.undefined,
  9.                         },
  11.                         statics = {
  12.                             methods = function ()
  13.                                 return {"showPopMenu",}
  14.                             end
  15.                         }
  16.                     }
  17. )
  19. function PopMenuMixin.prototype:init(owner)
  20.     Mixin.prototype.init(self, owner)
  21. end
  23. --显示菜单
  24. function PopMenuMixin.prototype:showPopMenu(vc)
  25.     ...
  26. end

如前面设置的 mixin PopMenuMixin，则提供给 PublicCameraViewController 的方法为 showPopMenu。

  1. -- Mixin.lua
  2. Mixin = Class.Class("Mixin",
  3.     {
  4.         properties={
  5.           owner=Class.undefined,
  6.         },
  7.         methods={
  8.             init=function(self, owner)
  9.                 self:setOwner(owner)
  10.             end
  11.         },
  13.         statics={
  14.             methods=function(self)
  15.                 return {}
  16.             end
  17.         }
  18.     })

当 PopMenuMixin init 方法调用的时候，将 PublicCameraViewController 设置为 PopMenuMixin 的 owner 属性
由此构建 PublicCameraViewController 和 PopMenuMixin 之间的关系：PublicCameraViewController 可以调用 PopMenuMixin 暴露的 methods 方法，PopMenuMixin 可以通过 getOwner() 获取 PublicCameraViewController 对象。

2.3 初始化属性（对象创建传入的属性，class 中定义的属性）

  1. -- Class.lua
  2. -- processClassProperties(newCls, properties)
  3. local processClassProperties = function(cls, props)
  4. --   logClassStyle("process properties:%s", table.tostring(props))
  6.    local propertyMaps = {}
  7.    for k, v in pairs(props) do
  8.       propertyMaps[k] = {
  9.          propName = k,
  10.          realPropName = NameMap[k][1],--"_" .. k,
  11.          getterName = NameMap[k][2],--string.getterName(k),
  12.          setterName = NameMap[k][3],--string.setterName(k),
  13.          changedEvtName = NameMap[k][4],--string.propChangeEvtName(k),
  14.          applyName = NameMap[k][5],--string.applyName(k),
  15.          initV = v,
  16.          needCopy = getmetatable(v) == nil and type(v) == 'table',
  17.       }
  18.    end
  20.     -- 1. 将构建对象时，自定义的属性设置给 props 设置给 cls 实例（self）的 initProperties，同时构建 get 和 set 方法。
  21.     -- 2. 将 class 定义时的属性设置给 initProperties，遍历全部的 super class 的属性同样设置给 initProperties
  22. end

2.4 初始化普通方法

  1. -- Class.lua
  2. -- processMethods(newCls, methods)
  3. function processMethods(cls, methods)
  4.    local proto = cls.prototype
  5.    if methods then
  6.       for key, v in pairs(methods) do
  7.          proto[key] = v
  8.       end
  9.    end
  10. end
  1. 将初始化变量中的方法，设置到 cls.prototype 中

2.5 初始化静态方法

  1. -- Class.lua
  2. -- processStaticMethods(newCls, statics)
  3. function processStaticMethods(cls, methods)
  4.    local metacls = cls.class.prototype
  5.    if not methods then 
  6.       return
  7.    end
  9.    for k, v in pairs(methods) do
  10.       metacls[k] = v
  11.    end
  12. end

  1. 将类定义中的 static 属性中定义的方法直接设置到 cls.class.prototype 中，根据前面 createClass 方法，其实最终也是设置到 newMetaclsProto 中

    1. function createClass(base, clsName)
    2.     ...
    4.     newMetacls.prototype = newMetaclsProto
    5.     newMetaclsProto.constructor = newMetacls
    6.     newMetaclsProto.__index = newMetaclsProto
    8.     newMetacls.prototype = newMetaclsProto
    9.     setmetatable(newMetacls, MetaClass.prototype)
    10.     ...
    11.     newCls.class = newMetacls
    12.     ...
    14.     return newCls, newClsProto
    15. end

3 类实例创建

前面讲述了 类定义和创建，那类对象是如何创建的，相关 init 方法等何时被调用呢？

  1. require "PublicCamera.PublicCameraViewController"
  2. local nextVC = PublicCameraViewController.PublicCameraViewController{
  3.     deviceId = self._cellDto.deviceId,
  4.     enterPublicTime = os.date(os.time()),
  5. }

nextVC 对象是如何被创建的？

查看 createClass 方法：

  1. --Class.lua
  2. function createClass(base,clsName)
  3.    --construct new class
  4.    ...
  5.    local newMetaclsProto = {}
  6.    ...
  7.    newMetaclsProto.__index = newMetaclsProto
  9.    --newcls需要构造函数，这在lua中必须设置其metacls protype的__call字段
  10.    newMetaclsProto.__call = base.class.prototype.__call
  12.    ...
  13.    setmetatableAndCopyMetaMethods(newMetaclsProto, base.class.prototype)
  15.    ...
  16.    setmetatable(newCls, newMetaclsProto)
  18.    return newCls, newClsProto
  19. end
  1. 调用 PublicCameraViewController.PublicCameraViewController(...) 时，则会查找 newCls 实例 metatable 中的 __call 方法，即 newMetaclsProto.__call 方法，即 base.class.prototype.__call
  2. base 的最终基类是 Object，Object.MetaObject 是 MetaObject，MetaObject 的 prototype 为 MetaObjectProto， MetaObjectProto.__call 方法已经被定义
  1. --All Class's base class
  2. Object = {}
  3. Object.prototype = ObjectProto
  4. ObjectProto.constructor = Object
  5. Object.className = "Object"
  7. --MetaObjectProto
  8. MetaObjectProto = {}
  9. MetaObjectProto.__index = MetaObjectProto
  11. ...
  13. --MetaObject
  14. MetaObject = {}
  15. MetaObject.className = "MetaObject"
  16. MetaObject.prototype = MetaObjectProto
  17. MetaObjectProto.constructor = MetaObject
  19. Object.class = MetaObject
  20. setmetatable(Object, MetaObjectProto)
  22. --MetaObject继承自Object
  23. setmetatableAndCopyMetaMethods(MetaObjectProto, ObjectProto)
  24. MetaObject.superclass = Object
  27. --MetametaClass
  28. MetaClassProto = {}
  29. MetaClassProto.__index = MetaClassProto
  1. MetaObjectProto.__call = function(cls, ...)
  2.     -- 1. 创建实例
  3.    local self = setmetatable({}, cls.prototype)
  5.    -- 2. 设置对象的类属性
  6.    self.class = cls
  8.    -- 3. 将类的 minixs 属性给 对象
  9.    initMixins(self, cls)
  11.    self.isIniting = yesF
  12.    self.isBeforeInit = yesF
  14.     -- 4. 如果有自定义初始化方法，则执行自定义方法，若无则执行默认初始化方法 processInitializedProperties
  15.    if cls.processInitProperties then
  16.       cls.processInitProperties(cls, self)
  17.    else
  18.       processInitializedProperties(cls, self)
  19.    end
  21.    self.isBeforeInit = notF
  23.    -- 5. 执行 init 方法
  24.    if cls.init then
  25.         self:init(...)
  26.    end
  28.    self.isIniting = notF
  30.    return self
  31. end
  1. local processInitializedProperties = function(cls, obj)
  2.    local initProperties = nil
  4.    if not cls.initProperties then return end
  6.    for i, propMap in pairs(cls.initProperties) do
  7.       local val = propMap.initV
  8.       if val ~= undefined then 
  9.          if propMap.needCopy then
  10.             local newVal = {}
  11.             for key, v in pairs(val) do
  12.                newVal[key] = v
  13.             end
  15.             doSetter(obj, propMap.setterName, newVal)
  16.             --obj[propMap.setterName](obj, newVal)
  17.          else
  18.             doSetter(obj, propMap.setterName, val)
  19. --            obj[propMap.setterName](obj, val)
  20.          end
  21.       end
  22.    end
  23. end
  1. 将 cls 中的属性值 set 给对象，并触发 setXXX 方法，同时触发 onXXXChanged 方法，部分属性触发 native 方法执行
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注