Lua middleclass 详解

A simple OOP library for Lua. It has inheritance, metamethods (operators), class variables and weak mixin support.
https://github.com/kikito/middleclass

函数功能解析

1. _createClasss(aClass, super)

返回默认的表

  local dict = {}
  dict.__index = dict

  local aClass = { name = name, super = super, static = {},
                   __instanceDict = dict, __declaredMethods = {},
                   subclasses = setmetatable({}, {__mode='k'})  }

创建一个table，包含下列属性：

• name 类名
• super 父类的table
• static 静态表
• __instanceDict 存放类定义的属性和函数(包含父类)
• __decaredMethod （当前类声明的方法，不包含父类）
• subclasses 子类表， 使用弱引用

 if super then
    setmetatable(aClass.static, { __index = function(_,k) return rawget(dict,k) or super.static[k] end })
  else
    setmetatable(aClass.static, { __index = function(_,k) return rawget(dict,k) end })
  end

设置static表的元表为 __index = __instanceDict（或者super.static）

 setmetatable(aClass, { __index = aClass.static, __tostring = _tostring, 
 __call = _call, __newindex = _declareInstanceMethod }) 

设置类的元表：__index 为 static, __tostring => 默认tostring，
_call =>调用static.new(), __newindex => _declareInstanceMethod

2. _includeMixin(aClass, mixin)

将一张表合并到另一张表中

  for name,method in pairs(mixin) do
    if name ~= "included" and name ~= "static" then aClass[name] = method end
  end

• 除了"included"和"static",将mixin中的域全部赋值到aClass中(覆盖)

  for name,method in pairs(mixin.static or {}) do
    aClass.static[name] = method
  end

• 将mixin.static中的域,赋值到aClass.static中

  if type(mixin.included)=="function" then mixin:included(aClass) end

• 如果mixin包含included方法,则调用mixin的included方法,参数为aClass

3. DefaultMixin

** 默认合并表,创建类时自动添加到类中**
提供如下方法:

• __tostring 默认tostring方法
• initialize 初始化方法 类似于构造函数

 isInstanceOf = function(self, aClass)
    return type(aClass) == 'table' and (aClass == self.class or self.class:isSubclassOf(aClass))
  end,

• isInstanceOf 判断是否是某个类的实例

为static添加方法:

allocate = function(self)
      assert(type(self) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
      return setmetatable({ class = self }, self.__instanceDict)
    end,

• allocate 创建一个实例表
  • 添加class属性,指向类表
  • 将类表的__instanceDict设置为元表

new = function(self, ...)
      assert(type(self) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
      local instance = self:allocate()
      instance:initialize(...)
      return instance
    end,

• new 通过allocate创建表,并调用initialize方法

• subclassed 创建子类后的回调

 subclass = function(self, name)
      assert(type(self) == 'table', "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'")
      assert(type(name) == "string", "You must provide a name(string) for your class")

      local subclass = _createClass(name, self)

      for methodName, f in pairs(self.__instanceDict) do
        _propagateInstanceMethod(subclass, methodName, f)
      end
      subclass.initialize = function(instance, ...) return self.initialize(instance, ...) end

      self.subclasses[subclass] = true
      self:subclassed(subclass)

      return subclass
    end,

• subclass 为类添加一个指定名字的子类,并返回子类
  • 创建指定名字的类,父类为自己
  • 将父类的__instanceDict中的所有域,复制到子类中
  • 子类的initialize 默认调用父类的initialize
  • 在自己的subclass索引中,添加子类的索引
  • 调用自己的subclassed方法,参数为子类

 isSubclassOf = function(self, other)
      return type(other)      == 'table' and
             type(self.super) == 'table' and
             ( self.super == other or self.super:isSubclassOf(other) )
    end,

• isSubclassOf 是否是指定类的子类

  include = function(self, ...)
      assert(type(self) == 'table', "Make sure you that you are using 'Class:include' instead of 'Class.include'")
      for _,mixin in ipairs({...}) do _includeMixin(self, mixin) end
      return self
    end

• include 将参数合并到本类中

4. _declareInstanceMethod(aClass, name, f)

在类中添加声明方法和属性

local function _declareInstanceMethod(aClass, name, f)
  aClass.__declaredMethods[name] = f

  if f == nil and aClass.super then
    f = aClass.super.__instanceDict[name]
  end

  _propagateInstanceMethod(aClass, name, f)
end

• 注册到__declaredMethods
• 如果f为nil,则去父类取该字段
• 将域添加到子类中

5. _propagateInstanceMethod(aClass, name, f)

添加域到表中,并添加到所有的子类中,相当于继承

local function _propagateInstanceMethod(aClass, name, f)
  f = name == "__index" and _createIndexWrapper(aClass, f) or f
  aClass.__instanceDict[name] = f

  for subclass in pairs(aClass.subclasses) do
    if rawget(subclass.__declaredMethods, name) == nil then
      _propagateInstanceMethod(subclass, name, f)
    end
  end
end

• 如果name = __index, 调用_createIndexWrapper
• 将f添加到aClass.__instanceDict[name]中
• 遍历所有子类,如果子类不包含该方法,则添加到子类中(若包含,相当于重写)

6. _createIndexWrapper(aClass, f)

对__index处理

local function _createIndexWrapper(aClass, f)
  if f == nil then
    return aClass.__instanceDict
  else
    return function(self, name)
      local value = aClass.__instanceDict[name]

      if value ~= nil then
        return value
      elseif type(f) == "function" then
        return (f(self, name))
      else
        return f[name]
      end
    end
  end
end

• f为空,则返回aClass.__instanceDict
• 如果__instanceDict包含name 则返回 <==> __index = __instanceDict
• 如果f为函数, __index = f(self,name)
• 否则,返回f[name]

7. _call(self, ...)

调用new方法,使A:new() <==> A()

8. _tostring(self)

** 默认tostring方法**

9. middleclass.class(name, super)

创建一个类,并设置父类

• 如果super ~= nil 则调用subclass, 将那么添加到super的子类中
• 否则,创建一张默认表,并将DefaultMixin合并进去

实例解析

Metamethods

不需设置metatable的元方法,直接在当前类中定义,即可实现原方法。
以tostring为例:

Point = class('Point')
function Point:initialize(x,y)
  self.x = x
  self.y = y
end
function Point:__tostring()
  return 'Point: [' .. tostring(self.x) .. ', ' .. tostring(self.y) .. ']'
end

p1 = Point(100, 200)
p2 = Point(35, -10)
print(p1)
print(p2)

Output:
Point: [100, 200]
Point: [35, -10]

1. p1(实例)的__index为__instanceDict,所以调用tostring时,会去__instanceDict中去查找
2. Pointer的__newindex为_declareInstanceMethod,在类中定义__tostring时,_declareInstanceMethod会将该方法加入到__instanceDict中
3. 重写__tostring,相当于在自己的元表中定义该方法
4. 其他元方法类似

Middleclass 4.x supports all the Lua metamethods. There are some restrictions:

• Overriding the metatable metamethod is possible, but likely will give you trouble. Do this only if you know what you are doing.
• Metamethods not supported by the Lua version being used are not supported. For example, the len metamethod does not work in Lua 5.1 or LuaJIT without 5.2 compatibility.

mixins

类变量提供include方法,可以将一个table的域拷贝到另一个table中,被拷贝的table会触发included方法

1. class.static表中提供include方法
2. class的__index指向class.static
3. 被合并的table 调用include方法

Private stuff

在类内定义局部变量,或者局部函数,外部不可访问

lua的作用于限制

其他

class = require("middleclass")
A = class("A")
A.n = 1
B = A()
print(B.n)
B.n = 2
print(B.n)
print(A.n)

Output:
1
2
1

B是A的实例,B继承了n(B中没有n属性,则去__instanceDict中取)
当B对n赋值,则相当于在B表中添加属性,不会改变__instanceDict的值,再次获取该属性时,直接从B表中读,所以值为2,且不会改变A中的值

middleclass使用的表的简单总结

1. __instanceDict 记录当前类,以及所有父类定义的实例方法(属性), __index指向自己
2. __declaredMethods 记录当前类声明的方法(属性)
3. subclasses 当前类的所有子类,弱引用
4. static 静态表,定义new, include, isSubclassOf等方法,__index指向__instanceDict。
   实例变量不能直接访问static表,必须通过.class.static访问。
   类的静态方法可以通过class.static:func 来定义
5. 类的默认表 定义__instanceDict,__declaredMethods, static等属性。
   __index指向static表,可以直接使用static中的字段(A:new())。
   __newIndex为_declareInstanceMethod方法,添加字段时会更新__instanceDict以及__declareMethods
6. 实例表 定义class属性,指向当前的类。 metatable为对应类的__instanceDict