利用metaclass实现python的aop

heberoxx

　　修行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'''
9class 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的方法调用，就这样子：
　　

1class 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　　
　　最后我们只需要：
　　

1def beforep(self):
2    print('before')
3def afterp(self):
4    print('after')
5
6if __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.iyunv.com/cavingdeep/archive/2006/08/22/483056.html
　　并感谢python讨论群69828975里的大虾Seewind(310380)给予的无私帮助
　　欢迎各位python大牛给予斧正