python类装饰器(装饰器类)详解 + 企业应用实例

哈喽，各位小伙伴，众所周知，如果要说你会python， 那么装饰器是必备技能，在python开发中，装饰器的应用也非常广泛。

不知小伙伴们在编程时有没有这样的苦恼：业务逻辑越复杂，函数处理逻辑也会复杂，从而函数中判断逻辑也会增加，有时还不得不拆分几个函数辅助完成，这会使得可阅读性降低，代码看上去很low，而且这样做会使得函数通用性降低，程序中必然出现很多重复累赘的代码。

上面的问题通过类似的装饰器可以完美解决，而且只用一个装饰器名称。阅读以下内容你将明白类装饰器原理，以及一个装饰器实现：日志记录、并发运行函数、添加互斥锁、限制函数执行次数等实例，好了，让我们进入今天的主题吧，（演示完整代码在最后，开箱即用）

类装饰器通用写法

上图代码块内容是类装饰器最通用的写法，装饰器传参与否，被装饰函数传参与否他否可以处理。

类装饰器运行顺序

从上图中的日志输出我们不难看出类装饰器运行顺序为：①先实例化类装饰器并执行__init__函数→②调用__call__方法→③调用call方法返回的main方法→④调用main方法返回的函数wapper→⑤运行被装饰的方法

了解了执行顺序，相信你对装饰器类有一定了解，好了那我们直接看实例

实例1- 并发执行

可以并发执行被装饰函数，这种做法在自动化中并发执行case，很有用

从打印结果可以看出，打印书序是乱序，说明 并发执行了被装饰函数，

实例2- 添加互斥锁

用装饰器给函数上锁，简单、高效、灵活性强，

从打印结果可以看出，没有并发执行，而是串行，按顺序打印

实例3- 记录日志

从test_log文件里，可以看出，相应信息被记录在txt文件中

看了类装饰器通用写法，以及相关实例后，依葫芦画瓢，整体结构复制后，添加函数，就可以封装属于自己的类装饰器，让一个装饰器完成多个功能，相信这对你程序有帮助。

有看不懂的地方，或者需要我帮你封装的，欢迎留言咨询，有问必答，相互学习，共赢~~~

示例源码：

import functools
import  copy
from concurrent.futures import  ThreadPoolExecutor as TPool
from threading import Lock
import time
import functools

class LeiWrapper:                               #定义装饰器类
    def __init__(self,*args,**kwargs):          #定义类装饰器初始化方法，用于接收类装饰器传入的参数
        self.args = args
        self.kwargs = kwargs
    def  main(self):                            #函数包装功能 预处理
        print("这是类装饰器中的第一个功能函数")
        @functools.wraps(self.func)             # 保持函数本身信息不变，比如函数name、注释信息等
        def wapper(*args,**kwargs):             # 定义包裹函数，用于接收函数调用时传入参数
            print("4444")
            data = self.func(*args,**kwargs)    # 调用运行被装饰的函数
            return data                         # 返回函数处理完的数据
        return wapper
    def RunBF(self):
        @functools.wraps(self.func)
        def mm(*arg,**kwarg):  #接收函数调用传入参数
            data = ["1","2","3"]  #用于并发的数据
            with TPool(4) as ex:   #启动有2个线程的线程池
                start = time.time()
                for i in data:
                    kwarg[i] = "参数+ " + str(i)  #改变参数
                    ex.submit(self.func,*arg,**kwarg) #并发执行函数
                end = time.time()
            print(end - start)
        return mm
    def LockFun(self):
        @functools.wraps(self.func)
        def mm(*arg,**kwarg):  #接收函数调用传入参数
            with Lock():
                    funResult = self.func(*arg,**kwarg) #给函数加锁
            return funResult   #返回被装饰函数的返回值
        return mm
    def logs(self):
        @functools.wraps(self.func)
        def mm(*arg,**kwarg):  #接收函数调用传入参数
            with open("test_log.txt","a+",encoding="UTF-8") as writer:
                 funResult = self.func(*arg,**kwarg) 
                 message = "函数被执行了，传入参数为： "  +  str(arg) + "，关键字参数为：" + str(kwarg)
                 message = message + "函数执行结果为： " + funResult  + "\n"
                 writer.write(message)  
            return funResult   #返回被装饰函数的返回值
        return mm
  
    def __call__(self,func):    
        self.func = func
        if self.kwargs.get("menthod") == "BF":  #根据参数判断装饰器工作内容
            return self.RunBF()
        if self.kwargs.get("menthod") == "Lock":  #根据参数判断装饰器工作内容
            return self.LockFun()
        if self.kwargs.get("menthod") == "logs":  #根据参数判断装饰器工作内容
            return self.logs()
        return self.main()
@LeiWrapper(menthod="logs")
def test(*arg,**kwarg):
    time.sleep(2)
    print("函数被执行了，传入参数为： "  +  str(arg) + "，关键字参数为：" + str(kwarg))
    return "执行完成"
    
test("参数1",key="wwwwwww")
test("参数2",key="eeeeeee")
test("参数3",key="rrrrrr")
test("参数4",key="tttt")