【步兵 lua】事件模型和事件解耦

【步兵 lua】事件模型和事件解耦 By EOS.

因为大多数程序是单线程，如果想处理外部事件，都离不开消息循环，

而事件模型和消息循环是天生一对，先了解下事件模式~

事件模型的特点

(1)可动态增加减少接收者

(2)可动态调整接收优先级

(3)每个接收对象都有机会响应事件，每个事件可由多个对象同时处理

(4)对于处理不了的事件，接收对象可以不做处理

(5)对于已经处理的事件，接收对象可以选择停止派发，也可以选择继续派发

对应关系：

(1)addListener

(2)changeListenerPriority

(3)addEvent、addListener、broadcast

(4)recvFunc 随意处理接受到的事件

(5)recvFunc – return def.event.ret_break 中断此消息的广播

源码

--Event.lua
Event = class("Event")
function Event:init(name, args)
self.name = name
self.args = args
end

EventListener = class("EventListener")
function EventListener:init(name, recvFunc, priority)
self.name = name
self.recv = recvFunc
self.priority = priority or 0
end

--EventDispatcher.lua
EventDispatcher = class("EventDispatcher")
local cls = EventDispatcher

local EventListener = {
name = "error",
priority = 0,
excute = function (event)

end,
}

function cls:init()
self._listeners = {}
self._indexs = {}
self._prioritys = {}
self._events = {}
self._maskEvents = {}
end

function cls:addEvent(event)
self._events[event] = true
end

function cls:maskEvent(eventName)
self._maskEvents[eventName] = true
end
function cls:cancelMaskEvent(event)
self._maskEvents[eventName] = nil
end
function cls:cancelAllMaskEvent()
self._maskEvents = {}
end

function cls:addListener(listener)
local name = listener.name
local priority = listener.priority or 0

local _listeners = self._listeners
local _indexs = self._indexs
local _prioritys = self._prioritys

_listeners[name] = _listeners[name] or {}
_listeners[name][priority] = _listeners[name][priority] or {}
_indexs[name] = _indexs[name] or {}
_indexs[name][priority] = _indexs[name][priority] or 0
_prioritys[name] = _prioritys[name] or {}

local l_list = _listeners[name][priority]
_indexs[name][priority] = _indexs[name][priority] + 1
local index = _indexs[name][priority]
l_list[index] = listener

if not table.find(_prioritys[name], priority) then
table.insert(_prioritys[name], priority)
table.sort(_prioritys[name], function (a, b)
return a > b
end)
end

return name.."_"..priority.."_"..index
end

function cls:removeListener(id)
local tags = string.split(id, "_")
local name = tags[1]
local priority = tonumber(tags[2])
local index = tonumber(tags[3])

local _listeners = self._listeners
if _listeners[name] and _listeners[name][priority] then
_listeners[name][priority][index] = nil
end
end

function cls:changeListenerPriority(id, newPriority)
local tags = string.split(id, "_")
local name = tags[1]
local priority = tonumber(tags[2])
local index = tonumber(tags[3])

local _listeners = self._listeners
if _listeners[name] and _listeners[name][priority] then
local listener = _listeners[name][priority][index]
_listeners[name][priority][index] = nil
listener.priority = newPriority
self:addListener(listener)
end
end

function cls:clear()
self._listeners = {}
self._indexs = {}
self._prioritys = {}
end

function cls:broadcast()
print("broadcast event:")
for event,_ in pairs(self._events) do
if not self._maskEvents[event.name] then
table.dump(event)

local _listeners = self._listeners
local _prioritys = self._prioritys
local name = event.name
local listeners = _listeners[name]

if listeners then
for i=1, #_prioritys[name] do
local priority = _prioritys[name][i]
for k,v in pairs(listeners[priority]) do
local ret = v.recv(event.args)
if ret == def.event.ret_break then
return
end
end
end
end
end
end
end

测试代码：

local dispatcher = EventDispatcher.new()
local event = Event.new(def.event.TestOne, {tab = "this is event One"})

local listener = EventListener.new(def.event.TestOne, function(evt)
print("recv: "..evt.tab)
end, 1)

local listener2 = EventListener.new(def.event.TestOne, function(evt)
print("recv_2: "..evt.tab)
-- return def.event.ret_break
end, 2)

local lsr_id = dispatcher:addListener(listener)
local lsr_id_2 = dispatcher:addListener(listener2)

dispatcher:addEvent(event)

-- dispatcher:maskEvent(def.event.TestOne)
-- dispatcher:cancelAllMaskEvent()
-- dispatcher:removeListener(lsr_id_2)
-- dispatcher:changeListenerPriority(lsr_id_2, 0)
-- print(listener2.priority)
dispatcher:broadcast()
end

为什么说事件可以解耦

正因为是单线程所以程序是顺序执行的。而事件系统却可以使其分离，实现模块化。

下面简单举个例子：

比如使用量个道具，人物升级了，刷新对应显示人物等级的地方。

方式一：

bag[useItem -> player[expAdd-> levelUp] -> ui_1[fresh] -> ...ui_n[fresh] -> end]

这样我使用一个道具的流程如果想结束。就必须背负着 人物属性相关模块

以及N个属性显示相关的模块，可能引发的问题就是，别人其中一个界面出了问题，

会导致我的模块报错，而我处理并没有任何问题，这就是耦合了。

方式二：

player[addListener(AddExp)]
ui_1[addListener(LevelUp)]
...
ui_n[addListener(LevelUp)]

bag[useItem -> addEvent(AddExp) -> end]
player[recv(AddExp) -> addEvent(LevelUp)]
ui_1[recv(LevelUp)]
...
ui_n[recv(LevelUp)]

效果是不是一目了然，各个模块都清晰的分离开了。这就是解耦~

因为我们用事件模式，“延迟调用”的方式（先添加，不处理），才得以实现。

总结

实现了一个独立的事件模型，但还有值得优化的地方。

我认为事件模型能解偶，主要在于延迟调用，如果即时调用的那发送事件是没意义的。

无非就是a->b->end变为了 a->c->b->end而已。

当然，事件过多的应用，可能会是逻辑过于分散，不容易调试。

不过只要规划好事件名就可以了，因为事件名就是这些逻辑的主心骨~ =、=

See Again~

之前

真爱无价，欢迎打赏~