设计模式 - 创造模式（Creational Patterns）

零、 设计模式 - 创造模式（Creational Patterns）

这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

一、Borg Pattern - 共享单例模式

borg-github 学习参考

1-1 简单认识

Borg Patterns ：a singleton with shared-state among instances

单例模式（Singleton pattern） - 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例共享模式（Borg Pattern ） - 实现单例而不是仅创建一个实例，是多实例下的状态共享，注重于分享状态而不是分享实例。

1-1-1 Borg 特点

• 修改了属性字典 __ dict __ ,所以所有实例都拥有相同的字典
• 同类实例修改属性，同步修改属性值
• 虽然分享状态，但是同类实例的 id 并不相同

1-1-2 Borg vs Singleton

Python3 - 单例模式及其实现方式

• Borg 实例地址各不相同；Singleton 实例地址相同
• Borg 和 Singleton 属性都共享。
• Singleton 由于只有一个地址，因而相对节省内存空间。

1-2 Python 实现

class Borg(object):
    # 因为是类属性，所以实例共享
    __shared_state = {}

    def __init__(self):
        # 重写 __dict__ 属性字典
        self.__dict__ = self.__shared_state
        self.state = 'Init'

    def __str__(self):
        # 打印输出属性值
        return self.state


class YourBorg(Borg):
    pass


if __name__ == '__main__':
    # 创建多个同类实例
    rm1 = Borg()
    rm2 = Borg()

    # 初始化实例内 state 属性
    rm1.state = 'Idle'
    rm2.state = 'Running'

    # 输出查询状态
    print('rm1: {0}'.format(rm1))
    print('rm2: {0}'.format(rm2))
    # rm1: Running
    # rm2: Running

    # 修改状态
    rm2.state = 'Zombie'

    print('rm1: {0}'.format(rm1))
    print('rm2: {0}'.format(rm2))
    # rm1: Zombie
    # rm2: Zombie

    # 地址不同
    print('rm1 id: {0}'.format(id(rm1)))
    print('rm2 id: {0}'.format(id(rm2)))
    # rm1 id: 1817362624072
    # rm2 id: 1817362624128

    # 子类调用父类初始化，覆盖了父类属性
    rm3 = YourBorg()

    print('rm1: {0}'.format(rm1))
    print('rm2: {0}'.format(rm2))
    print('rm3: {0}'.format(rm3))
    # rm1: Init
    # rm2: Init
    # rm3: Init

1-2-1 装饰器实现

def borg(cls):
    cls._state = {
   }
    orig_init = cls.__init__
    def new_init(self, *args, **kwargs):
        self.__dict__ = cls._state
        orig_init(self, *args, **kwargs)
    cls.__init__ = new_init
    return cls

@borg
class TestBorg(object):
    def say_borg(self):
        print "i am borg"

1-3 应用场景

1-3-1 数据库连接管理

https://github.com/onetwopunch/pythonDbTemplate/blob/master/database.py

sqlite3 的连接管理，所有实例使用都是同一个db文件。

二、工厂模式、抽象工厂模式

factory pattern ：delegate a specialized function/method to create instances ；委托特别的函数去创建实例

abstract_factory pattern ：use a generic function with specific factories

2-1 工厂模式（factory pattern ）

A Factory is an object for creating other objects.

工厂对象被用于创建其他对象。

工厂类往往是用于提供实例化的“方法”，例如：动物工厂，根据动物叫声的不同而实例化为猫类或狗类。

2-1-1 Python 实现

# 实例类们
# Greek 语言类
class GreekLocalizer(object):
    """A simple localizer a la gettext"""

    def __init__(self):
        self.translations = {
   "dog": "σκύλος", "cat": "γάτα"}

    def localize(self, msg):
        """We'll punt if we don't have a translation"""
        return self.translations.get(msg, msg)


# English 语言类
class EnglishLocalizer(object):
    """Simply echoes the message"""

    def localize(self, msg):
        return msg


# 工厂函数，用于自主选择 language 是 English 还是 Greek
def get_localizer(language="English"):
    """Factory"""
    localizers = {
   
        "English": EnglishLocalizer,
        "Greek": GreekLocalizer,
    }
    # 返回实例对象
    return localizers[language]()


if __name__ == "__main__":
    e, g = get_localizer(language="English"), get_localizer(language="Greek")
    print(e.localize("dog"), e.localize("cat"))
    print(g.localize("dog"), g.localize("cat"