工程代码不简单

本文简述了一些自己对于工程代码的认识

经历了多年的开发之后,有些一开始显得高大上的话题,因为遇到的次数多了,慢慢的也变的平常起来,而平常的事物往往又会给人简单的感觉,于是那些原本高大上的话题,渐渐的也变的"简单"起来…

但很多时候,我们只是熟稔了这些话题的基本概念,所谓的"简单"只是一种错觉罢了,尤其是从工程角度考虑更是如此.

简单举个例子:

Observer Pattern(观察者模式)

刚接触观察者模式(或者说设计模式)的时候,总会让人产生些高大上的感觉,不过见的次数一多,大家也都自然而然的觉得简单起来了,熟悉的朋友甚至都可以随手写份实现:

-- observer_manager.lua
local table = table
local observers = {}
local observer_manager = {}

-- add observer
function observer_manager.add(observer)
    table.insert(observers, observer)
end

-- remove observer
function observer_manager.remove(observer)
    for i = 1, #observers do
        if observers[i] == observer then
            table.remove(observers, i)
            break
        end
    end
end

-- clear observers
function observer_manager.clear()
    observers = {}
end

-- notify observers
function observer_manager.notify(event)
    for i = 1, #observers do
        observers[i].on(event)
    end
end

return observer_manager

简单测试一下,运行的结果也很正确:

local observer_manager = require("observer_manager")

local observer_1 = { on = function(event) print("observer_1 on " .. event) end }
local observer_2 = { on = function(event) print("observer_2 on " .. event) end }

observer_manager.add(observer_1)
observer_manager.add(observer_2)
observer_manager.notify("event_1")

observer_manager.remove(observer_1)
observer_manager.notify("event_2")

observer_manager.clear()
observer_manager.notify("event_3")

observer_manager.add(observer_1)
observer_manager.add(observer_2)
observer_manager.notify("event_4")

--------

// output: 

observer_1 on event_1
observer_2 on event_1
observer_2 on event_2
observer_1 on event_4
observer_2 on event_4

看起来实现观察者模式真的是比较简单,如果工程中需要使用观察者模式的话,是不是我们直接将上述代码添加进项目就可以了呢?

答案是否定的,因为在工程代码中,你不仅仅要实现观察者模式的基本概念,你还要权衡是否需要实现一些观察者模式的衍生概念,另外更多的是,你还要处理好很多实现相关的边界问题.

随便列些问题(以上述的简单实现代码为例):

• 重复的 add observer 怎么处理?
• 重复的 remove observer 怎么处理?
• 如果在 notify 过程中 add observer 怎么处理?
• 如果在 notify 过程中 remove observer 怎么处理?
• notify 过程中,调用 observer 回调的顺序是否需要定义?
• observer 是否需要调整自己的回调顺序?
• 如果需要, observer 怎样调整自己的回调顺序?
• 如果需要, observer 的回调顺序调整机制应该如何实现?
• observer 的回调中出现错误怎么处理?
• observer 的回调中出现超时怎么处理?
• …

看到这里,我想你应该不会觉得在工程中实现一个观察者模式是件简单的事情了…

总结

很多话题的核心概念并不复杂,简单的代码实现也并不困难,但是要在工程项目中进行实现则是另外一回事了,问题在于在工程项目中,你不仅仅要实现基本概念,还要权衡实现衍生概念,另外更多的你还要处理好很多实现相关的边界问题.

总的来说,工程代码不简单,这也是我们需要保持 KISS 的原因之一.