Python设计模式-创建型：单例模式和工厂模式家族

Python设计模式-创建型：单例模式和工厂模式家族

知识点：

• 单例模式概念及一般实现
  
• 单例模式的装饰器实现
  
• 简单工厂模式
  
• 抽象工厂模式
  

单例模式(singleton)

• 所谓单例模式，也就是说不管什么时候我们要确保只有一个对象实例存在。
  
• 很多情况下，整个系统中只需要存在一个对象，所有的信息都从这个对象获取，比如系统的配置对象，或者是线程池。
  
• 这些场景下，就非常适合使用单例模式。总结起来，就是说不管我们初始化一个对象多少次，真正干活的对象只会生成一次并且在首次生成。
  

Singleton._instance

1. # -*- coding: utf-8 -*-
3. class Singleton(object):
4.     """
5.     单例模式
6.     """
7.     class _A(object):
8.         """
9.        真正干活的类, 对外隐藏
10.         """
11.         def __init__(self):
12.             pass
14.         def display(self):
15.             """ 返回当前实例的 ID，是全局唯一的"""
16.             return id(self)
18.     # 类变量，用于存储 _A 的实例
19.     _instance = None
21.     def __init__(self):
22.         """ 先判断类变量中是否已经保存了 _A 的实例，如果没有则创建一个后返回"""
23.         if Singleton._instance is None:
24.             Singleton._instance = Singleton._A()
26.     def __getattr__(self, attr):
27.         """ 所有的属性都应该直接从 Singleton._instance 获取"""
28.         return getattr(self._instance, attr)
31. if __name__ == '__main__':
32.     # 创建两个实例
33.     s1 = Singleton()
34.     s2 = Singleton()
35.     print(id(s1), s1.display())
36.     print(id(s2), s2.display())

复制代码

• 使用类变量 Singleton._instance 来存储创建的实例，并且保证只会创建一次实例。
  
• 由于 Python 是一门动态语言，我们可以在运行时改变类定义。
  
• 在首次初始化Singleton时，我们将首次生成类_A的实例,并将其存储到 Singleton._instance 中，以后每次初始化 Singleton 时都从 Singleton._instance 获取真正干活的实例，这样我们就实现了单例模式。
  

装饰器

1. # -*- coding: utf-8 -*-
3. class Singleton:
5.     """
6.     单例类装饰器，可以用于想实现单例的任何类。注意，不能用于多线程环境。
7.     """
9.     def __init__(self, cls):
10.         """ 需要的参数是一个类 """
11.         self._cls = cls
13.     def Instance(self):
14.         """
15.         返回真正的实例
16.         """
17.         try:
18.             return self._instance
19.         except AttributeError:
20.             self._instance = self._cls()
21.             return self._instance
23.     def __call__(self):
24.         raise TypeError('Singletons must be accessed through `Instance()`.')
26.     def __instancecheck__(self, inst):
27.         return isinstance(inst, self._decorated)
30. # 装饰器
31. @Singleton
32. class A:
33.     """一个需要单例模式的类"""
34.     def __init__(self):
35.         pass
37.     def display(self):
38.         return id(self)
40. if __name__ == '__main__':
41.     s1 = A.Instance()
42.     s2 = A.Instance()
43.     print(s1, s1.display())
44.     print(s2, s2.display())
45.     print(s1 is s2)

复制代码

• 用装饰器实现了单例模式，任何想使用单例模式的类，只需要使用 Singleton 装饰器装饰一下就可以使用了。
  
• 可以看到其核心工作原理其实和第一种实现方式是一致的，也是使用内置的属性 Singleton._instance 来存储实例的。通过使用装饰器的模式我们将代码解耦了，使用更加灵活
  

案例-单例模式-连接sqlite3数据库

1. # -*- coding: utf-8 -*-
4. import sqlite3
5. from flask import current_app
6. from flask import _app_ctx_stack as stack
9. class SQLite3(object):
11.     def __init__(self, app=None):
12.         self.app = app
13.         if app is not None:
14.             self.init_app(app)
16.     def init_app(self, app):
17.         """
18.         典型的 Flask 扩展的初始化方式
19.         """
20.         app.config.setdefault('SQLITE3_DATABASE', ':memory:')
21.         app.teardown_appcontext(self.teardown)
23.     def connect(self):
24.         """
25.         连接到 sqlite 数据库
26.         """
27.         return sqlite3.connect(current_app.config['SQLITE3_DATABASE'])
29.     def teardown(self, exception):
30.           """
31.           关闭 sqlite 链接
32.           """
33.         ctx = stack.top
34.         if hasattr(ctx, 'sqlite3_db'):
35.             ctx.sqlite3_db.close()
37.     @property
38.     def connection(self):
39.         """
40.         单例模式在这里：使用 flask._app_ctx_stack 存放 sqlite 链接,
41.         每次获取数据库链接时都通过 connection 获取
42.         """
43.         ctx = stack.top
44.         if ctx is not None:
45.             if not hasattr(ctx, 'sqlite3_db'):
46.                 ctx.sqlite3_db = self.connect()
47.             return ctx.sqlite3_db

复制代码

简单工厂模式 Simple factory

一个函数，传入需要创建的产品类型，然后返回相应的产品

1. # -*- coding: utf-8 -*-
4. import random
7. class BasicCourse(object):
8.     """
9.     基础课程
10.     """
11.     def get_labs(self):
12.         return "basic_course: labs"
14.     def __str__(self):
15.         return "BasciCourse"
18. class ProjectCourse(object):
19.     """
20.     项目课
21.     """
23.     def get_labs(self):
24.         return "project_course: labs"
26.     def __str__(self):
27.         return "ProjectCourse"
30. class SimpleCourseFactory(object):
32.     @staticmethod
33.     def create_course(type):
34.         """ 简单工厂，用于创建课程"""
35.         if type == 'bc':
36.             return BasicCourse()
37.         elif type == 'pc':
38.             return ProjectCourse()
41. if __name__ == '__main__':
42.     t = random.choice(['bc', 'pc'])
43.     course = SimpleCourseFactory.create_course(t)
44.     print(course.get_labs())

复制代码

工厂方法模式 factory method

上面的简单工厂模式中，我们遇到了问题：如果需要增加一种课程，那我们需要修改工厂代码。仔细想想，如果对工厂进行抽象化，让每个工厂只负责一种产品的生产，那这样当增加一种产品时，就不需要修改已有的工厂了，只需要新增加一个工厂就行了，这样就避免修改整个工厂了

1. # -*- coding: utf-8 -*-
3. import random
4. import abc
7. class BasicCourse(object):
8.     """
9.         基础课程
10.         """
11.     def get_labs(self):
12.         return "basic_course: labs"
14.     def __str__(self):
15.         return "BasicCourse"
18. class ProjectCourse(object):
19.     """
20.         项目课
21.         """
23.     def get_labs(self):
24.         return "project_course: labs"
26.     def __str__(self):
27.         return "ProjectCourse"
30. class Factory(metaclass=abc.ABCMeta):
31.     """
32.         抽象工厂类
33.         """
35.     @abc.abstractmethod
36.     def create_course(self):
37.         pass
40. class BasicCourseFactory(Factory):
41.     """
42.         基础课程工厂类
43.         """
45.     def create_course(self):
46.         return BasicCourse()
49. class ProjectCourseFactory(Factory):
50.     """
51.         项目课程工厂类
52.         """
53.     def create_course(self):
54.         return ProjectCourse()
57. def get_factory():
58.     """
59.         随机获取一个工厂类
60.         """
61.     return random.choice([BasicCourseFactory, ProjectCourseFactory])()
64. if __name__ == '__main__':
65.     factory = get_factory()
66.     course = factory.create_course()
67.     print(course.get_labs())

复制代码

我们有两种课程：BasicCourse 和 ProjectCourse，分别对应基础课和项目课。接着，我们创建了一个抽象的工厂 Factory，该工厂有一抽象方法Factory.create_course用于创建课程，最后我们基于抽象工厂实现了生产基础课程的工厂BasicCourseFactory和生产项目课的工厂ProjectCourseFactory。这样当我们新增加一种课程时，就不需要修改已经存在的基础课工厂和项目课工厂了。这里需要说明下，我们通过 Python 的abc模块实现抽象类和抽象方法。
抽象工厂模式

在工厂方法模式中，我们会遇到一个问题，当产品非常多时，继续使用工厂方法模式会产生非常多的工厂类。
如果按照工厂方法模式的作法，我们需要创建 Linux 虚拟机工厂类和 Mac 虚拟机工厂类， 这样我们就会有一堆工厂类了。我们就不能创建出一个能同时创建课程和虚拟机的工厂吗？

1. -*- coding: utf-8 -*-
3. import random
4. import abc
6. # 两种类型的课程
7. class BasicCourse(object):
8.     """
9.     基础课程
10.     """
11.     def get_labs(self):
12.         return "basic_course: labs"
14.     def __str__(self):
15.         return "BasicCourse"
18. class ProjectCourse(object):
19.     """
20.     项目课
21.     """
23.     def get_labs(self):
24.         return "project_course: labs"
26.     def __str__(self):
27.         return "ProjectCourse"
30. # 两种类型的虚拟机
31. class LinuxVm(object):
32.     """
33.     Linux 虚拟机
34.     """
36.     def start(self):
37.         return "Linux vm running"
40. class MacVm(object):
41.     """
42.     Mac OSX 虚拟机
43.     """
45.     def start(self):
46.         return "Mac OSX vm running"
49. class Factory(metaclass=abc.ABCMeta):
50.     """
51.     抽象工厂类, 现在工厂类不仅能创建课程，还能创建虚拟机了
52.     """
54.     @abc.abstractmethod
55.     def create_course(self):
56.         pass
58.     @abc.abstractmethod
59.     def create_vm(self):
60.         pass
63. class BasicCourseLinuxFactory(Factory):
64.     """
65.     基础课程工厂类
66.     """
68.     def create_course(self):
69.         return BasicCourse()
71.     def create_vm(self):
72.         return LinuxVm()
75. class ProjectCourseMacFactory(Factory):
76.     """
77.     项目课程工厂类
78.     """
80.     def create_course(self):
81.         return ProjectCourse()
83.     def create_vm(self):
84.         return MacVm()
87. def get_factory():
88.     """
89.     随机获取一个工厂类
90.     """
91.     return random.choice([BasicCourseLinuxFactory, ProjectCourseMacFactory])()
94. if __name__ == '__main__':
95.     factory = get_factory()
96.     course = factory.create_course()
97.     vm = factory.create_vm()
98.     print(course.get_labs())
99.     print(vm.start())

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！