设计模式---工厂模式

1、工厂模式

所谓工厂模式，就是作为一个工厂的类有一个对象以及与它关联的多个方法，客户端使用某些参数调用此方法，之后，工厂会据此创建所需类型的对象，然后将他们返回给客户端。

客户端也可以创建对象，那为什么需要工厂的存在呢？

因为工厂拥有以下优点：

• 松耦合，即对象的创建可以独立于类的实现
• 对客户端十分友好，只需知道传递的接口，方法和参数，就可以创建所需的对象了
• 可以轻松的在工厂中添加其他类来创建其他类型的对象，而无需更改客户端代码。
• 工厂还可以重用现有对象。

下面介绍工厂模式的三个变体：

• 简单工厂模式：不符合开闭原则，不属于23种设计模式之一
• 工厂方法模式
• 抽象工厂模式

2、简单工厂模式

简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

from abc import ABCMeta, abstractclassmethod

class Animal(metaclass=ABCMeta):

    @abstractclassmethod  # 抽象类方法
    def do_say(self):
        pass

class Dog(Animal):
    def do_say(self):
        print('www')

class Cat(Animal):
    def do_say(self):
        print('mmm')

class ForestFactory:
    def make_sound(self, object_type):
        print('object_type的类型：',type(eval(object_type)))
        return eval(object_type)().do_say()

if __name__ == '__main__':
    ff = ForestFactory()
    animal = input('输入哪种动物来叫？')
    ff.make_sound(animal)

输入哪种动物来叫？Cat
object_type的类型： <class 'abc.ABCMeta'>
mmm

如上，创建一个名为Animal的抽象产品。Animal是一个抽象的基类（ABCMeta是Python的特殊元类，用来生成类Abstract），它带有方法do_say()。我们利用Animal接口创建了两种产品（Cat和Dog），并实现了do_say()方法来提供这些动物的相应的叫声。之后又为了给客户端提供接口，创建了ForectFactory类，在类中写了一个方法make_sound()，用户就可以将参数（Cat或Dog）传给该方法，就能实现相应的功能。

在看python实现代码时遇到不少知识盲区，参考了下面几篇博客：
Python内置函数(19)——eval
Python装饰器、metaclass、abc模块学习笔记
Python抽象类（abc模块）

简单工厂模式的优缺点

• 优点
  工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。
  客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。
  通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。

• 缺点
  由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。
  使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。
  系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。
  简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。
  不符合开闭原则，当需要创建新产品时，需要修改其他已创建的类。

---

工厂方法模式

在资料的搜寻过程中看到一个例子非常形象，很容易理解，语法也没上面的花里胡哨，虽然可能欠缺了点严谨性。

class LeiFeng():
    def buy_rice(self):
        pass

    def sweep(self):
        pass

class Student(LeiFeng):
    def buy_rice(self):
        print ('大学生帮你买米')

    def sweep(self):
        print ('大学生帮你扫地')


class Volunteer(LeiFeng):
    def buy_rice(self):
        print ('社区志愿者帮你买米')

    def sweep(self):
        print ('社区志愿者帮你扫地')


class LeiFengFactory():
    def create_lei_feng(self):
        pass

class StudentFactory(LeiFengFactory):
    def create_lei_feng(self):
        return Student()

class VolunteerFactory(LeiFengFactory):
    def create_lei_feng(self):
        return Volunteer()


if __name__ == '__main__':
    myFactory = StudentFactory()
    leifeng1 = myFactory.create_lei_feng()

    leifeng1.buy_rice()
    leifeng1.sweep()

解释：它先创建了一个LeiFeng类，它可以买米，扫地两件事，接下来由大学生和社区志愿者来继承这个雷锋精神，也有了这两个优点，之后，又创建了LeiFengFactory类，来培养（生产）大学生和社区志愿者，让大学生（ StudentFactory）和社区志愿者（VolunteerFactory）继承这个培养方案（LeiFengFactory），在主函数中就可以通过调用大学生（StudentFactory）或社区志愿者（VolunteerFactory）类来创建实例，让他们去做好事！

这个工厂方法模式相比于简单工厂方法的不同之处在于当需要创建新的方法时，比如需要让中学生也加入进来，那么就只需在新建两个类即可，无需更改别的类，符合开闭原则。

class LeiFeng():
    def buy_rice(self):
        pass

    def sweep(self):
        pass

class Student(LeiFeng):
    def buy_rice(self):
        print ('大学生帮你买米')

    def sweep(self):
        print ('大学生帮你扫地')


class Volunteer(LeiFeng):
    def buy_rice(self):
        print ('社区志愿者帮你买米')

    def sweep(self):
        print ('社区志愿者帮你扫地')

# ------------新加的类---------------
class MiddleStudent(LeiFeng):
    def buy_rice(self):
        print('中学生帮你买米')
    def sweep(self):
        print ('中学生帮你扫地')
# ----------------------------------

class LeiFengFactory():
    def create_lei_feng(self):
        pass


class StudentFactory(LeiFengFactory):
    def create_lei_feng(self):
        return Student()


class VolunteerFactory(LeiFengFactory):
    def create_lei_feng(self):
        return Volunteer()

# ------------新加的类-----------------
class MiddleStudentFactory(LeiFengFactory):
    def create_lei_feng(self):
        return MiddleStudent()
# ----------------------------------

if __name__ == '__main__':
    myFactory = StudentFactory()
    leifeng1 = myFactory.create_lei_feng()

    leifeng1.buy_rice()
    leifeng1.sweep()

---

抽象工厂模式

通过工厂方法模式我们可以看到，当各个方法一多，如果为每个方法都创建一个类来对应，将会变得很复杂，所以引入了抽象的概念。工厂方法用于创建一个产品，那抽象工厂方法就是创建相关产品的系列，比如航空飞机，由多个工厂不同的零部件，在运输到组装工厂组装…………

下面以制作游戏为例：

在编写一款面向全年龄的游戏，游戏本身需要使用工厂方法进行开发。但游戏也需要考虑不同年龄段玩家的需求和口味不同，所以需要为不同年龄段的玩家针对游戏进行一定的修改。于是在用户输入年龄后，运行符合其年龄的要求的游戏。

class Frog:

    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

    def interact_with(self, obstacle):
        print('{} the Frog encounters {} and {}!'.format(self,
        obstacle, obstacle.action()))


class Bug:

    def __str__(self):
        return 'a bug'

    def action(self):
        return 'eats it'


class FrogWorld:

    def __init__(self, name):
        print(self)
        self.player_name = name

    def __str__(self):
        return '\n\n\t------ Frog World -------'

    def make_character(self):
        return Frog(self.player_name)

    def make_obstacle(self):
        return Bug()


class Wizard:

    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name


    def interact_with(self, obstacle):
        print(
            '{} the Wizard battles against {} and {}!'.format(
            self,
            obstacle,
            obstacle.action()))


class Ork:

    def __str__(self):
        return 'an evil ork'

    def action(self):
        return 'kills it'


class WizardWorld:

    def __init__(self, name):
        print(self)
        self.player_name = name

    def __str__(self):
        return '\n\n\t------ Wizard World -------'

    def make_character(self):
        return Wizard(self.player_name)

    def make_obstacle(self):
        return Ork()

class GameEnvironment:

    def __init__(self, factory):
        self.hero = factory.make_character()
        self.obstacle = factory.make_obstacle()

    def play(self):
        self.hero.interact_with(self.obstacle)

def validate_age(name):
    try:
        age = input('Welcome {}. How old are you? '.format(name))
        age = int(age)
    except ValueError as err:
        print("Age {} is invalid, please try again...".format(err))
        return (False, err)
    return (True, age)

if __name__ == '__main__':
    name = input("Hello. What's your name? ")
    valid_input = False
    while not valid_input:
        valid_input, age = validate_age(name)
        game = FrogWorld if age < 18 else WizardWorld
        environment = GameEnvironment(game(name))
        environment.play()

Hello. What's your name? wayne
Welcome wayne. How old are you? 12


    ------ Frog World -------
wayne the Frog encounters a bug and eats it!

解释：
1、通过一个 GameEnvironment 去管理两个游戏：FrogWorld、WizerdWorld ，根据用户输入的不同的年龄去决定其去玩那个游戏，是青蛙世界还是巫师世界呢？
2、而每个游戏类即 FrogWorld、WizerdWorld ，又分别管理着 两个角色 --（Frog青蛙、Bug臭虫）和（Wizerd巫师、Ork怪兽）
通过这种层层继承的方式，将各个模块管理好，最终根据客户端的输入，来返回不同的游戏世界。

其实无论是工厂模式和抽象工厂模式的思想都是一样的，根据不同的输入，调用相同的接口，得出不同的结果。其内部封装了操作流程，用户无需知道其内部如何其实现的如何进行选择，只管输入便可的得到结果。
参考自