創建型模式 ---- 設計模式第3章

1. 簡單工廠模式

       簡單工廠模式不是23中設計模式中的，但是必須要知道。簡單工廠模式不直接向客戶端暴露對象創建的細節，而是通過一個工廠類來負責創建產品類的實例。簡單工程模式的角色有：工廠角色、抽象產品角色、具體產品角色，通過例子來加深理解：

from abc import ABCMeta, abstractmethod


# 抽象產品角色，以什麼樣的表現去使用
class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        pass

# 產品角色
class Alipay(Payment):
    def __init__(self, use_huabei=False):
        self.use_huabei = use_huabei

    def pay(self, money):
        if self.use_huabei == True:
            print("花唄支付了{0}元!".format(money))
        else:
            print("支付寶餘額支付了{0}元!".format(money))

# 產品角色
class WechatPay(Payment):
    def pay(self, money):
        print("微信支付了%d元!" % (money))

# 工廠類角色
class PaymentFactory:
    def ctreate_payment(self, method):
        if method == 'Alipay':
            return Alipay()
        elif method == 'WechatPay':
            return WechatPay()
        elif method == 'HuabeiPay':
            return Alipay(use_huabei=True)
        else:
            raise TypeError('No such payment named %s' % method)

# 客戶端調用。不直接向客戶端暴露對象創建的實現細節，而是通過一個工廠類來負責創建產品類的實例
pf = PaymentFactory()
p = pf.ctreate_payment('HuabeiPay')
p.pay(100)

2. 工廠方法模式

       簡單工廠模式只創建一個工廠類，當有新的產品時，需要修改工廠類代碼。而 工廠方法模式的每個具體產品對應一個具體的工廠類，不需要修改工廠類代碼，並且同時也能滿足隱藏對象創建的細節。但是工廠方法模式也是有缺點的，就是 每增加一個具體產品類，就必須增加一個相應的具體方法。
       工廠模式方法模式的概念是定義了一個用於創建對象的接口(工廠接口)，讓子類決定實例化那一個產品類。角色有抽象工廠角色、具體工廠角色、抽象產品角色和具體產品角色。通過例子來加深理解，每個具體產品對應一個具體的工廠類：

from abc import ABCMeta, abstractmethod

# 抽象產品角色
class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        pass

# 具體產品角色
class Alipay(Payment):
    def __init__(self, use_huabei=False):
        self.use_huabei = use_huabei

    def pay(self, money):
        if self.use_huabei == True:
            print("花唄支付了{0}元!".format(money))
        else:
            print("支付寶餘額支付了{0}元!".format(money))

class WechatPay(Payment):
    def pay(self, money):
        print("微信支付了%d元!" % (money))

# 抽象工廠角色
class PaymentFactory(metaclass=ABCMeta):
    @abstractmethod
    def create_payment(self):
        pass

# 具體工廠角色
class AlipayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()

class WechatPayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()

class HuabeiFactory(PaymentFactory):
    def create_payment(self):
        return Alipay(use_huabei=True)

hfp = HuabeiFactory().create_payment()
hfp.pay(100)  # 花唄支付了100元!

缺點是每增加一個具體產品類，就必須增加一個相應的具體方法：

from abc import ABCMeta, abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        pass

class Alipay(Payment):
    def __init__(self, use_huabei=False):
        self.use_huabei = use_huabei

    def pay(self, money):
        if self.use_huabei == True:
            print("花唄支付了{0}元!".format(money))
        else:
            print("支付寶餘額支付了{0}元!".format(money))

class WechatPay(Payment):
    def pay(self, money):
        print("微信支付了%d元!" % (money))

class BankPay(Payment):
    def pay(self, money):
        print("銀行支付了%d元!" % (money))

# 創建產品的工廠類的接口
class PaymentFactory(metaclass=ABCMeta):
    @abstractmethod
    def create_payment(self):
        pass

# 工廠類
class AlipayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()

# 工廠類
class WechatPayPayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()

# 工廠類
class HuabeiPayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay(use_huabei=True)

# 新增加銀行支付的工廠類
class BankPayFactory(PaymentFactory):
    def create_payment(self):
        return BankPay()

bfp = BankPayFactory().create_payment()
bfp.pay(100)  # 銀行支付了100元!

3. 抽象工廠模式

       抽象工廠模式：定義一個工廠類的接口讓工廠子類來創建一系列相關或者相互依賴的對象。相比工廠方法模式，抽象工廠模式中的每一個具體工廠都生產一套產品。下面是生產廠商生產一部手機的例子：生產一部手機如果說只需要手機殼、CPU和操作系統這三個類對象，其中每個類對象都有不同的種類。對每個具體工廠，分別生產一部手機需要的三個對象。通過例子來加深理解：

from abc import ABCMeta, abstractmethod

# ------抽象的產品------
class PhoneShell(metaclass=ABCMeta):
    @abstractmethod
    def show_shell(self):
        pass

class PhoneCPU(metaclass=ABCMeta):
    @abstractmethod
    def show_cpu(self):
        pass

class PhoneOS(metaclass=ABCMeta):
    @abstractmethod
    def show_os(self):
        pass
        
# ------具體的產品------
class SmallShell(PhoneShell):
    def show_shell(self):
        print('普通手機小手機殼')

class BigShell(PhoneShell):
    def show_shell(self):
        print('普通手機大手機殼')

class AppleShell(PhoneShell):
    def show_shell(self):
        print('蘋果手機殼')

class SnapDragonCPU(PhoneCPU):
    def show_cpu(self):
        print('驍龍CPU')

class HuaweiCPU(PhoneCPU):
    def show_cpu(self):
        print('化爲CPU')

class AppleCPU(PhoneCPU):
    def show_cpu(self):
        print('蘋果CPU')

class AndroidOS(PhoneOS):
    def show_os(self):
        print('IOS系統')

class AppleOS(PhoneOS):
    def show_os(self):
        print('安卓系統')

# ------抽象的工廠------
class PhoneFactory(metaclass=ABCMeta):
    @abstractmethod
    def make_shell(self):
        pass

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass

# ------具體的工廠------
class HuaweiFactory(PhoneFactory):
    def make_shell(self):
        return SmallShell()

    def make_cpu(self):
        return HuaweiCPU()

    def make_os(self):
        return AndroidOS()

class AppleFactory(PhoneFactory):
    def make_shell(self):
        return AppleShell()

    def make_cpu(self):
        return AppleCPU()

    def make_os(self):
        return AppleOS()

# ------客戶端------
class Phone:
    def __init__(self, shell, cpu, os):
        self.shell = shell
        self.cpu = cpu
        self.os = os

    def show_info(self):
        print('手機信息：')
        self.shell.show_shell()
        self.cpu.show_cpu()
        self.os.show_os()

def make_phone(factory):
    shell = factory.make_shell()
    cpu = factory.make_cpu()
    os = factory.make_os()
    return Phone(shell, cpu, os)

p = make_phone(HuaweiFactory())
p.show_info()
"""
手機信息：
普通手機小手機殼
化爲CPU
IOS系統
"""

       抽象工廠模式的角色有：抽象工廠角色、具體工廠角色、抽象產品角色、具體產品角色和客戶端。抽象工廠模式的優點是：將客戶端和類的具體實現相分離；每個工廠創建了一個完整的產品系列，使得易於交換產品系列；有利於產品的一致性，即產品之間的約束關係。缺點是：難以支持新種類抽象產品。

4. 建造者模式

       建造者模式是將一個複雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。角色有抽象創建者、具體創建者、指揮者和產品。建造者模式與抽象工廠模式相似，也用來創建複雜的對象。主要區別是 建造者模式着重一步步構造一個複雜對象(控制順序)。而抽象工廠模式着重於多個系列的產品對象，寫個例子來加強理解：

from abc import ABCMeta, abstractmethod

# ------產品------
class Player:
    def __init__(self, face=None, body=None, arms=None, legs=None):
        self.face = face
        self.body = body
        self.arms = arms
        self.legs = legs

    def __str__(self):
        return '%s,%s,%s,%s' % (self.face, self.body, self.arms, self.legs)

# ------抽象建造者------
class PlayerBuilder(metaclass=ABCMeta):
    @abstractmethod
    def build_face(self):
        pass

    @abstractmethod
    def build_body(self):
        pass

    @abstractmethod
    def build_arms(self):
        pass

    @abstractmethod
    def build_legs(self):
        pass

# ------具體建造者,隱藏了一個產品的內部結構------
class GirlBuilder(PlayerBuilder):
    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = '漂亮的臉蛋'

    def build_body(self):
        self.player.body = '苗條的身材'

    def build_arms(self):
        self.player.arms = '細細的胳膊'

    def build_legs(self):
        self.player.legs = '大長腿'

# ------具體建造者，表示代碼------
class MonsterBuilder(PlayerBuilder):
    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = '綠臉'

    def build_body(self):
        self.player.body = '魁梧的身體'

    def build_arms(self):
        self.player.arms = '粗壯的胳膊'

    def build_legs(self):
        self.player.legs = '粗壯的大腿'

# ------指揮者，構造代碼(構造代碼和表示代碼分開)，可以對構造過程進行更加精細地控制------
class PlayerDirectory():
    def builder_player(self, builder):
        """
        隱藏了裝配過程
        :param builder:
        :return:
        """
        builder.build_face()
        builder.build_body()
        builder.build_arms()
        builder.build_legs()
        return builder.player

# ------客戶端------
builder = GirlBuilder()
director = PlayerDirectory()
p = director.builder_player(builder)
print(p)  # 漂亮的臉蛋,苗條的身材,細細的胳膊,大長腿

5. 單例模式

       單例模式保證一個類只有一個實例，並提供一個訪問它的全局訪問點。優點是對唯一實例的受控訪問（只有一個實例），單例相當於全局變量，但防止了命名空間被污染（變量命名不會有衝突）。寫個例子來加深理解：

class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

class MyClass(Singleton):
    def __init__(self, a):
        self.a = a

ms1 = MyClass(1)
ms2 = MyClass(2)
print(ms1.a, ms2.a)
print(id(ms1), id(ms2))
"""
2 2
139843914173312 139843914173312
"""

       如果實例只出現一次，如日誌系統中只需要創建一個日誌對象（否則兩個日誌對象同時操作一個文件就會造成操作衝突）；數據庫連接池只需要創建一個對象來操作數據庫（否則增加系統開銷，浪費系統資源）；操作系統只需要創建一個文件系統對象來操作文件系統。

6. 創建型模式概述

       抽象工廠模式和建造者模式相比於簡單工廠模式和工廠方法模式而言更加靈活也更加複雜。通常情況下，軟件設計以簡單工廠模式或工廠方法模式開始，當發現設計需要更大的靈活性的時候，則向更加複雜的設計模式演化。