AOP programming paradiag

AOP

https://en.wikipedia.org/wiki/Aspect-oriented_programming

Typically, an aspect is scattered or tangled as code, making it harder to understand and maintain. It is scattered by virtue of the function (such as logging) being spread over a number of unrelated functions that might use its function, possibly in entirely unrelated systems, different source languages, etc. That means to change logging can require modifying all affected modules. Aspects become tangled not only with the mainline function of the systems in which they are expressed but also with each other. That means changing one concern entails understanding all the tangled concerns or having some means by which the effect of changes can be inferred.

 

Logging exemplifies a crosscutting concern because a logging strategy necessarily affects every logged part of the system. Logging thereby crosscuts all logged classes and methods.

 

http://www.cnblogs.com/beliefbetrayal/archive/2012/02/03/2337522.html

　　AOP（Aspect-Oriented Programming，面向切面的編程），它是能夠經過預編譯方式和運行期動態代理實如今不修改源代碼的狀況下給程序動態統一添加功能的一種技術。它是一種新的方法論，它是對傳統OOP編程的一種補充。

　　OOP是關注將需求功能劃分爲不一樣的而且相對獨立，封裝良好的類，並讓它們有着屬於本身的行爲，依靠繼承和多態等來定義彼此的關係；AOP是但願可以將通用需求功能從不相關的類當中分離出來，可以使得不少類共享一個行爲，一旦發生變化，沒必要修改不少類，而只須要修改這個行爲便可。

 

Lua AOP

http://lua.2524044.n2.nabble.com/Question-about-AOP-like-function-calls-interception-td7651107.html

The reason why I'm asking is to see how something like AOP (Aspect Oriented Programming) approach could be applied to Lua. For example, I'd like to be able to execute a custom code before or after a call, manipulate call arguments and results, etc. And I'd like to be able to specify what I want to intercept (e.g. using patterns like this: "all calls of functions that look like set* or libname.*") outside of the code, where interception is supposed to be applied. That is the source code should not be aware of interception if possible. Normally it is achieved by means of interception or instrumentation in most languages. I'm wondering how and if this can be done in Lua. 

 

local _print = print

print = function( … )
  -- before...
  _print( … )
  -- after...
end

 

http://lua-users.org/lists/lua-l/2011-01/msg00187.html

as many things OO, most 'fun' things in aspects are trivial to do in
functional programming:

for example, it's common to enhance the built-on type() function:

do
  local oldtype = type
  function type(x)
    local mt = getmetatable(x)
    if mt and mt.__type then return mt.__type end
    return oldtype(x)
  end
end

or you could do some 'prepend' functions:

function prepend(f,pre)
  return function(...)
    return pre(f,...)
  end
end


and use like this:

type = prepend (type, function(old, x)
  local mt = getmetatable(x)
  if mt and mt.__type then return mt.__type end
  return old(x)
end

 

AOP lua庫

http://luaforge.net/projects/aspectlua/

AspectLua is an extension of Lua for Aspect-Oriented Programming. It follows some concepts of AspectJ, and enables the creation of Aspects for modularize crosscutting concerns in objects written in pure Lua.

 

以下： 對account 的 deposit方法進行跟蹤， 調用完後， 進行打印。

dofile("AspectLua.lua")

account = luaorb.createproxy(readIOR("account.ref"),"IDL:Account:1.0")
account:deposit(5)

function logfile(a)
    print("o valor depositado e",a)
end

asp = Aspect:new("aspect.ref")
asp:aspect({name = 'AccountLogging'} , {name = 'tracingMethods', designator = 'call', list = {'bank_impl.deposit'}}, {type ='after', action = logfile})