Python设计模式 - 工厂模式

所谓工厂模式，无非就是指向工厂一样去生产产品，只不过这么里的产品不是真实的产品，而是类的实例；而工厂也不是真的工厂，而是一个(工厂)类，这个类提供了获取各种类实例的方法。采用工厂模式，实现了对象创建和类实现两者之间的松耦合。调用端通过固定的接口来获取对象实例，而无需关心创建实例的复杂性。从而降低了代码调用和维护的复杂度。

简单工厂模式

class Phone(object):
    def __repr__(self):
        return "Phone"


class Pad(object):
    def __repr__(self):
        return "Pad"


class SimpleFactory(object):
    @staticmethod
    def produce_product(object_type):
        return eval(object_type)()


if __name__ == "__main__":
    f = SimpleFactory()
    p = SimpleFactory.produce_product("Pad")
    print(p)
    p = SimpleFactory.produce_product("Phone")
    print(p)

简单工厂模式果然够简单。但是一旦我们需要生产更多的产品，那我们就不得不去修改SimpleFactory。这样的话就违反了设计模式的“开放／封闭原则“， 即类或对象及其方法对于扩展来说，应该是开放的，但是修改来说，应该是封闭的。封闭的意思，通常表示现有的类是不应该被修改的。所以我们需要工厂模式。

工厂模式

# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod


class Phone(object):
    def __repr__(self):
        return "Phone"


class Pad(object):
    def __repr__(self):
        return "Pad"


class AbstractFactory(metaclass=ABCMeta):
    @abstractmethod
    def produce_product(self):
        pass


class PhoneFactory(AbstractFactory):

    def produce_product(self):
        return Phone()


class PadFactory(AbstractFactory):

    def produce_product(self):
        return Pad()


phone_factory = PhoneFactory()
print(phone_factory.produce_product())
pad_factory = PadFactory()
print(pad_factory.produce_product())

工厂模式与简单工厂的区别在于，工厂不再需要去判断产品的类型，而是每个产品都有一个子类工厂，让这些子类的工厂去生成对应的产品实例。

抽象工厂模式

# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod

class AndroidPhone(object):
    def __repr__(self):
        return "Android Phone"


class IPhone(object):
    def __repr__(self):
        return "iPhone"


class AndroidPad(object):
    def __repr__(self):
        return "Android Pad"


class IPad(object):
    def __repr__(self):
        return "iPad"


class AbstractFactory(metaclass=ABCMeta):
    @abstractmethod
    def produce_phone(self):
        pass

    @abstractmethod
    def produce_pad(self):
        pass


class AndroidFactory(AbstractFactory):

    def produce_phone(self):
        return AndroidPhone()

    def produce_pad(self):
        return AndroidPad()


class IosFactory(AbstractFactory):

    def produce_phone(self):
        return IPhone()

    def produce_pad(self):
        return IPad()


print(AndroidFactory().produce_phone())
print(AndroidFactory().produce_pad())
print(IosFactory().produce_phone())
print(IosFactory().produce_pad())

抽象工厂模式与工厂模式的区别在于抽象工厂模式的每个工厂类可以制造一种以上的同类产品，而工厂模式的每个工厂类只能生产一种产品。