python工廠方法模式原理與實現

Posted on by

一、簡介

工廠模式是屬於創建型模式，它提供瞭一種創建對象的最佳方式。

在工廠模式中，我們在創建對象的過程中不會向客戶端暴露實現邏輯，而是通過一個共同的接口類來指向新創建的對象。

二、工廠方法模式的主要角色

抽象工廠（Abstract Factory）：提供瞭創建產品的接口，調用者通過它訪問具體工廠的工廠方法newProduct()來創建產品。
具體工廠（ConcreteFactory）：主要實現抽象工廠中的抽象方法，完成具體產品的創建。
抽象產品（Product）：定義瞭產品的規范，描述瞭產品的主要特性和功能。
具體產品（ConcreteProduct）：實現瞭抽象產品定義的接口，由具體工廠來創建，它同具體工廠之間一一對應。

三、簡單工廠模式

內容：不直接向客戶端暴露對象創建實現的細節，而是通過工廠類來負責創建產品類的實例。

具體代碼（jiandan.py）：

from abc import ABCMeta, abstractmethod
 
class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self):
        pass
 
class WechatPay(Payment):
    def pay(self, money):
        print("微信支付%s" % money)
        return
 
class Alipay(Payment):
    def __init__(self, huabei=False):
        self.huabei = huabei
    def pay(self, money):
        if self.huabei:
            print("花唄支付%s" % money)
        else:
            print("支付寶餘額支付%s" % money)
 
class PaymentFactory:
    def create_pay(self, method):
        if method == "wechat":
            return WechatPay()
        elif method == "alipay":
            return Alipay()
        elif method == "huabei":
            return Alipay(huabei=True)
        else:
            raise TypeError("No such payment name %s" % method)
 
# client
pf = PaymentFactory()
p = pf.create_pay("huabei")
p.pay(100)

結果：

ABCMeta是python的一個元類，用於在Python程序中創建抽象基類，抽象基類中聲明的抽象方法，使用abstractmethod裝飾器裝飾。

簡單明瞭的說：創建一個公共的抽象類，然後創建多個支付的類繼承這個抽象類，各種支付類裡實現具體的支付方式，通過工廠類選擇支付方式，這樣客服端隻實現支付方式，不需要知道具體的實現方法。

優點：

隱藏瞭對象創建的實現細節客戶端不需要修改代碼

缺點：

違反瞭單一職責原則，將創建邏輯集中到一個工廠類裡當添加新產品時，需要修改工廠類代碼，違反瞭開閉原則 

四、工廠模式

內容：定義瞭一個用於創建對象的接口（工廠類），讓工廠子類決定實例化哪一個產品類。

具體代碼（factory_method.py）：

from abc import ABCMeta, abstractmethod
 
class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self):
        pass
 
class WechatPay(Payment):
    def pay(self, money):
        print("微信支付%s" % money)
        return
 
class Alipay(Payment):
    def __init__(self, huabei=False):
        self.huabei = huabei
    def pay(self, money):
        if self.huabei:
            print("花唄支付%s" % money)
        else:
            print("支付寶餘額支付%s" % money)
 
class PaymentFactory(metaclass=ABCMeta):
    @abstractmethod
    def create_method(self):
        pass
 
class AlipayFactory(PaymentFactory):
    def create_method(self):
        return Alipay()
 
class WechatFactory(PaymentFactory):
    def create_method(self):
        return WechatPay()
 
class HuabeiFactory(PaymentFactory):
    def create_method(self):
        return Alipay(huabei=True)
 
pf = HuabeiFactory()
p = pf.create_method()
p.pay(100)

結果：

五、抽象工廠模式

 內容：定義一個工廠類接口，讓工廠子類來創建一系列相關或者相互依賴的對象。

與工廠模式相比，抽象工廠模式中的每一個產品都生產一套產品。

具體代碼（abstract_factory.py）：

from abc import ABCMeta, abstractmethod
"""
抽象產品
"""
 
class PhoneShell(metaclass=ABCMeta):
    @abstractmethod
    def show_shell(self):
        pass
 
class OS(metaclass=ABCMeta):
    @abstractmethod
    def show_os(self):
        pass
 
class CPU(metaclass=ABCMeta):
    @abstractmethod
    def show_cpu(self):
        pass
 
# 抽象工廠
class PhoneFactory(metaclass=ABCMeta):
    @abstractmethod
    def make_shell(self):
        pass
    @abstractmethod
    def make_cpu(self):
        pass
    @abstractmethod
    def make_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(CPU):
    def show_cpu(self):
        print("驍龍CPU")
 
class MediaTekCPU(CPU):
    def show_cpu(self):
        print("聯發科CPU")
 
class AppleCPU(CPU):
    def show_cpu(self):
        print("蘋果CPU")
 
class AppleOS(OS):
    def show_os(self):
        print("蘋果OS系統")
 
class AndroidOS(OS):
    def show_os(self):
        print("Android系統")
 
class IOS(OS):
    def show_os(self):
        print("IOS系統")
 
# 具體工廠
class MiFactory(PhoneFactory):
    def make_cpu(self):
        return SnapDragonCPU()
    def make_os(self):
        return AndroidOS()
    def make_shell(self):
        return BigShell()
 
class HuaweiFactory(PhoneFactory):
    def make_cpu(self):
        return MediaTekCPU()
    def make_os(self):
        return AndroidOS()
    def make_shell(self):
        return SmallShell()
 
class IPhoneFactory(PhoneFactory):
    def make_cpu(self):
        return AppleCPU()
    def make_os(self):
        return AppleOS()
    def make_shell(self):
        return AppleShell()
 
class Phone:
    def __init__(self, cpu, os, shell):
        self.cpu = cpu
        self.os = os
        self.shell = shell
    def show_info(self):
        print("手機信息:")
        self.cpu.show_cpu()
        self.os.show_os()
        self.shell.show_shell()
 
def make_phone(factory):
    cpu = factory.make_cpu()
    os = factory.make_os()
    shell = factory.make_shell()
    return Phone(cpu, os, shell)
 
p1 = make_phone(MiFactory())
p1.show_info()

結果：

優點：

將客戶端與類的具體實現相分離每個工廠創建瞭一個完整的產品系列，使得易於交換產品系列有利於產品的一致性（及產品之間的約束關系）

缺點：

難以支持新種類的抽象產品

總結

到此這篇關於python工廠方法模式原理與實現的文章就介紹到這瞭,更多相關python工廠方法模式內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：