实例讲解Python设计模式编程之工厂方法模式的使用

工厂方法模式是简单工厂模式的进一步抽象和推广,它不仅保持了简单工厂模式能够向客户隐藏类的实例化过程这一优点,而且还通过多态性克服了工厂类过于复杂且不易于扩展的缺点。在工厂方法模式中,处于核心地位的工厂类不再负责所有产品的创建,而是将具体的创建工作交由子类去完成。工厂方法模式中的核心工厂类经过功能抽象之后,成为了一个抽象的工厂角色,仅负责给出具体工厂子类必须实现的接口,而不涉及哪种产品类应当被实例化这一细节。工厂方法模式的一般性结构如下图所示,图中为了简化只给出了一个产品类和一个工厂类,但在实际系统中通常需要设计多个产品类和多个工厂类。

工厂方法模式的实质是将对象的创建延迟到其子类实现,即由子类根据当前情况动态决定应该实例化哪一个产品类。从上图可以看出,工厂方法模式涉及到抽象工厂角色、具体工厂角色、抽象产品角色和具体产品角色四个参与者。

  • 抽象工厂(Creator)角色  是工厂方法模式的核心,它负责定义创建抽象产品对象的工厂方法。抽象工厂不能被外界直接调用,但任何在模式中用于创建产品对象的工厂类都必须实现由它所定义的工厂方法。
  • 具体工厂(Concrete Creator)角色  是工厂方法模式的对外接口,它负责实现创建具体产品对象的内部逻辑。具体工厂与应用密切相关,可以被外界直接调用,创建所需要的产品。
  • 抽象产品(Product)角色  是工厂方法模式所创建的所有对象的父类,它负责描述所有具体产品共有的公共接口。
  • 具体产品(Concrete Product)角色  是工厂方法模式的创建目标,所有创建的对象都是充当这一角色的某个具体类的实例。

抽象工厂角色负责声明工厂方法(factory method),用来"生产"抽象产品,以下是抽象工厂的示例性Python代码:

creator.py
class Creator:
  """ 抽象工厂角色 """

 # 创建抽象产品的工厂方法
 def factoryMethod(self):
 pass

具体工厂角色负责创建一个具体产品的实例,并将其返回给调用者。具体工厂是与具体产品相关的,实现时一般常用的做法是为每个具体产品定义一个具体工厂。以下是具体工厂的示例性Python代码:
concretecreator.py
class ConcreteCreator(Creator):
  """ 具体工厂角色 """

 # 创建具体产品的工厂方法
 def factoryMethod(self):
 product = ConcreteProduct()
 return product

抽象产品角色的主要目的是为所有的具体产品提供一个共同的接口,通常只需给出相应的声明就可以了,而不用给出具体的实现。以下是抽象产品类的示例性Python代码:
product.py
class Product:
  """ 抽象产品角色 """

 # 所有产品类的公共接口
 def interface(self):
 pass

具体产品角色充当最终的创建目标,一般来讲它是抽象产品类的子类,实现了抽象产品类中定义的所有工厂方法,实际应用时通常会具有比较复杂的业务逻辑。以下是具体产品类的示例性Python代码:
concreteproduct.py
class ConcreteProduct(Product):
  """ 具体产品角色 """

 # 公共接口的实现
 def interface(self):
 print "Concrete Product Method"

在应用工厂方法模式时,通常还需要再引入一个客户端角色,由它负责创建具体的工厂对象,然后再调用工厂对象中的工厂方法来创建相应的产品对象。以下是客户端的示例性Python代码:
client.py
class Client:
  """ 客户端角色 """

def run(self):
 creator = ConcreteCreator()
 product = creator.factoryMethod()
 product.interface()
# 主函数
if (__name__ == "__main__"):
 client = Client()
 client.run()

在这个简单的示意性实现里,充当具体产品和具体工厂角色的类都只有一个,但在真正的实际应用中,通常遇到的都是同时会有多个具体产品类的情况,此时相应地需要提供多个具体工厂类,每个具体工厂都负责生产对应的具体产品。
工厂方法模式的活动序列如下图所示,客户端Client首先创建ConcreteCreator对象,然后调用ConcreteCreator对象的工厂方法factoryMethod(),由它负责"生产"出所需要的ConcreteProduct对象。

下面我们来看一个具体案例:
如果你开一家Pizza店(PizzaStore抽象类)卖各种风味的Pizza(Pizza子类),那么你需要根据客户要求准备相应的Pizza(创建Pizza对象),然后烘烤、切片、包装;
最简单的做法就是在PizzaStore中根据客户要求(类型判断)创建相应的Pizza对象,然后调用Pizza自身(由Pizza抽象类实现)的烘烤、切片和包装方法;
但这样的代码缺乏弹性,因为你让一个抽象类去依赖具体的对象;我们可以创建一个工厂来生产Pizza,根据传入的不同类型值返回不同Pizza对象,即从PizzaStore中将创建对象的代码挪到工厂中。但这只是一个编程技巧,并不算模式。
在工厂方法模式中,我们在PizzaStore中定义一个抽象接口(create_pizza)作为抽象的工厂,而order_pizza是它的客户;将Pizza对象的创建放到PizzaStore子类去解决。
现有Cheese和Clam两款Pizza,以及NY和Chicago两家分店,每家店的同款Pizza的口味不同——为迎合当地口味做了改进,主要差别来自不同的原材料,因此我们实现四个Pizza类型(NYStyleCheesePizza、NYStyleClamPizza、ChicagoStyleCheesePizza和ChicagoStyleClamPizza),每种使用不同的原材料组合,根据客户所在城市和选择款式我们创建不同的对象;根据工厂方法,我们将对象创建的代码放到PizzaStore子类去实现。
代码:

#!/usr/bin/python 

class Pizza:
 name = ""
 dough = ""
 sauce = ""
 toppings = [] 

 def prepare(self):
  print "Preparing %s" % self.name
  print " dough: %s" % self.dough
  print " sauce: %s" % self.sauce
  print " add toppings:"
  for n in self.toppings:
   print "  %s" % n 

 def bake(self):
  print "Bake for 25 minutes at 350." 

 def cut(self):
  print "Cutting into diagonal slices." 

 def box(self):
  print "Put into official box." 

 def get_name(self):
  return self.name 

class PizzaStore:
 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 NYStyleCheesePizza(Pizza):
 def __init__(self):
  self.name = "NY Style Cheese Pizza"
  self.dough = "NY Dough"
  self.sauce = "NY Sauce"
  self.toppings.append("NY toopping A")
  self.toppings.append("NY toopping B") 

class ChicagoStyleCheesePizza(Pizza):
 def __init__(self):
  self.name = "Chicago Style Cheese Pizza"
  self.dough = "Chicago Dough"
  self.sauce = "Chicago Sauce"
  sefl.toppings.append("Chicago toopping A") 

 def cut(self):
  print "Cutting into square slices." 

class NYStyleClamPizza(Pizza):
 def __init__(self):
  self.name = "NY Style Clam Pizza"
  self.dough = "NY Dough"
  self.sauce = "NY Sauce"
  self.toppings.append("NY toopping A")
  self.toppings.append("NY toopping B") 

class ChicagoStyleClamPizza(Pizza):
 def __init__(self):
  self.name = "Chicago Style Clam Pizza"
  self.dough = "Chicago Dough"
  self.sauce = "Chicago Sauce"
  self.toppings.append("Chicago toopping A") 

 def cut(self):
  print "Cutting into square slices." 

class NYPizzaStore(PizzaStore):
 def create_pizza(self, pizza_type):
  if pizza_type == "cheese":
   return NYStyleCheesePizza()
  elif pizza_type == "clam":
   return NYStyleClamPizza()
  else:
   return None 

class ChicagoPizzaStore(PizzaStore):
 def create_pizza(self, pizza_type):
  if pizza_type == "cheese":
   return ChicagoStyleCheesePizza()
  elif pizza_type == "clam":
   return ChicagoStyleClamPizza()
  else:
   return None 

if __name__ == "__main__":
 ny_store = NYPizzaStore()
 chicago_store = ChicagoPizzaStore() 

 pizza = ny_store.order_pizza("cheese")
 print "Mike ordered a %s." % pizza.get_name()
 print 

 pizza = chicago_store.order_pizza("clam")
 print "John ordered a %s." % pizza.get_name()
 print

输出:

Preparing NY Style Cheese Pizza
 dough: NY Dough
 sauce: NY Sauce
 add toppings:
  NY toopping A
  NY toopping B
Bake for 25 minutes at 350.
Cutting into diagonal slices.
Put into official box.
Mike ordered a NY Style Cheese Pizza. 

Preparing Chicago Style Clam Pizza
 dough: Chicago Dough
 sauce: Chicago Sauce
 add toppings:
  NY toopping A
  NY toopping B
  Chicago toopping A
Bake for 25 minutes at 350.
Cutting into square slices.
Put into official box.
John ordered a Chicago Style Clam Pizza.
时间: 2016-02-29

详解设计模式中的工厂方法模式在Python程序中的运用

工厂方法(Factory Method)模式又称为虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式,属于类的创建型模式.在工厂方法模式中,父类负责定义创建对象的公共接口,而子类则负责生成具体的对象,这样做的目的是将类的实例化操作延迟到子类中完成,即由子类来决定究竟应该实体化哪一个类. 在简单工厂模式中,一个工厂类处于对产品类进行实例化的中心位置上,它知道每一个产品类的细节,并决定何时哪一个产品类应当被实例化.简单工厂模式的优点是能

举例讲解Python设计模式编程中对抽象工厂模式的运用

抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 优点:易于交换"产品系列",只要更改相应的工厂即可. 缺点:建立产品的时候很繁琐,需要增加和修改很多东西. 优化1:为了避免客户端有过多的逻辑判断,可以封装出一个简单工厂类来生成产品类. 优化2:为了减少简单工厂类里面的逻辑判断,可以采用"反射"机制,直接根据外部的配置文件读取出需要使用产品类的信息. #encoding=utf-8 # #by panda #抽象工厂模式 def p

使用简单工厂模式来进行Python的设计模式编程

计模式的目的是让代码易维护.易扩展,不能为了模式而模式,因此一个简单的工具脚本是不需要用到任何模式的. 简单工厂模式又叫静态工厂方法模式,工厂模式家族中最简单的一种模式.这个模式的基本工作方式: 通过一个工厂来决定创建哪种具体的产品实例. 下面是一个简单的工厂实例: def create_animal(name): if name == 'dog': return Dog() elif name == 'cat': return Cat() animal = create_animal('dog

设计模式中的原型模式在Python程序中的应用示例

原型模式: 原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象. 原型模式本质就是克隆对象,所以在对象初始化操作比较复杂的情况下,很实用,能大大降低耗时,提高性能,因为"不用重新初始化对象,而是动态地获得对象运行时的状态". 应用特性: 需要大量的基于某个基础原型进行微量修改而得到新原型时使用. 结构特性: 对象的复制机制,即浅复制和深复制. 例1: #!/usr/bin/env python #encoding: utf-8 from copy import copy, d

Python设计模式编程中Adapter适配器模式的使用实例

将一个类的接口转换成客户希望的另外一个接口.使得原本由于接口不兼容而不能一起工作的那些类可以一起工作. 应用场景:希望复用一些现存的类,但是接口又与复用环境要求不一致. 模式特点:将一个类的接口转换成为客户希望的另外一个接口. 分类:类适配器(通过多重继承).对象适配器. 来通过例子说明,下面是用户通过适配器使用一个类的方法 class Target: def Request(): print "common request." class Adaptee(Target): def S

举例分析Python中设计模式之外观模式的运用

应用特性: 在很多复杂而小功能需要调用需求时,而且这些调用往往还有一定相关性,即一调用就是一系列的. 结构特性: 把原本复杂而繁多的调用,规划统一到一个入口类中,从此只通过这一个入口调用就可以了. 代码结构示例: class ModuleOne(object): def Create(self): print 'create module one instance' def Delete(self): print 'delete module one instance' class Module

Python设计模式编程中解释器模式的简单程序示例分享

模式特点:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 我们来看一下下面这样的程序结构: class Context: def __init__(self): self.input="" self.output="" class AbstractExpression: def Interpret(self,context): pass class Expression(AbstractExpression): de

详解Python设计模式编程中观察者模式与策略模式的运用

观察者模式 观察者模式:又叫发布订阅模式,定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,这个主题对象的状态发生变化时,会通知所有观察者对象,是他们能自动更新自己. 代码结构 class Topic(object): """主题类.保存所有观察者实例的引用,每个主题都可以有很多观察者 可以增加和删除观察者""" def __init__(self): self.obs = [] def Attach(self, ob): se

深入解析Python设计模式编程中建造者模式的使用

建造者模式:将一个复杂对象的构建与他的表示分离,使得同样的构建过程可以创建不同的表示. 基本思想 某类产品的构建由很多复杂组件组成: 这些组件中的某些细节不同,构建出的产品表象会略有不同: 通过一个指挥者按照产品的创建步骤来一步步执行产品的创建: 当需要创建不同的产品时,只需要派生一个具体的建造者,重写相应的组件构建方法即可. 代码结构 class Builder(object): """基类""" def Part1(self): # 不同类型

Python使用设计模式中的责任链模式与迭代器模式的示例

责任链模式 责任链模式:将能处理请求的对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理请求为止,避免请求的发送者和接收者之间的耦合关系. #encoding=utf-8 # #by panda #职责连模式 def printInfo(info): print unicode(info, 'utf-8').encode('gbk') #抽象职责类 class Manager(): successor = None name = '' def __init__(self, name):

实例解析Python设计模式编程之桥接模式的运用

我们先来看一个例子: #encoding=utf-8 # #by panda #桥接模式 def printInfo(info): print unicode(info, 'utf-8').encode('gbk') #抽象类:手机品牌 class HandsetBrand(): soft = None def SetHandsetSoft(self, soft): self.soft = soft def Run(self): pass #具体抽象类:手机品牌1 class HandsetBr

分析Python中设计模式之Decorator装饰器模式的要点

先给出一个四人团对Decorator mode的定义:动态地给一个对象添加一些额外的职责. 再来说说这个模式的好处:认证,权限检查,记日志,检查参数,加锁,等等等等,这些功能和系统业务无关,但又是系统所必须的,说的更明白一点,就是面向方面的编程(AOP). 在Python中Decorator mode可以按照像其它编程语言如C++, Java等的样子来实现,但是Python在应用装饰概念方面的能力上远不止于此,Python提供了一个语法和一个编程特性来加强这方面的功能.Python提供的语法就是

Python装饰器模式定义与用法分析

本文实例讲述了Python装饰器模式定义与用法.分享给大家供大家参考,具体如下: 装饰器模式定义:动态地给一个对象添加一些额外的职责. 在Python中Decorator mode可以按照像其它编程语言如C++, Java等的样子来实现,但是Python在应用装饰概念方面的能力上远不止于此,Python提供了一个语法和一个编程特性来加强这方面的功能. 首先需要了解一下Python中闭包的概念:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(c

java实现装饰器模式(Decorator Pattern)

一.什么是装饰器模式   装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构.这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装.   这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能.   在不想增加更多子类的情况下扩展类,动态地给一个对象添加一些额外的职责.就增加功能来说,装饰器模式相比生成子类更为灵活. 二.装饰器模式的具体实现 1.结构图 2.分析 装饰器模式由组件和装饰者组成. 抽

浅析Python装饰器以及装饰器模式

漫谈 如果作为一个Python入门,不了解Python装饰器也没什么,但是如果作为一个中级Python开发人员,如果再不对python装饰器熟稔于心的话,那么可能并没有量变积累到质变. 我以前也看过很多讲python 装饰器的文章,但是都是看了就忘.一方面是没有做太多的练习,二是对它的领会不是很深. 希望引以为戒!!! 郑传 装饰模式 如果你了解Java,你肯定听过 装饰器模式.在面向对象中,装饰模式指:动态地给一个对象添加一些额外的职责.就增加一些功能来说,装饰模式比生成子类更为灵活. 在设计

C#装饰器模式(Decorator Pattern)实例教程

本文以实例形式详细讲述了C#装饰器模式的实现方法.分享给大家供大家参考.具体实现方法如下: 现假设有一个公司要做产品套餐,即把不同的产品组合在一起,不同的组合对应不同的价格.最终呈现出来的效果是:把产品组合的所有元素呈现出来,并显示该组合的价格. 每个产品都有名称和价格,首先设计一个关于产品的抽象基类. public abstract class ProductBase { public abstract string GetName(); public abstract double GetP

PHP设计模式(八)装饰器模式Decorator实例详解【结构型】

本文实例讲述了PHP设计模式:装饰器模式Decorator.分享给大家供大家参考,具体如下: 1. 概述 若你从事过面向对象开发,实现给一个类或对象增加行为,使用继承机制,这是所有面向对象语言的一个基本特性.如果已经存在的一个类缺少某些方法,或者须要给方法添加更多的功能(魅力),你也许会仅仅继承这个类来产生一个新类-这建立在额外的代码上. 通过继承一个现有类可以使得子类在拥有自身方法的同时还拥有父类的方法.但是这种方法是静态的,用户不能控制增加行为的方式和时机.如果  你希望改变一个已经初始化的

深入解析设计模式中的装饰器模式在iOS应用开发中的实现

装饰器模式可以在不修改代码的情况下灵活的为一对象添加行为和职责.当你要修改一个被其它类包含的类的行为时,它可以代替子类化方法. 一.基本实现 下面我把类的结构图向大家展示如下: 让我们简单分析一下上面的结构图,Component是定义一个对象接口,可以给这些对象动态地添加职责.ConcreteComponent是定义了一个具体的对象,也可以给这个对象添加一些职责.Decorator,装饰抽象类,继承了Component,从外类来扩展Component类的功能,但对于Component来说,是无需

PHP设计模式之装饰器模式定义与用法详解

本文实例讲述了PHP设计模式之装饰器模式定义与用法.分享给大家供大家参考,具体如下: 什么是装饰器模式 作为一种结构型模式, 装饰器(Decorator)模式就是对一个已有结构增加"装饰". 适配器模式, 是为现在有结构增加的是一个适配器类,.将一个类的接口,转换成客户期望的另外一个接口.适配器让原本接口不兼容的类可以很好的合作. 装饰器模式是将一个对象包装起来以增强新的行为和责任.装饰器也称为包装器(类似于适配器) 有些设计设计模式包含一个抽象类,而且该抽象类还继承了另一个抽象类,这

浅谈Java设计模式系列-装饰器模式

一.概述 装饰器模式作用是针对目标方法进行增强,提供新的功能或者额外的功能. 不同于适配器模式和桥接模式,装饰器模式涉及的是单方,和代理模式相同,而且目标必须是抽象的. 而实际上,装饰器模式和代理模式的实现方式基本一致,只在目标的存在上有些差别,这个后面我们具体讲述. 二.初步分析 上面提到了两点: 涉及的是单方 目标是抽象的 我们来想一下,所谓单方主要指的是在整个装饰器模式中不存在双方调用,要解决的也不是双方调用的问题,而是解决单方提供对外服务的问题,这个单方在自行对外提供服务时,功能不足,或

实例讲解Ruby使用设计模式中的装饰器模式的方法

概述        若你从事过面向对象开发,实现给一个类或对象增加行为,使用继承机制,这是所有面向对象语言的一  个基本特性.如果已经存在的一个类缺少某些方法,或者须要给方法添加更多的功能(魅力),你也许会仅仅继承这个类来产生一个新类-这建立在额外的代码上.       通过继承一个现有类可以使得子类在拥有自身方法的同时还拥有父类的方法.但是这种方法是静态的,用户不能控制增加行为的方式和时机.如果  你希望改变一个已经初始化的对象的行为,你怎么办?或者,你希望继承许多类的行为,改怎么办?前一个,