利用metaclass实现python的aop

修行Python个把星期，终于有点成果了，呵呵，一个利用metaclass实现的aop。

其实python这类非常动态的语言要实现AOP是很容易的，所以首先我们要来先定义一个metaclass

然后我们要在__new__（）这个metaclass 的时候动态植入方法到要调用地方法的前后。

具体代码如下：

 1
 2 __author__= " alex "
 3 __date__ = " $2008-12-5 23:54:11$ "
 4 __name__= " pyaop "
 5
 6 '''
 7 这个metaclass是实现AOP的基础
 8 '''
 9 class pyaop(type):
10      '''
11     这个空方法是用来将后面的beforeop和afterop初始化成函数引用
12      '''
13      def nop(self):
14          pass
15      '''
16     下面这两个变量是类变量，也就是存放我们要植入的两个函数的地址的变量
17      '''
18     beforeop=nop
19     afterop=nop
20      '''
21     设置前后两个植入函数的类函数
22      '''
23     @classmethod
24      def setbefore(self,func):
25         pyaop.beforeop=func
26     @classmethod
27      def setafter(self,func):
28         pyaop.afterop=func
29      '''
30     初始化metaclass的函数，这个函数最重要的就是第四个参数，dict通过这个参数我们可以修改类的属性（方法）
31      '''
32      def  __new__(mcl,name,bases,dict):
33          from types  import FunctionType  # 加载类型模块的FunctionType
34         obj=object()  # 定义一个空对象的变量
35          '''
36         这个就是要植入的方法，func参数就是我们要调用的函数
37          '''
38          def aop(func):
39              '''
40             我们用这个函数来代替将要调用的函数
41              '''
42              def wrapper(*args, **kwds):
43                 pyaop.beforeop(obj)  # 调用前置函数
44                 value = func(*args, **kwds)  # 调用本来要调用的函数
45                 pyaop.afterop(obj)  # 调用后置函数
46                  return value  # 返回
47              return wrapper
48          # 在类的成员列表中查找即将调用的函数
49          for attr, value  in dict.iteritems():
50              if isinstance(value, FunctionType):
51                 dict[attr] = aop(value)  # 找到后用aop这个函数替换之
52         obj=super(pyaop, mcl). __new__(mcl, name, bases, dict)  # 调用父类的__new__()创建self
53          return obj
54     

 

使用的时候，如果我们要拦截一个类A的方法调用，就这样子：

 

 1 class A(object):
 2      __metaclass__ = pyaop
 3      def foo(self):
 4         total = 0
 5          for i  in range(100000):
 6             total = total+1
 7          print total
 8
 9      def foo2(self):
10          from time  import sleep
11         total = 0
12          for i  in range(100000):
13             total = total+1
14             sleep(0.0001)
15          print total

 

最后我们只需要：

 

 1 def beforep(self):
 2      print( ' before ')
 3 def afterp(self):
 4      print( ' after ')
 5
 6 if  __name__ ==  " __main__ ":
 7     pyaop.setbefore(beforep)
 8     pyaop.setafter(afterp)
 9     a=A()
10     a.foo()
11     a.foo2()

 这样子在执行代码的时候就得到了如下结果

before
100000
after
before
100000
after

这段代码耗时一天才调通（汗颜），是基于园里另外一贴 http://www.cnblogs.com/cavingdeep/archive/2006/08/22/483056.html