设计模式之创造型模式（抽象工厂模式、建造者模式、工厂模式、原型模式、单例模式）

--------------------------------- 创建型模式 --------------------------------
- 隐藏了这些类的实例是如何被创建和放在一起，整个系统关于这些对象所直到的  -
- 由抽象类所定义的接口。这样，创建型模式在创建了什么、谁创建它、它是怎么  -
- 被创建的，以及何时创建这些方面提供了很大的灵活性。                               -
-----------------------------------------------------------------------------
1. 抽象工厂模式

提供一个创建一系列或相关依赖对象的接口，而无需制定它们具体的类。

#!/usr/bin/env python
#coding:utf-8
'''
抽象工厂模式
模式特点：提供一个创建一系列相关或相互依赖对象的接口，而无需知道能够它们具体的类。
程序实例：提供对不同的数据库访问的支持。
代码特点：无
注：'I'开头的类是接口，需要子类去实现，此命名方法为C#风格，python无要求。
'''
class IUser(object):
    def get_user(self):
        pass
    
    def insert_user(self):
        pass
    
class IDepartment(object):
    def get_department(self):
        pass
    
    def insert_department(self):
        pass
    
class CAccessUser(IUser):
    def get_user(self):
        print 'Access database get user information'
        
    def insert_user(self):
        print 'Access database insert user information'
        
class CAccessDepartment(IDepartment):
    def get_department(self):
        print 'Access database get department information'
        
    def insert_department(self):
        print 'Access database insert department information'
        
class CSqlUser(IUser):
    def get_user(self):
        print 'SQL database get user information'
        
    def insert_user(self):
        print 'SQL database insert user information'
        
class CSqlDepartment(IDepartment):
    def get_department(self):
        print 'SQL database get department information'
        
    def insert_department(self):
        print 'SQL database insert department information'
        
class IFactory(object):
    def create_user(self):
        pass
    
    def create_department(self):
        pass
    
class AccessFactory(IFactory):
    def create_user(self):
        temp = CAccessUser()
        return temp
    
    def create_department(self):
        temp = CAccessDepartment()
        return temp
    
class SqlFactory(IFactory):
    def create_user(self):
        temp = CSqlUser()
        return temp
    
    def create_department(self):
        temp = CSqlDepartment()
        return temp
    
if __name__ == '__main__':
    factory = SqlFactory() # 如果要换成access数据库，则只需要更改这行为AccessFactory即可
    user = factory.create_user()
    depart = factory.create_department()
    user.get_user()
    depart.get_department()

2. 建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

#!/usr/bin/env python
#coding:utf-8
'''
建造者模式
模式特点：讲一个复杂对象的构建（Director）与它的表示（Builder）分离，使得同样的构
        建过程可以创建不同的表示（ConcreteBuilder）。
程序实例：“画”出一个四肢健全（头身手脚）的小人。
代码特点：无
建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时适用的模式
'''
class Person(object):
    def create_head(self):
        pass
    
    def create_hand(self):
        pass
    
    def create_body(self):
        pass
    
    def create_foot(self):
        pass
    
class ThinPerson(Person):
    def create_head(self):
        print 'draw thin head'
    
    def create_hand(self):
        print 'draw thin hand'
        
    def create_body(self):
        print 'draw thin body'
        
    def create_foot(self):
        print 'draw thin foot'
        
class FatPerson(Person):
    def create_head(self):
        print 'draw fat head'
    
    def create_hand(self):
        print 'draw fat hand'
        
    def create_body(self):
        print 'draw fat body'
        
    def create_foot(self):
        print 'draw fat foot'
        
class Director(object):
    def __init__(self, temp):
        self.p = temp
        
    def create(self):
        self.p.create_head()
        self.p.create_body()
        self.p.create_hand()
        self.p.create_foot()
        
if __name__ == '__main__':
    p = FatPerson()
    d = Director(p)
    d.create()

3. 工厂模式  -- 设计的开始

定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂模式使一个类的实例化延迟到其子类

#!/usr/bin/env python
#coding:utf-8
'''
工厂模式
模式特点：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的
        实例化延迟到其子类。
程序实例：基类雷锋类，派生出学生类和志愿者类，由这两种子类完成“学雷锋”工作。子类的创
        建由雷锋工厂的对应的子类完成
代码特点：客户端决定实例化哪一个工厂来实现子类。
'''
class LeiFeng(object):
    def sweep(self):
        '''扫地'''
        print 'LeiFeng sweep'

class Student(LeiFeng):
    def sweep(self):
        print 'Student sweep'

class Volenter(LeiFeng):
    def sweep(self):
        print 'Volenter sweep'


class LeiFengFactory(object):
    def create_leifeng(self):
        temp = LeiFeng()
        return temp
        
class StudentFactory(LeiFengFactory):
    def create_leifeng(self):
        temp = Student()
        return temp

class VolenterFactory(LeiFengFactory):
    def create_leifeng(self):
        temp = Volenter()
        return temp
    
if __name__ == '__main__':
    sf = StudentFactory()
    s = sf.create_leifeng()
    s.sweep()
    
    sdf = VolenterFactory()
    sd = sdf.create_leifeng()
    sd.sweep()
    
'''
如果用简单工厂模式实现，则调用一个新增加的行为，就要重新实例化一个对象
'''

4. 原型模式

用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

#!/usr/bin/env python
#coding:utf-8
'''
原型模式
模式特点：用原型实例制定创建对象的种类，并且通过拷贝这些原型创建新的对象。
程序实例：从简历模板生成新的简历
代码特点：简历类Resume提供的clone()方法并不是真正的clone， 只是为已存在对象增加一
        次引用。
python为对象提供的copy模块中的copy方法和deepcopy方法已经实现了原型模式，但由于例
子的层次较浅，二者看不出区别。
'''
import copy

class WorkExp(object):
    place = ''
    year = 0
    
class Resume(object):
    name = ''
    age = 0
    
    def __init__(self, n):
        self.name = n
    
    def set_age(self, a):
        self.age = a
    
    def set_work_exp(self, p, y):
        self.place = p
        self.year = y
        
    def display(self):
        print self.age
        print self.place
        print self.year
        
    def clone(self):
        # 实际不是‘克隆’，只是返回了自己
        return self
    
if __name__ == '__main__':
    a = Resume('a')
    b = a.clone()
    c = copy.copy(a)
    d = copy.deepcopy(a)
    
    a.set_age(7)
    b.set_age(12)
    c.set_age(15)
    d.set_age(18)
    
    a.set_work_exp('PrimarySchool', 1996)
    b.set_work_exp('MidSchool', 2001)
    c.set_work_exp('HighSchool', 2004)
    d.set_work_exp('UniversitySchool', 2007)
    
    a.display()
    b.display()
    c.display()
    d.display()

5. 单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

#!/usr/bin/env python
#coding:utf-8
'''
单例模式
模式特点：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
程序实例：公司人员的组织结构
代码特点：无
我要问的是，python真的需要单例模式吗？我指像其他编程语言中的单例模式。
答案是：不需要！
因为python有模块（module），最pythonic的单例典范。
模块在一个应用程序中只有一份，它本身就是单例的，将你所需要的树形和方法，直接暴露在模
块中变成模块的全局变量和方法即可！
'''
print '---------- 方法1 ----------'
# 重构__new__方法
# 并将一个类的实例绑定到类变量_instance上
# 如果cls._instance为None，说明该类还没有被实例化，实例化该类，返回
# 如果cls._instance不为None，直接返回cls._instance
class Singleton(object):
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            org = super(Singleton, cls)
            cls._instance = org.__new__(cls,*args, **kw)
        return cls._instance
    
class MyClass(Singleton):
    a = 1

one = MyClass()
two = MyClass()

two.a = 3
print one.a    #3
# one 和 two 完全相同，可以用id()，==，is检查，结果全为True

print '---------- 方法2 ----------'
#共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)
#同一个类的所有实例天然拥有相同的行为(方法),
#只需要保证同一个类的所有实例具有相同的状态(属性)即可
#所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(dict)
#可参看:http://code.activestate.com/recipes/66531/
class Singleton2(object):
    _state = {}
    def __new__(cls, * args, **kw):
        ob = super(Singleton2, cls).__new__(cls, *args, **kw)
        ob.__dict__ = cls._state
        return obj

class MyClass2(Singleton2):
    a = 2

one = MyClass2()
two = MyClass2()

two.a = 3
print one.a # 3
# one 和 two 是两个不同的对象，id, ==, is的结果都是fals
# 但是one和two具有相同的__dict__属性
id(one.__dict__) == id(two.__dict__)

print '---------- 方法3 ----------'
# 方法1的升级版本
# 使用__metaclass__（元类）的高级python用法
class Singleton3(object):
    def __init__(cls, name, bases, dict):
        super(Singleton3, cls).__init__(name, bases, dict)
        cls._instance = None
        
    def __call__(cls, *args, **kw):
        if cls._instance is None:
            cls._instance = super(Singleton3, cls).__call__(*args, **kw)
        return cls._instance

class MyClass3(object):
    __metaclass__ = Singleton3
    
one = MyClass3()
two = MyClass3()
# one 和 two 完全相同，可以用id()，==，is检查，结果全为True

print '---------- 方法4 ----------'
# 方法1更高级的版本
# 使用装饰器（decorator）
# 更pythonic，更elegant的方法
# 单例本身根本不知道自己是单例的，因为它本身（自己的代码）并不是单例的
def singleton(cls, *args, **kw):
    instances = {}
    def _singleton():
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return _singleton

@singleton
class MyClass4(object):
    a = 1
    def __init__(self, x=0):
        self.x = x

one = MyClass4()
two = MyClass4()
# one 和 two 完全相同，可以用id()，==，is检查，结果全为True