享元模式： 通过为相似对象引入数据共享来最小化内存使用，提升性能，一个享元就是一个包含状态的独立的不可变数据的共享对象 使用场景： 1、系统有大量相似对象。 2、需要缓冲池的场景 例如建立一个数据库链接，不希望建立多个链接，但又期望在同一个解释器下操作多台机器的数据库，但机器的IP端口不同的时候，就需要创建新链接，否则则直接使用已创建的链接 主要解决： 在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建

参考文章： https://www.runoob.com/design-pattern/flyweight-pattern.html https://github.com/ydf0509/python36patterns/blob/master/%E5%88%9B%E5%BB%BA%E5%9E%8B%E6%A8%A1%E5%BC%8F-%E4%BA%AB%E5%85%83%E6%A8%A1%E5%BC%8F-%E5%85%83%E7%B1%BB.py

享元模式

  1. # 单例模式，错误示范
  2. from redis import StrictRedis
  3. import pysnooper
  5. class Myredis:
  7.     _inst = None
  9.     def __new__(cls, *args, **kwargs):
  10.         # 实例不存在则创建redis链接实例
  11.         if not cls._inst:
  12.             self = super(Myredis, cls).__new__(cls)
  13.             self.__conn_redis__(*args, **kwargs)
  14.             cls._inst = self
  15.         print("cls._inst === {}".format(cls._inst))
  17.         return cls._inst
  19.     def __conn_redis__(self, redis_db):
  21.         print("传入的redis db 是{}".format(redis_db))
  22.         self.r = StrictRedis(host='127.0.0.1', port=6379, db=redis_db)
  23.         print("self.r === {}".format(self.r))
  26.     def set_data(self, key, value):
  28.         self.r.set(key, value)
  31. if __name__ == "__main__":
  32.     a = Myredis(3)
  33.     b = Myredis(4)
  34.     print(a, b)
  35.     # 这里会发现，即使链接的是不用的redis 数据库，使用的都是同一个实例，DB4永远不会都数据
  36.     """
  37.     传入的redis db 是3
  38.     self.r === Redis<ConnectionPool<Connection<host=127.0.0.1,port=6379,db=3>>>
  39.     cls._inst === <__main__.Myredis object at 0x7f6b064e7d68>
  40.     cls._inst === <__main__.Myredis object at 0x7f6b064e7d68>
  41.     <__main__.Myredis object at 0x7f6b064e7d68> <__main__.Myredis object at 0x7f6b064e7d68>
  42.     """
  1. # 享元模式
  2. class MyRedisOfShareMode:
  4.     pool = dict()   # 缓存池
  6.     def __new__(cls, redis_host, redis_port, redis_db):
  8.         # 将ip、post、db拼接组合为实例唯一标识
  9.         cache_key = '-'.join([redis_host, str(redis_port), str(redis_db)])
  10.         obj = cls.pool.get(cache_key, None)
  12.         # 如果唯一标识不存在，则重新创建redis链接实例
  13.         if not obj:
  14.             obj = object.__new__(cls)
  15.             print("obj==={}".format(obj))
  17.             cls.__conn_redis__(redis_host, redis_port, redis_db)
  18.             print("当前实例化的redis == {}".format(cache_key))  
  20.             print("cls==={}".format(cls))  
  22.             # 将已创建的实例保存到缓存池中
  23.             cls.pool[cache_key] = obj
  24.             print("cls.pool==={}".format(cls.pool))
  26.         return obj
  28.     @classmethod
  29.     def __conn_redis__(cls, redis_host, redis_port, redis_db):
  31.         print("传入的redis db 是{}".format(redis_db))
  33.         cls.r = StrictRedis(host=redis_host, port=redis_port, db=redis_db)
  34.         print("cls.r === {}".format(cls.r))
  38.     def set_data(self, name, value):
  39.         self.r.set(name, value)
  42. if __name__ == "__main__":
  44.     a = MyRedisOfShareMode('127.0.0.1', 6379, 2).set_data('aaa', '111')
  45.     b = MyRedisOfShareMode('127.0.0.1', 6379, 2).set_data('bbb', '222')
  46.     print(a, b)
  47.     c = MyRedisOfShareMode('127.0.0.1', 6379, 3).set_data('ccc', '11221')
  48.     print("###########", a, b, c)
  51.     # 可以看出，当ip、port、db一致时，是不会重复创建redis链接实例的
  52.     """
  53.         obj===<__main__.MyRedisOfShareMode object at 0x7f13feb62e48>
  54.         传入的redis db 是2
  55.         cls.r === Redis<ConnectionPool<Connection<host=127.0.0.1,port=6379,db=2>>>
  56.         当前实例化的redis == 2
  57.         cls===<class '__main__.MyRedisOfShareMode'>
  58.         cls.pool==={2: <__main__.MyRedisOfShareMode object at 0x7f13feb62e48>}
  59.         None None
  60.         obj===<__main__.MyRedisOfShareMode object at 0x7f13fe07df28>
  61.         传入的redis db 是3
  62.         cls.r === Redis<ConnectionPool<Connection<host=127.0.0.1,port=6379,db=3>>>
  63.         当前实例化的redis == 3
  64.         cls===<class '__main__.MyRedisOfShareMode'>
  65.         cls.pool==={2: <__main__.MyRedisOfShareMode object at 0x7f13feb62e48>, 3: <__main__.MyRedisOfShareMode object at 0x7f13fe07df28>}
  66.         ########### None None None
  67.     """

享元模式-装饰器实现

  1. from redis import StrictRedis
  2. from functools import wraps
  3. from logzero import logger
  6. def redis_conn_decorator(cls):
  8.     _instance = {}  # 缓存池
  11.     @wraps(cls)
  12.     def wrappers(*args, **kwargs):
  13.         # 将host、port、db 拼接作为唯一标识
  14.         cache_key = '-'.join([*args])
  16.         # 唯一标识不存在则创建redis 链接实例
  17.         if cache_key not in _instance:
  18.             logger.info("新创建了实例， cache_key == {}".format(cache_key))
  19.             logger.info("cls===={}".format(cls))
  21.             # 将创建的实例保存到缓存池
  22.             _instance[cache_key] = cls(*args)
  24.         logger.info("当前_instance == {}".format(_instance))
  26.         return _instance[cache_key]
  29.     return wrappers
  32. @redis_conn_decorator
  33. class MyRedis(object):
  35.     def __init__(self, host, port, redis_db):
  36.         self.redis_db = redis_db
  37.         logger.info("传入的redis db 是{}".format(self.redis_db))
  39.         self.r = StrictRedis(host=host, port=int(port), db=int(self.redis_db))
  40.         logger.info("self.r === {}".format(self.r))
  43.     def set_data(self, name, value):
  45.         logger.info(f"name={name}, value={value}")
  46.         self.r.set(name, value)
  49. if __name__ == "__main__":
  50.     a = MyRedis('127.0.0.1', "6379", "3")
  51.     b = MyRedis('127.0.0.1', "6379", "3")
  52.     c = MyRedis('127.0.0.1', "6379", "4")
  53.     print(a, b, c)
  54.     a.set_data("a_decorator", 'aa')
  55.     b.set_data("b_decorator", 'bb')
  56.     c.set_data("c_decorator", 'cc')
  58.     """
  59.     [I 220717 15:26:51 share_meta_with_decorator:26] 新创建了实例， cache_key == 127.0.0.1-6379-3
  60.     [I 220717 15:26:51 share_meta_with_decorator:27] cls====<class '__main__.MyRedis'>
  61.     [I 220717 15:26:51 share_meta_with_decorator:45] 传入的redis db 是3
  62.     [I 220717 15:26:51 share_meta_with_decorator:48] self.r === Redis<ConnectionPool<Connection<host=127.0.0.1,port=6379,db=3>>>
  63.     [I 220717 15:26:51 share_meta_with_decorator:32] 当前_instance == {'127.0.0.1-6379-3': <__main__.MyRedis object at 0x7f9bab805550>}
  64.     [I 220717 15:26:51 share_meta_with_decorator:32] 当前_instance == {'127.0.0.1-6379-3': <__main__.MyRedis object at 0x7f9bab805550>}
  65.     [I 220717 15:26:51 share_meta_with_decorator:26] 新创建了实例， cache_key == 127.0.0.1-6379-4
  66.     [I 220717 15:26:51 share_meta_with_decorator:27] cls====<class '__main__.MyRedis'>
  67.     [I 220717 15:26:51 share_meta_with_decorator:45] 传入的redis db 是4
  68.     [I 220717 15:26:51 share_meta_with_decorator:48] self.r === Redis<ConnectionPool<Connection<host=127.0.0.1,port=6379,db=4>>>
  69.     [I 220717 15:26:51 share_meta_with_decorator:32] 当前_instance == {'127.0.0.1-6379-3': <__main__.MyRedis object at 0x7f9bab805550>, '127.0.0.1-6379-4': <__main__.MyRedis object at 0x7f9ba85886a0>}
  70.     <__main__.MyRedis object at 0x7f9bab805550> <__main__.MyRedis object at 0x7f9bab805550> <__main__.MyRedis object at 0x7f9ba85886a0>
  71.     [I 220717 15:26:51 share_meta_with_decorator:53] name=a_decorator, value=aa
  72.     [I 220717 15:26:51 share_meta_with_decorator:53] name=b_decorator, value=bb
  73.     [I 220717 15:26:51 share_meta_with_decorator:53] name=c_decorator, value=cc
  74.     """

享元模式-元类实现

  1. from redis import StrictRedis
  2. from logzero import logger
  5. class ConnRedisMetaClass(type):
  7.     def __init__(cls, name, bases, dict):
  8.         super(ConnRedisMetaClass, cls).__init__(name, bases, dict)
  9.         cls._inst_map = {}
  12.     @staticmethod
  13.     def _make_arguments_to_key(args, kwds):
  14.         """拼接参数"""
  15.         key = args
  16.         if kwds:
  17.             sorted_items = sorted(kwds.items())
  18.             for item in sorted_items:
  19.                 key += item
  20.         return key
  23.     def __call__(cls, *args, **kwargs):
  24.         # 将host、port、db 拼接作为唯一标识
  25.         cache_key = f'{cls}_{cls._make_arguments_to_key(args, kwargs)}'
  26.         logger.info(f"cache_key === {cache_key}")
  28.         # 唯一标识不存在则创建redis 链接实例
  29.         if cache_key not in cls._inst_map:
  30.             cls._inst_map[cache_key] = super().__call__(*args, **kwargs)
  32.         logger.info(f"cls._inst_map === {cls._inst_map}")
  33.         return cls._inst_map[cache_key]
  36. class Myredis(metaclass=ConnRedisMetaClass):
  38.     def __init__(self, host, port, redis_db):
  39.         logger.info(f"传入的host = {host}, port = {port}, redis_db = {redis_db}")
  41.         self.r = StrictRedis(host=host, port=port, db=redis_db)
  42.         logger.info("self.r === {}".format(self.r))
  45.     def set_data(self, name, value):
  47.         logger.info(f"name={name}, value={value}")
  48.         self.r.set(name, value)
  52. if __name__ == "__main__":
  53.     a = Myredis('127.0.0.1', 6379, 2)
  54.     b = Myredis('127.0.0.1', 6379, 2)
  55.     c = Myredis('127.0.0.1', 6379, 4)
  56.     logger.info(f"{a}, {b}, {c}")
  58.     a.set_data("a", 'metaclass-aa')
  59.     b.set_data("b", 'metaclass-bb')
  60.     c.set_data("c", 'metaclass-cc')
  62.     """
  63.     [I 220717 15:28:42 share_meta_with_metaclass:34] cache_key === <class '__main__.Myredis'>_('127.0.0.1', 6379, 2)
  64.     [I 220717 15:28:42 share_meta_with_metaclass:47] 传入的host = 127.0.0.1, port = 6379, redis_db = 2
  65.     [I 220717 15:28:42 share_meta_with_metaclass:50] self.r === Redis<ConnectionPool<Connection<host=127.0.0.1,port=6379,db=2>>>
  66.     [I 220717 15:28:42 share_meta_with_metaclass:40] cls._inst_map === {"<class '__main__.Myredis'>_('127.0.0.1', 6379, 2)": <__main__.Myredis object at 0x7fb918eae908>}
  67.     [I 220717 15:28:42 share_meta_with_metaclass:34] cache_key === <class '__main__.Myredis'>_('127.0.0.1', 6379, 2)
  68.     [I 220717 15:28:42 share_meta_with_metaclass:40] cls._inst_map === {"<class '__main__.Myredis'>_('127.0.0.1', 6379, 2)": <__main__.Myredis object at 0x7fb918eae908>}
  69.     [I 220717 15:28:42 share_meta_with_metaclass:34] cache_key === <class '__main__.Myredis'>_('127.0.0.1', 6379, 4)
  70.     [I 220717 15:28:42 share_meta_with_metaclass:47] 传入的host = 127.0.0.1, port = 6379, redis_db = 4
  71.     [I 220717 15:28:42 share_meta_with_metaclass:50] self.r === Redis<ConnectionPool<Connection<host=127.0.0.1,port=6379,db=4>>>
  72.     [I 220717 15:28:42 share_meta_with_metaclass:40] cls._inst_map === {"<class '__main__.Myredis'>_('127.0.0.1', 6379, 2)": <__main__.Myredis object at 0x7fb918eae908>, "<class '__main__.Myredis'>_('127.0.0.1', 6379, 4)": <__main__.Myredis object at 0x7fb91578cbe0>}
  73.     [I 220717 15:28:42 share_meta_with_metaclass:64] <__main__.Myredis object at 0x7fb918eae908>, <__main__.Myredis object at 0x7fb918eae908>, <__main__.Myredis object at 0x7fb91578cbe0>
  74.     [I 220717 15:28:42 share_meta_with_metaclass:55] name=a, value=metaclass-aa
  75.     [I 220717 15:28:42 share_meta_with_metaclass:55] name=b, value=metaclass-bb
  76.     [I 220717 15:28:42 share_meta_with_metaclass:55] name=c, value=metaclass-cc
  77.     """