单例设计模式

确保类只有一个对象被创建
为对象提供一个全局都可以访问的入口
控制共享资源的并发访问

1 简单实现：

通过覆盖__new__方法来控制对象的创建。

class Singleton(object):
    def __new__(cls):
        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance

s1 = Singelton()
s2 = Singleton()

更进一步，可以改写成：

class HealthCheck:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not HealthCheck._instance:
            HealthCheck._instance = super(HealthCheck, cls).__new__(cls, *args, **kwargs)
        return HealthCheck._instance
    
    def __init__(self):
        self.servers = []
    def do1(self):
       pass
    def do2(self):
        pass

2 python元类

实例化对象时，该类所继承的元类的__call__方法控制着该过程。

 1 class MetaSingleton(type):
 2     _instance = {}
 3     def __call__(cls, *args, **kwargs):
 4         if cls not in cls._instance:
 5             cls._instance[cls] = super(MetaSingleton, cls).__call__(*args, **kwargs)
 6         return cls._instance
 7 
 8 class Logger(metaclass = MetaSingleton):
 9     pass
10 
11 logger1 = Logger()
12 logger2 = Logger()

工厂模式

简单工厂模式

工厂方法模式

抽象工厂模式

代理模式

为其他对象提供了一个代理，从而实现了对原始对象的访问控制。
相当于增加了一个层或接口。增加了安全性。
代理模式与装饰器不同，后者是在原有对象上动态的添加新的行为；而前者是在程序编译时完成的，旨在控制外界对被代理对象的访问。

 1 class Actor(object):
 2     def __init__(self):
 3         self.isBusy = False
 4 
 5     def occupied(self):
 6         self.isBusy = True
 7         print(type(self).__name__, "is occupied with current movie")
 8 
 9     def available(self):
10         self.isBusy = False
11         print(type(self).__name__, "is free for the movie")
12    
13     def getStatus(self):
14     return self.isBusy
15 
16 
17 class Agent(object):
18     def __init__(self):
19         self.principal = None
20 
21     def __work(self):
22         self.actor = Actor()
23         if self.actor.getStatus():
24             self.actor.occupied()
25         else:
26             self.available()
27 
28 
29 if __name__ == '__main__':
30     r = Agent()
31     r.work()

代理的分类：

虚拟代理
远程代理
保护代理
智能代理