设计模式——单例模式/工厂模式

---

前言

常见的设计模式，它们是：单例模式、工厂模式、构建者模式、代理模式、观察者模式

---

一、单例模式

单例模式的主要目是保证某一个实例对象只会存在一个，减少资源的消耗。

第 1 种，重写 new 方法

定义一个实例变量，在 new 方法中保证这个变量仅仅初始化一次

# 单例模式
class Singleton(object):
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = object.__new__(cls, *args, **kwargs)
        return cls._instance

if __name__ == '__main__':
    # 构建3个实例
    instance1 = Singleton()
    instance2 = Singleton()
    instance3 = Singleton()

    # 打印出实例的内存地址，判断是否是同一个实例
    print(id(instance1))
    print(id(instance2))
    print(id(instance3))

第 2 种，闭包定义装饰器

使用闭包的方式定义一个单例装饰器，将类的定义隐藏到闭包函数中

def singleton(cls):
    """
    定义单例的装饰器（闭包）
    :param cls:
    :return:
    """
    _instance = {}

    def _singleton(*args, **kargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kargs)
        return _instance[cls]

    return _singleton


@singleton
class Singleton(object):
    """单例实例"""

    def __init__(self, arg1):
        self.arg1 = arg1

if __name__ == '__main__':
    instance1 = Singleton("xag")
    instance2 = Singleton("xingag")

    print(id(instance1))
    print(id(instance2))

第 3 种，多线程中构建单例

要保证多线程中构建的实例对象为单例，需要在 new 函数中使用 threading.Lock() 加入同步锁，保证了多线程创建的实例是单例存在的，不会导致脏数据！

class Singleton(object):
    """
    实例化一个对象
    """

     # 锁
    _instance_lock = threading.Lock()

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)
        return Singleton._instance


def task(arg):
    """
    任务
    :param arg:
    :return:
    """
    instance = Singleton()
    print(id(instance), '\n')

if __name__ == '__main__':
    # 3个线程
    for i in range(3):
        t = threading.Thread(target=task, args=[i, ])
        t.start()

二、工厂模式

工厂模式包含：简单工厂、工厂方法、抽象工厂

1.简单工厂

定义一个工厂类，创建一个静态方法，根据输入的类型，返回不同的对象

# 定义一系列水果
class Apple(object):
    """苹果"""

    def __repr__(self):
        return "苹果"


class Banana(object):
    """香蕉"""

    def __repr__(self):
        return "香蕉"


class Orange(object):
    """橘子"""

    def __repr__(self):
        return "橘子"
        
class FactorySimple(object):
    """简单工厂模式"""

    @staticmethod
    def get_fruit(fruit_name):
        if 'a' == fruit_name:
            return Apple()
        elif 'b' == fruit_name:
            return Banana()
        elif 'o' == fruit_name:
            return Orange()
        else:
            return '没有这种水果'


if __name__ == '__main__':
    # 分别获取3种水果
    # 输入参数，通过简单工厂，返回对应的实例
    instance_apple = FactorySimple.get_fruit('a')
    instance_banana = FactorySimple.get_fruit('b')
    instance_orange = FactorySimple.get_fruit('o')

2.工厂方法

工厂方法将创建对象的工作让相应的工厂子类去实现，保证在新增工厂类时，不用修改原有代码，首先，创建一个抽象公共工厂类，并定义一个生产对象的方法，接着，创建抽象工厂类的 3 个子类，并重写方法，创建一个实例对象并返回

import abc
from factory.fruit import *

class AbstractFactory(object):
    """抽象工厂"""
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def get_fruit(self):
        pass

class AppleFactory(AbstractFactory):
    """生产苹果"""

    def get_fruit(self):
        return Apple()

class BananaFactory(AbstractFactory):
    """生产香蕉"""

    def get_fruit(self):
        return Banana()

class OrangeFactory(AbstractFactory):
    """生产橘子"""

    def get_fruit(self):
        return Orange()

if __name__ == '__main__':
    # 每个工厂负责生产自己的产品也避免了我们在新增产品时需要修改工厂的代码，而只要增加相应的工厂即可
    instance_apple = AppleFactory().get_fruit()
    instance_banana = BananaFactory().get_fruit()
    instance_orange = OrangeFactory().get_fruit()

    print(instance_apple)
    print(instance_banana)
    print(instance_orange)

3.抽象工厂

如果一个工厂要生产多个产品，使用工厂方法的话，就需要编写很多工厂类，不太实用，使用抽象工厂就可以很好的解决这个问题

class MaoXW_CC(object):
    """川菜-毛血旺"""

    def __str__(self):
        return "川菜-毛血旺"

class XiaoCR_CC(object):
    """川菜-小炒肉"""

    def __str__(self):
        return "川菜-小炒肉"

class MaoXW_XC(object):
    """湘菜-毛血旺"""

    def __str__(self):
        return "湘菜-毛血旺"

class XiaoCR_XC(object):
    """湘菜-小炒肉"""

    def __str__(self):
        return "湘菜-小炒肉"

class AbstractFactory(object):
    """
    抽象工厂
    既可以生产毛血旺，也可以生成小炒肉
    """
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def product_maoxw(self):
        pass

    @abc.abstractmethod
    def product_xiaocr(self):
        pass

class CCFactory(AbstractFactory):
    """川菜馆"""

    def product_maoxw(self):
        return MaoXW_CC()

    def product_xiaocr(self):
        return XiaoCR_CC()


class XCFactory(AbstractFactory):
    """湘菜馆"""

    def product_maoxw(self):
        return MaoXW_XC()

    def product_xiaocr(self):
        return XiaoCR_XC()

if __name__ == '__main__':
    # 川菜炒两个菜，分别是：毛血旺和小炒肉
    maoxw_cc = CCFactory().product_maoxw()
    xiaocr_cc = CCFactory().product_xiaocr()

    print(maoxw_cc, xiaocr_cc)

    maoxw_xc = XCFactory().product_maoxw()
    xiaocr_xc = XCFactory().product_xiaocr()

    print(maoxw_xc, xiaocr_xc)