设计模式之工厂模式（factory pattern）

之前有在学设计模式，感觉还是把一些常用的设计模式总结出来，方便我以后的回顾。

今天我要写的是设计模式之工厂模式

工厂模式一般包含工厂方法（factory method）和抽象工厂（abstract factory）

（1）工厂方法（factory method）

所有工厂模式都用来封装对象的创建。工厂方式模式通过让子类决定该创建的对象是什么，来达到讲对象创建的过程封装的目的。

只是一些概念比较难理解，还是直接看代码（以下代码来自<HeadFirst设计模式>）

java 版本：

public class SimplePizzaFactory {
     public Pizza createPizza(String type) {
          Pizza pizza = null;

          if (type.equals("cheese")) {
               pizza = new CheesePizza();
          } else if (type.equals("pepperoni")) {
               pizza = new PepperoniPizza();p
          } else if (type.equals("clam")) {
               pizza = new ClamPizza();
          }
     }
     return pizza;
}

python 版本：

class JSONParser:
    def parse(self, raw_data):
        return json.loads(raw_data)

class XMLParser:
    def parse(self, raw_data):
        return xml2dict(raw_data)

def new_parser(type, **kwargs):
    if type == 'json':
        return JSONParser()
    elif type == 'xml':
        return XMLParser()

parser = new_parser('json')
with open('hello.json') as fp:
    data = parser.parse(fp.read())
print(data)

解释：

（1）有两个类：JSONParser 和 XMLParser ，工厂则是 new_parser()

（2）从代码 parser = new_parser('json') 看得出来在实例化对象的时候，只需要考虑哪种结构，而不是具体的类。

总结：

“工厂模式”所带来的好处：

将创建对象的代码集中在一个对象或方法中，可以避免代码中的重复，并且更方便以后的维护。这也意味着客户在实例化对象时，只会依赖于结构，而不是具体类。

（2）抽象工厂（abstract factory）

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类

代码来源：https://github.com/faif/python-patterns/blob/master/creational/abstract_factory.py

import six
import abc
import random


class PetShop(object):

    """A pet shop"""

    def __init__(self, animal_factory=None):
        """pet_factory is our abstract factory.  We can set it at will."""

        self.pet_factory = animal_factory

    def show_pet(self):
        """Creates and shows a pet using the abstract factory"""

        pet = self.pet_factory.get_pet()
        print("We have a lovely {}".format(pet))
        print("It says {}".format(pet.speak()))
        print("We also have {}".format(self.pet_factory.get_food()))


# Stuff that our factory makes

class Dog(object):

    def speak(self):
        return "woof"

    def __str__(self):
        return "Dog"


class Cat(object):

    def speak(self):
        return "meow"

    def __str__(self):
        return "Cat"


# Factory classes

class DogFactory(object):

    def get_pet(self):
        return Dog()

    def get_food(self):
        return "dog food"


class CatFactory(object):

    def get_pet(self):
        return Cat()

    def get_food(self):
        return "cat food"


# Create the proper family
def get_factory():
    """Let's be dynamic!"""
    return random.choice([DogFactory, CatFactory])()


# Implementation 2 of an abstract factory
@six.add_metaclass(abc.ABCMeta)
class Pet(object):

    @classmethod
    def from_name(cls, name):
        for sub_cls in cls.__subclasses__():
            if name == sub_cls.__name__.lower():
                return sub_cls()

    @abc.abstractmethod
    def speak(self):
        """"""



class Kitty(Pet):
    def speak(self):
        return "Miao"


class Duck(Pet):
    def speak(self):
        return "Quak"


# Show pets with various factories
if __name__ == "__main__":
    for i in range(3):
        shop = PetShop(get_factory())
        shop.show_pet()
        print("=" * 20)

    for name0 in ["kitty", "duck"]:
        pet = Pet.from_name(name0)
        print("{}: {}".format(name0, pet.speak()))

### OUTPUT ###
# We have a lovely Cat
# It says meow
# We also have cat food
# ====================
# We have a lovely Dog
# It says woof
# We also have dog food
# ====================
# We have a lovely Cat
# It says meow
# We also have cat food
# ====================
# kitty: Miao
# duck: Quak

总结：工厂方法和抽象工厂的选择: 先使用工厂方法，当发现需要使用一系列工厂方法来创建多个对象的时候， 可以考虑把这些创建对象的过程合并到一个抽象工厂

参考资料：

（1）https://sourcemaking.com/design_patterns/

（2）http://link.zhihu.com/?target=https%3A//github.com/faif/python-patterns