当前位置: 首页 > 编程笔记 >

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

子车凯泽
2023-03-14
本文向大家介绍举例讲解Python设计模式编程中对抽象工厂模式的运用,包括了举例讲解Python设计模式编程中对抽象工厂模式的运用的使用技巧和注意事项,需要的朋友参考一下

抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
优点:易于交换“产品系列”,只要更改相应的工厂即可。
缺点:建立产品的时候很繁琐,需要增加和修改很多东西。

优化1:为了避免客户端有过多的逻辑判断,可以封装出一个简单工厂类来生成产品类。
优化2:为了减少简单工厂类里面的逻辑判断,可以采用“反射”机制,直接根据外部的配置文件读取出需要使用产品类的信息。

#encoding=utf-8 
# 
#by panda 
#抽象工厂模式 
 
def printInfo(info): 
  print unicode(info, 'utf-8').encode('gbk') 
   
#抽象产品A:user表 
class IUser(): 
  def Insert(self): 
    pass 
  def GetUser(self): 
    pass 
 
#sqlserver实现的User 
class SqlserverUser(IUser): 
  def Insert(self): 
    printInfo("在SQL Server中给User表增加一条记录") 
  def GetUser(self): 
    printInfo("在SQL Server中得到User表的一条记录") 
 
#Access实现的User 
class AccessUser(IUser): 
  def Insert(self): 
    printInfo("在Access中给User表增加一条记录") 
  def GetUser(self): 
    printInfo("在Access中得到User表一条记录") 
 
 
#抽象产品B:部门表 
class IDepartment(): 
  def Insert(self): 
    pass 
  def GetUser(self): 
    pass 
 
#sqlserver实现的Department 
class SqlserverDepartment(IUser): 
  def Insert(self): 
    printInfo("在SQL Server中给Department表增加一条记录") 
  def GetUser(self): 
    printInfo("在SQL Server中得到Department表的一条记录") 
 
#Access实现的Department 
class AccessDepartment(IUser): 
  def Insert(self): 
    printInfo("在Access中给Department表增加一条记录") 
  def GetUser(self): 
    printInfo("在Access中得到Department表一条记录") 
 
 
#抽象工厂 
class IFactory(): 
  def CreateUser(self): 
    pass 
  def CreateDepartment(self): 
    pass   
 
#sql server工厂 
class SqlServerFactory(IFactory): 
  def CreateUser(self): 
    return SqlserverUser() 
  def CreateDepartment(self): 
    return SqlserverDepartment() 
 
#access工厂 
class AccessFactory(IFactory): 
  def CreateUser(self): 
    return AccessUser() 
  def CreateDepartment(self): 
    return AccessDepartment() 
   
#优化一:采用一个简单工厂类,封装逻辑判断操作 
class DataAccess(): 
#  db = "Sqlserver" 
  db = "Access" 
  @staticmethod 
  def CreateUser(): 
    if (DataAccess.db == "Sqlserver"): 
      return SqlserverUser() 
    elif(DataAccess.db == "Access"): 
      return AccessUser() 
  @staticmethod 
  def CreateDepartment(): 
    if (DataAccess.db == "Sqlserver"): 
      return SqlserverDepartment() 
    elif(DataAccess.db == "Access"): 
      return AccessDepartment() 
     
#优化二:采用反射机制,避免使用太多判断 
##以下信息可以从配置文件中获取 
DBType = 'Sqlserver' #'Access' 
DBTab_User = 'User' 
DBTab_Department = 'Department' 
 
class DataAccessPro(): 
#  db = "Sqlserver" 
  db = "Access" 
  @staticmethod 
  def CreateUser(): 
    funName = DBType + DBTab_User 
    return eval(funName)() #eval 将其中的字符串转化为python表达式 
  @staticmethod 
  def CreateDepartment(): 
    funName = DBType + DBTab_Department 
    return eval(funName)() 
     
def clientUI(): 
  printInfo("\n--------抽象工厂方法--------") 
  factory = SqlServerFactory() 
  iu = factory.CreateUser() 
  iu.Insert() 
  iu.GetUser() 
  id = factory.CreateDepartment() 
  id.Insert() 
  id.GetUser() 
   
  printInfo("\n--抽象工厂方法+简单工厂方法--") 
  iu = DataAccess.CreateUser() 
  iu.Insert() 
  iu.GetUser() 
  id = DataAccess.CreateDepartment() 
  id.Insert() 
  id.GetUser() 
   
  printInfo("\n-抽象工厂方法+简单工厂方法+反射-") 
  iu = DataAccessPro.CreateUser() 
  iu.Insert() 
  iu.GetUser() 
  id = DataAccessPro.CreateDepartment() 
  id.Insert() 
  id.GetUser()   
  return 
 
 
if __name__ == '__main__': 
  clientUI(); 

类图:

工厂模式和抽象工厂模式的区别:工厂模式是在派生类中定义一个工厂的抽象接口,然后基类负责创建具体对象;抽象工厂模式是维护一个产品家族,由基类定义产品被生产的方法,客户根据派生类的接口进行开发。

实例:人民群众喜闻乐见的披萨店例子这里又可以搬出来了,这次我们根据抽象工厂模式的特点,用不同原材料制作不同口味的披萨,创建不同原材料的工厂,不同实体店做出口味不同的披萨。创建一个产品家族(Dough、Sauce、Cheese和Clam)的抽象类型(PizzaIngredientFactory),这个类型的子类(NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory)定义了产品被产生的方法。
代码:

#!/usr/bin/python
# -*- coding:utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
 
'''
披萨
'''
class Pizza:
  name = ""
  dough = None
  sauce = None
  cheese = None
  clam = None
 
  def prepare(self):
    pass
 
  def bake(self):
    print "烘烤25分钟在350。".decode('utf-8')
 
  def cut(self):
    print "切割成对角线切片。".decode('utf-8')
 
  def box(self):
    print "放在官方的盒子中。".decode('utf-8')
 
  def get_name(self):
    return self.name
 
  def set_name(self, name):
    self.name = name
 
  def to_string(self):
    string = "%s:\n" % self.name
    string += "  面团: %s\n" % self.dough.to_string() if self.dough else ""
    string += "  酱汁: %s\n" % self.sauce.to_string() if self.sauce else ""
    string += "  奶酪: %s\n" % self.cheese.to_string() if self.cheese else ""
    string += "  文蛤: %s\n" % self.clam.to_string() if self.clam else ""
    return string
 
'''
什么类别的披萨
'''
class CheesePizza(Pizza):
  def __init__(self, ingredient_factory):
    self.ingredient_factory = ingredient_factory
 
  def prepare(self):
    print "准备: %s" % self.name
    self.dough = self.ingredient_factory.create_dough()
    self.sauce = self.ingredient_factory.create_sauce()
    self.cheese = self.ingredient_factory.create_cheese()
 
 
class ClamPizza(Pizza):
  def __init__(self, ingredient_factory):
    self.ingredient_factory = ingredient_factory
 
  def prepare(self):
    print "准备: %s" % self.name
    self.dough = self.ingredient_factory.create_dough()
    self.sauce = self.ingredient_factory.create_sauce()
    self.clam = self.ingredient_factory.create_clam()
 
'''
披萨店
'''
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
 
'''
纽约披萨实体店1
'''
class NYPizzaStore(PizzaStore):
  def create_pizza(self, pizza_type):
    ingredient_factory = NYPizzaIngredientFactory()
 
    if pizza_type == "cheese":
      pizza = CheesePizza(ingredient_factory)
      pizza.set_name("纽约风格芝士披萨".decode('utf-8'))
    elif pizza_type == "clam":
      pizza = ClamPizza(ingredient_factory)
      pizza.set_name("纽约风格文蛤披萨".decode('utf-8'))
    else:
      pizza = None
 
    return pizza
 
'''
芝加哥披萨实体店2
'''
class ChicagoPizzaStore(PizzaStore):
   def create_pizza(self, pizza_type):
    ingredient_factory = ChicagoPizzaIngredientFactory()
 
    if pizza_type == "cheese":
      pizza = CheesePizza(ingredient_factory)
      pizza.set_name("芝加哥风格芝士披萨".decode('utf-8'))
    elif pizza_type == "clam":
      pizza = ClamPizza(ingredient_factory)
      pizza.set_name("芝加哥风格文蛤披萨".decode('utf-8'))
    else:
      pizza = None
 
    return pizza
 
'''
生产披萨的工厂
'''
class PizzaIngredientFactory:
  def create_dough(self):
    pass
 
  def create_sauce(self):
    pass
 
  def create_cheese(self):
    pass
 
  def create_clam(self):
    pass
 
'''
生产披萨的实体工厂1
'''
class NYPizzaIngredientFactory(PizzaIngredientFactory):
  def create_dough(self):
    return ThinDough()
 
  def create_sauce(self):
    return MarinaraSauce()
 
  def create_cheese(self):
    return FreshCheese()
 
  def create_clam(self):
    return FreshClam()
 
'''
生产披萨的实体工厂2
'''
class ChicagoPizzaIngredientFactory(PizzaIngredientFactory):
  def create_dough(self):
    return ThickDough()
 
  def create_sauce(self):
    return MushroomSauce()
 
  def create_cheese(self):
    return BlueCheese()
 
  def create_clam(self):
    return FrozenClam()
 
 
class Dough:
  def to_string(self):
    pass
 
class ThinDough(Dough):
  def to_string(self):
    return "薄的面团"
 
class ThickDough(Dough):
  def to_string(self):
    return "厚的生面团"
 
class Sauce:
  def to_string(self):
    pass
 
class MarinaraSauce(Sauce):
  def to_string(self):
    return "番茄酱"
 
class MushroomSauce(Sauce):
  def to_string(self):
    return "蘑菇酱"
 
class Cheese:
  def to_string(self):
    pass
 
class FreshCheese(Cheese):
  def to_string(self):
    return "新鲜的奶酪"
 
class BlueCheese(Cheese):
  def to_string(self):
    return "蓝纹奶酪"
 
class Clam:
  def to_string(self):
    pass
 
class FreshClam(Clam):
  def to_string(self):
    return "新鲜的文蛤"
 
class FrozenClam(Clam):
  def to_string(self):
    return "冷冻的文蛤"
 
if __name__ == "__main__":
  # 创建了两个披萨实体店
  ny_store = NYPizzaStore()
  chicago_store = ChicagoPizzaStore()
 
  # 在第一个披萨对象中订购了一个cheese风味的披萨
  pizza = ny_store.order_pizza("cheese")
  print pizza.to_string()
  print "迈克订购了一个 %s" % pizza.get_name()
  print
 
  pizza = chicago_store.order_pizza("clam")
  print pizza.to_string()
  print "约翰订购了一个%s" % pizza.get_name()

结果:

准备: 纽约风格芝士披萨
烘烤25分钟在350。
切割成对角线切片。
放在官方的盒子中。
纽约风格芝士披萨:
  面团: 薄的面团
  酱汁: 番茄酱
  奶酪: 新鲜的奶酪
 
迈克订购了一个 纽约风格芝士披萨
 
准备: 芝加哥风格文蛤披萨
烘烤25分钟在350。
切割成对角线切片。
放在官方的盒子中。
芝加哥风格文蛤披萨:
  面团: 厚的生面团
  酱汁: 蘑菇酱
  文蛤: 冷冻的文蛤
 
约翰订购了一个芝加哥风格文蛤披萨
 类似资料:
  • 本文向大家介绍举例讲解C#编程中对设计模式中的单例模式的运用,包括了举例讲解C#编程中对设计模式中的单例模式的运用的使用技巧和注意事项,需要的朋友参考一下 单例模式的介绍 说到单例模式,大家第一反应应该就是——什么是单例模式?,从“单例”字面意思上理解为——一个类只有一个实例,所以单例模式也就是保证一个类只有一个实例的一种实现方法罢了,下面给出单例模式的一个官方定义:确保一个类只有一个实例,并提供

  • 本文向大家介绍Java设计模式编程中的工厂方法模式和抽象工厂模式,包括了Java设计模式编程中的工厂方法模式和抽象工厂模式的使用技巧和注意事项,需要的朋友参考一下 工厂方法模式 动机 创建一个对象往往需要复杂的过程,所以不适合包含在一个复合工厂中,当有新的产品时,需要修改这个复合的工厂,不利于扩展。 而且,有些对象的创建可以需要用到复合工厂访问不到的信息,所以,定义一个工厂接口,通过实现这个接口来

  • 本文向大家介绍实例解析Java单例模式编程中对抽象工厂模式的运用,包括了实例解析Java单例模式编程中对抽象工厂模式的运用的使用技巧和注意事项,需要的朋友参考一下 定义:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。 类型:创建类模式 类图: 抽象工厂模式与工厂方法模式的区别         抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工

  • 4. 抽象工厂(Abstract Factory) Intent 提供一个接口,用于创建 相关的对象家族 。 Class Diagram 抽象工厂模式创建的是对象家族,也就是很多对象而不是一个对象,并且这些对象是相关的,也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象,这和抽象工厂模式有很大不同。 抽象工厂模式用到了工厂方法模式来创建单一对象,AbstractFactory 中的 cr

  • 本文向大家介绍举例解析设计模式中的工厂方法模式在C++编程中的运用,包括了举例解析设计模式中的工厂方法模式在C++编程中的运用的使用技巧和注意事项,需要的朋友参考一下 工厂方法模式不同于简单工厂模式的地方在于工厂方法模式把对象的创建过程放到里子类里。这样工厂父对象和产品父对象一样,可以是抽象类或者接口,只定义相应的规范或操作,不涉及具体的创建或实现细节。 其类图如下: 实例代码为: 关键的实现:

  • 本文向大家介绍C++设计模式之抽象工厂模式,包括了C++设计模式之抽象工厂模式的使用技巧和注意事项,需要的朋友参考一下 问题描述 之前讲到了C++设计模式——工厂方法模式,我们可能会想到,后期产品会越来越多了,建立的工厂也会越来越多,工厂进行了增长,工厂变的凌乱而难于管理;由于工厂方法模式创建的对象都是继承于Product的,所以工厂方法模式中,每个工厂只能创建单一种类的产品,当需要生产一种全新的

  • 本文向大家介绍PHP实现设计模式中的抽象工厂模式详解,包括了PHP实现设计模式中的抽象工厂模式详解的使用技巧和注意事项,需要的朋友参考一下 抽象工厂模式(Abstact Factory)是一种常见的软件设计模式。该模式为一个产品族提供了统一的创建接口。当需要这个产品族的某一系列的时候,可以为此系列的产品族创建一个 具体的工厂类。 【意图】 抽象工厂模式提供一个创建一系统相关或相互依赖对象的接口,而

  • 我正在努力学习创造性设计模式,我想我现在理解了工厂方法模式。但在转向抽象工厂模式时,我找不到它的用途。我知道我错过了一些东西,但不知道在哪里。 在抽象工厂模式中,我们将有一个抽象工厂,混凝土工厂将返回实例。假设我们正在处理汽车的创建。我们将有一个像这样的抽象工厂 我们的混凝土工厂将是 在用户类中,我们将像 我认为我们也可以使用工厂模式构建相同的功能 在用户类中,我们可以 如果我的理解是正确的(如果