工作需要使用学习Python， 发现Python装饰器很神奇，所以把以前做游戏用到的c#的装饰器模式捡起来对比了下。
1.C#装饰器设计模式：
先容我手上举个🌰子，组装电脑主板
根据面向对象编程思想，电脑主板大致为主板、cpu、gpu、内存条...
- 以主板MainBoard为主体其他部件围绕主板组装
- 所有电脑配件都继承该抽象类component
- 装饰类decorate继承component
//配件
public abstract class Component
{
public abstract void Log();
}
// 主板
public class MainBoard : Component
{
public override void Log()
{
Console.WriteLine("输出主板！");
}
}
//装饰器
public class Decorator : Component
{
protected Component _component;
public Decorator(Component component)
{
this._component = component;
}
public override void Log()
{
if (_component != null)
{
_component.Log();
}
}
}
//内存条（装饰具体承载者以下）
public class MemoryBank : Decorator
{
public override void Log()
{
base.Log();
Console.WriteLine("组装内存条！");
}
}
public class GPU : Decorator
{
public override void Log()
{
base.Log();
Console.WriteLine("组装显卡！");
}
}
public class CPU : Decorator
{
public override void Log()
{
base.Log();
Console.WriteLine("组装CPU！");
}
}
- 输出
class Program
{
static void Main(string[] args)
{
//我有了一个主板
MainBoard mainBoard = new MainBoard();
mainBoard.Log();
//主板装上cpu
CPU cpu_MainBoard = new CPU(mainBoard);
cpu_MainBoard.Log();
//主板装上了gpu
GPU gpu_MainBoard = new GPU(mainBoard);
gpu_MainBoard.Log();
//主板装上了内存条
MemoryBank memory_MainBoard = new MemoryBank(mainBoard);
memory_MainBoard.Log();
//主板同时装上了cpu、gpu、内存条,每个装饰类都要实例化一次 同时每一次传入被装饰的实例
CPU cpu_MainBoard = new CPU(mainBoard);
GPU gpu_cpu_MainBoard = new GPU(cpu_MainBoard);
MemoryBank memory_gpu_cpu_MainBoard = new MemoryBank(gpu_cpu_MainBoard);
memory_gpu_cpu_MainBoard.Log(); //有内存条，cpu，gpu的主板
Console.Read();
}
}
总结
- 优点：
- 使用装饰模式的方式来新增功能，可避免更改已经实现的程序代码。
- 灵活性和透明性，适合应用在系统功能是采用叠加不同小功能来完成实现的开发方式
- 缺点：
- 过多的装饰类容易造成系统维护的难度，功能之间太多的堆砌无形增加了其他程序员阅读代码的困难度（程序员之间review的鄙视）
- 应用场景：
- 装饰模式适合项目后期增加系统功能时使用
- 网络在线游戏中数据封包的加密解密，通过额外附加的“信息加密装饰者”，就可以染原本传递的信息增加安全性，而且可以实现不同的加密方式来层层包裹，而且修改时候，也不会影响到原油的数据封包的传送架构。
- 界面特效，可以在界面组建上增加一个 接口特效装饰类，来封装各种界面叠加效果，增加灵活性
最后 装饰器设计模式 就是让开发者遵从面向对象的设计思想，套用一句话 “组合对象优先继承对象”
2.Python装饰器用法：
- 首先装饰器是啥：对原有函数不进行任何更改从而达到增加功能的函数方法或者类函数
其中@为python的装饰器语法糖，比如
# 定义装饰器函数
def decorator_log(func):
def wrapper(*arg, **kwargs):
print('我是装饰器的打印日志')
return func(*arg, **kwargs)
return wrapper
@decorator_log
def test1():
print("我是测试方法1")
if __name__ == '__main__':
test1()
#执行结果是：
我是装饰器的打印日志
我是测试方法1
@decorator_log写在test1 函数的上方相当于 -------- test1 = decorator_log(test1)
这就意味着 方法 test1 方法已经被替换成了 decorator_log(test1) 所以被@装饰器方法 标记后 原方法已经是一个新的方法
再看下装饰器内部实现 其实 是把 装饰器函数decorator_log 内部定义的wrapper 给 return 出来 来代替了 传进来的func 网上流行说法 是闭包概念的深化
参考 知乎：如何理解Python装饰器
带参数的装饰器函数
# 定义装饰器函数
def decorator_log(a):
def decoragtor(func):
def wrapper(*arg, **kwargs):
print('我是装饰器的打印日志',a)
return func(*arg, **kwargs)
return wrapper
return decoragtor
@decorator_log('hello,world')
def test1():
print("我是测试方法1")
if __name__ == '__main__':
test1()
#执行结果是：
我是装饰器的打印日志hello,world
我是测试方法1
对比两种语言的装饰器：
- 虽然都是对原有函数进行封装，并且不改变原有代码而增加功能
- python是对闭包概念的深化，c#的装饰器模式是利用类对象的概念，不过C#用委托的概念也能实现 python这种方法传递 同时封装函数上下文到另一个执行环境，同样是闭包的概念 。
- python 要简洁的多 只要理解装饰器的概念，代码量上要简洁的多，并且易阅读（代码易阅读 是一个非常好 易于快速开发的重要特性）
