python工厂方法模式原理与实现

时间：2022-11-06 09:20:38|栏目：Python代码|点击：次

一、简介

工厂模式是属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象的过程中不会向客户端暴露实现逻辑，而是通过一个共同的接口类来指向新创建的对象。

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

抽象工厂（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()

结果：