基于Python的设计模式简述

结构梳理>>>

第一部分：创建型模式

工厂模式

工厂方法
抽象工厂

建造者模式
原型模式
单例模式

第二部分：结构型模式

适配器模式
修饰器模式
外观模式
享元模式
模型-视图-控制器模式
代理模式

第三部分：行为型模式

责任链模式
命令模式
解释模式
观察者模式
状态模式
策略模式
模板模式

干货>>>

　　何为设计模式？

　　==>大牛们踩过了无数的坑总结出来的软件设计中的推荐方案

第一部分：创建型模式

　　跟对象创建有关的一系列模式

工厂模式

　　客户端请求对象时无需知道对象的来源，直接通过向函数和类向工厂传递参数创建对象，简化对象的创建过程

　　工厂方法

　　何为工厂？

　　==>加工类的地方

　　何为工厂方法？

　　==>以方法（函数）作为工厂

　　实现：

　　定义函数，根据条件返回不同类的实例

　　1）定义多个类（平行的类）

　　2）定义工厂方法-函数，通过不同输入参数的条件判断将上面定义的类分别赋值同一个变量，最后返回变量的调用-类的实例对象

　　3）可以再定义一系列函数调用工厂方法进行封装，实现不同功能（异常处理，写日志等）

　　抽象工厂

　　何为抽象工厂？

　　==>一组工厂方法，每个工厂方法返回不同实例对象

　　为什么要用抽象工厂？

　　==>优点：工厂方法的泛化，使对象创建更容易追踪；将对象创建和使用解耦；优化内存占用和性能潜力；可通过改变激活工厂方法动态改变应用行为，不用终止重启，改变用户使用应用的观感（看不懂？往下看）

　　什么时候用？

　　==>创建了很多工厂方法，难以维护了，此时，我们需要把创建实例对象的过程合并在一起

　　实现：

　　1）定义多个类（平行的类）

　　2）定义抽象工厂-类，通过定义类的不同方法（make_a、make_b...），返回上面定义类的实例对象（有参数的在__init__中定义）==>将抽象工厂作为一个接口，实现动态激活make_a、make_b等工厂方法

　　3）可以再定义一系列类，对抽象工厂进行封装。

　　　　例如：再定义一个类Env，__init__中传入抽象工厂的调用-类的实例对象，通过调用实例的make_a、make_b方法，实现在Env中初始化类；定义其他方法，实现不同功能

建造者模式

　　用于细粒度控制复杂对象的创建过程

　　何为建造者模式？

　　==>创建一个由多个部分构成的对象，每个构成需要一步步完成，就像盖房子，每个部分都建造好，对象才算最终创建

　　什么时候用？

　　1）页面生成器

　　2）文档转换器

　　3）用户界面

　　4）表单创建工具

　　再回首:

　　工厂模式：单步创建对象；调用立即返回实例对象；

　　建造者模式：多步创建对象；需要时才返回最终实例对象；

　　实现：

　　引入建造者、指挥者、

　　1）定义一个类A（要创建的类，创建时需要一步步调用类中不同的属性和方法）

　　2）定义不同类的Builder（建造者），实例化时传入A的实例；定义多个函数-代表创建过程的多个步骤（通过调用实例的属性和方法实现），实现不同建造者的不同创建步骤

　　3）定义一个类Constructer（指挥者），定义方法，传入建造者作为参数，按照指定的顺序执行建造者定义的一系列方法（建造步骤）

原型模式

　　创建对象的克隆-副本（注意引用和副本的区别）；copy.deepcopy的使用

　　实现：

　　通过定义类，定义方法，调用copy.deepcopy（obj）实现对象克隆

单例模式

　　每次初始化类时生成同一个实例对象

　　实现：

# 1. new方法实现

class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__new__(*args, **kwargs)
        return cls._instance

class MyClass:
    a = 1


# 2. 装饰器实现

from functools import wraps

def singleton(cls):
    _instance = {}

    @wraps(cls)
    def check_instance(*args, **kwargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kwargs)
        return _instance[cls]
    return check_instance

@singleton
class MyClass:
    a = 1

# 3. metaclass实现

class Singleton(type):
    _instance = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instance:
            cls._instance[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance[cls]

class MyClass(metaclass=Singleton):
    # __metaclass__ = Singleton
    a = 1

第二部分：结构型模式

　　处理系统中不同实体（类、对象）间关系，通过对象组合方式，创造新功能

适配器模式

　　实现不兼容接口间兼容　　

　　遵循开放封闭原则（扩展开放、修改封闭）

　　什么时候用？

　　不修改原始代码的情况下，将老组件用于新系统or新组件用于老系统；组件以外部库提供，无法访问代码

　　实现

　　方式1：继承

　　方式2：类的内部字典（更地道）

　　1）定义类（待访问的代码类）

　　2）定义类（可访问的代码）

　　3）定义类Adapter，初始化对象时传入待访问的类对象、待访问的类的方法（dict形式），将待访问的类的方法update到self.__dict__中

*****external.py*****

class Synthesizer:

    def __init__(self, name):

        self.name = name

    def __str__(self):

        return 'the {} synthesizer'.format(self.name)

    def play(self):

        return 'is playing an electronic song'

class Human:

    def __init__(self, name):

        self.name = name

    def __str__(self):

        return '{} the human'.format(self.name)

    def speak(self):

        return 'says hello'

*****adapter.py*****

from external import Synthesizer, Human

class Computer:

    def __init__(self, name):

        self.name = name

    def __str__(self):

        return 'the {} computer'.format(self.name)

    def execute(self):

        return 'executes a program'

class Adapter:

    def __init__(self, obj, adapted_methods):

        self.obj = obj

        self.__dict__.update(adapted_methods)

    def __str__(self):

        return str(self.obj)

    def main():

        objects = [Computer('Asus')]

        synth = Synthesizer('moog')

        objects.append(Adapter(synth, dict(execute=synth.play)))

        human = Human('Bob')

        objects.append(Adapter(human, dict(execute=human.speak)))

        for i in objects:

            print('{} {}'.format(str(i), i.execute()))



if __name__ == "__main__":

　　main()

修饰器模式

　　无序使用子类，动态扩展对象的行为（能用组合，不用继承）-将功能添加到对象

　　什么时候用？

　　实现横切关注点

　　1）数据校验

　　2）事务处理（这里的事务类似于数据库事务，意味着要么所有步骤都成功完成，要么事务失败）

　　3）缓存

　　4）日志

　　5）监控

　　6）调试

　　7）业务规则

　　8）压缩

　　9）加密

　　图形用户界面（GUI）工具集

　　实现：

　　python修饰器实现修饰器模式

外观模式

　　一种简化复杂系统访问的方式

　　为什么要用外观模式？

　　隐藏系统的内部复杂性，通过一个简化的接口向客户端暴露必要的部分（在复杂系统做了一个抽象层）

享元模式

　　复用对象，提高系统的资源利用率

模型-视图-控制器模式
代理模式

第三部分：行为型模式

责任链模式
命令模式
解释模式
观察者模式
状态模式
策略模式
模板模式