简单工厂模式，工厂方法和抽象工厂模式 python实现_简单工厂和抽象工厂 python-CSDN博客

记录学习

本系列文章是希望将软件项目中最常见的设计模式用通俗易懂的语言来讲解清楚，并通过Python来实现，每个设计模式都是围绕如下三个问题：

为什么？即为什么要使用这个设计模式，在使用这个模式之前存在什么样的问题？
是什么？通过Python语言来去实现这个设计模式，用于解决为什么中提到的问题。
怎么用？理解了为什么我们也就基本了解了什么情况下使用这个模式，不过在这里还是会细化使用场景，阐述模式的局限和优缺点。

这次的主角是简单工厂，工厂方法和抽象工厂模式，由于这几个模式联系紧密，有一定的相似性，所以放在一起来讲。

简单工厂模式

为什么

工厂模式里最常举的例子就是Pizza店的例子，我们就用这个经典的例子来说吧。假设我们开了一个Pizza店，然后我们多种Pizza供顾客选用，如下：

class CheesePizza(object):
...
class VegetablePizza(object):
...
# 可以继续定义多种类型的Pizza
...

然后可以定义我们的Pizza店用以生产Pizza

class PizzaStore(object):
def order_pizza(self, pizza_type):
# ------------------------------------
if pizza_type == "cheese":
self.pizza = CheesePizza()
elif pizza_type == "vegetable":
self.pizza = VegetablePizza()
else:
self.pizza = SeafoodPizza()
# -------------------------------------
self.pizza.prepare()
self.pizza.bake()
self.pizza.cut()
self.pizza.box()
return self.pizza

这里问题在于我们的产品（也就是不同种类的Pizza）可能会变化，比如过了段时间会新增几种类型的Pizza，也会去掉某些不受欢迎的Pizza类型，这个时候我们就需要修改不断修改order_pizza()中的代码（横线包起来的那部分代码）。而我们的设计原则之一就是将“变化”抽离出来，进行封装。这就是简单工厂模式的初衷。

是什么

简单工厂模式，就是将创建不同类型实例的代码抽离出来，封装成一个工厂类(实际我觉得用一个函数更直接)。这个工厂类就是专门用于生产不同的产品（这里就是pizza产品）给客户端（这里就是order_pizza)。客户不需要知道怎么生产出这些pizza，客户只需要告诉工厂，我需要cheese pizza还是其它类型的pizza就可以了，然后工厂会去返回给客户相应的pizza。代码如下：

class SimplePizzaFactory(object):
@staticmethod
def create_pizza(pizza_type):
pizzas = dict(cheese=CheesePizza, vegetable=VegetablePizza, seafood=SeafoodPizza)
return pizzas[pizza_type]()

原来的PizzaStore则更改为：

class PizzaStore(object):
def order_pizza(self, pizza_type):
# ------------------------------------
self.pizza = SimplePizzaFactory.create_pizza(pizza_type)
# -------------------------------------
self.pizza.prepare()
self.pizza.bake()
self.pizza.cut()
self.pizza.box()
return self.pizza

怎么用

看到上边的代码，很多同学可能会疑惑，这个就是代码转移到别处而已，似乎没有什么卵用啊。其实简单工厂模式除了将创建实例的代码进行了封装，使得代码更加清晰以外，另一个好处就是，当有其它客户需要创建同样的实例时就可以直接调用工厂的create_pizza()了。比如我们有了一个送外卖的类：

class PizzaTakeOut(object):
def order_pizza(self, pizza_type):
# ------------------------------------
self.pizza = SimplePizzaFactory.create_pizza(pizza_type)
# -------------------------------------
...

在这种情况下，如果新增或者删除某一个产品（Pizza类）我们只需要简单地更新一处代码（即简单工厂中的创建实例的代码）就可以了。
再一个好处是，一个大的系统往往是分不同的层次和模块进行分别开发的，当开发客户端（这里就是指PizzaStore）程序员和开发底层产品（这里指各种Pizza）的程序员不是同一个人就会非常有用，因为开发客户端的程序员通过工厂创建对象时就不需要关注到底怎么创建出不同的产品的，他只需要将客户的需求（pizza_type)传递给工厂就可以了。

工厂方法和抽象工厂模式

为什么？

在简单工厂中我们一般情况下只是创建了一种产品，但是对于一组产品的创建，往往很难应付，想想下如果我们要创建一组关于汽车的零部件产品，如果用简单工厂模式，代码可能如下：

class SimpleCarPartsFactory(object):
def __init__(self, car_type):
self.car_type = car_type
def create_engines(self):
engines = dict(small=SmallEngines, medium=MediumEngines, big=BigEngines)
return engines[self.car_type]()
def create_wheels(self):
wheels = dict(small=SmallWheeles, medium=MediumWheeles, big=BigWheeles)
return wheels[self.car_type]()
...

这个代码虽然也可以勉强使用，但是试想一下，如果我再添加一个superbig类型的汽车，那么是不是就需要修改所有的create方法？如果修改某个组件类，或者删除某一种类型的组件是否都需要去修改这个类呢？如果这些都是你一个人来改呢？。。。。。。
好吧，这就是我们为什么需要工厂方法和抽象工厂的原因。

是什么

首先来说下什么是工厂方法，工厂方法就是将客户端程序抽象出一个父类，然后在子类中实现创建产品的方法，这个方法就是工厂方法

class PizzaStore(object): # 客户端程序抽象出父类
def order_pizza(self, pizza_type):
# ------------------------------------
self.pizza = self.create_pizza(pizza_type)
# -------------------------------------
self.pizza.prepare()
self.pizza.bake()
self.pizza.cut()
self.pizza.box()
return self.pizza
def create_pizza(self, pizza_type): #抽象的工厂方法
pass
class BeijingPizzaStore(PizzaStore): # 客户端程序的子类
def create_pizza(self, pizza_type): # 具体的工厂方法
pizzas = dict(cheese=BeijingCheesePizza, vegetable=BeijingVegetablePizza, seafood=BeijingSeafoodPizza) # 不同的子类可能使用不同的产品
return pizzas[pizza_type]()
class ShanghaiPizzaStore(PizzaStore):
def create_pizza(self, pizza_type):
pizzas = dict(cheese=ShanghaiCheesePizza, vegetable=ShanghaiVegetablePizza, seafood=ShanghaiSeafoodPizza)
return pizzas[pizza_type]()

这里如果我们用简单工厂模式去实现的话，就要给create方法多传递一个地区的参数（如："beijing")，然后在方法中要做两次条件判断（地区和pizza类型），这样做就有点不太优雅了。
不论怎么样，我们现在已经了解了什么是工厂方法模式，那么现在要看另一个设计模式-抽象工厂模式，这个模式中实际使用了工厂方法模式。而抽象工厂模式才是真正解决了我们之前说的一组产品的问题。
使用抽象工厂来实现汽车组件的实例生产：

class AbstractCarPartsFactory(object): #Python中这个抽象类甚至可以省略，但是为了表达清晰，还是创建了这个父类
def create_engine(self):
passs
def create_wheels(self):
pass
...
class SmallCarPartsFactory(AbstractCarPartsFactory): #不同类型的汽车工厂维护自身的实例创建
def create_engine(self): #具体的工厂方法
return SmallEngine()
def create_wheels(self):
return SmallWheels()
...
class MediumCarPartsFactory(AbstractCarPartsFactory):
def create_engine(self):
return SmallEngine()
def create_wheels(self):
return SmallWheels()
...
...

使用时如下：

class CarFactory(object):
def create_car(self, car_type):
car_factorys = dict(
small=SmallCarPartsFactory, medium=MediumCarPartsFactory,
big=BigCarPartsFactory)
self.carparts_factory = car_factorys[car_type]()
self.prepare_parts():
self.engine = self.cartparts_factory.create_engine()
self.wheels = self.cartparts_factory.create_wheels()
...
self.compose_parts()
self.painting()
...

由以上例子可以看出我们首先将生产一组产品的工厂抽象成一个工厂类（即，AbstractCarPartsFactory)，这正是抽象工厂这个名字的由来。随后我们通过不同子类工厂来实现具体产品的实例化，在子类中实现产品实例化，是不是听着耳熟，对，这里正是利用了工厂方法模式，所以抽象工厂模式利用了工厂方法模式，但它们却是不同的模式，这里注意区分。
这时，如果我们想增加一个新的汽车类型，那么只需要添加一个子类即可，是不是很轻松的赶脚？