设计模式三：建造者模式

什么是建造者模式

创建一个由多个部分构成的对象，而且构成需要一步步完成只有当各部分都创建好，这个对象才算是完整的。

此模式有两个参与者：建造者和指挥者
建造者负责创建复杂对象的各个组成部分
指挥者是使用一个建造者实例控制建造的过程

使用场景

知道一个对象必须经过多个步骤来创建，并且要求同一个构造过程可以产生不同的表现，就可以使用建造者模式

建造者模式和工厂模式的差别：

工厂模式以单个步骤创建对象，而建造者模式以多个步骤创建对象，并且始终会使用一个指挥者
工厂模式会立即返回一个创建好的对象，而建造者模式仅在需要时客户端代码才会显示地请求指挥者返回最终的对象
举例说明：
工厂模式：买一台特定预配置的电脑型号，所有硬件的规格都已经由制造商预先确定，不用向你咨询就知道自己该做什么，通常接收的仅仅是单条指令
建造者模式：你是指挥者，向制造商提供指令说明心中理想的电脑规格，就可以得到一台定制化的PC

实例代码

from enum import Enum
import time

Progress = Enum('Progress','queued preparation packing ready')
Ingredient = Enum('Ingredient', 'egg sausage')
Vegetables = Enum('Vegetables','cabbage carota pepper lettuce')
Sauce = Enum('Sauce','hot salty')
STEP_DELAY = 3

class Fried_Rice:
def __init__(self,name):
self.name = name
self.ingredient = None
self.sauce = None
self.vegetables = []
def __str__(self):
return self.name

class EggRiceBuilder:
def __init__(self):
self.friedrice = Fried_Rice('Egg Fried Rice')
self.progress = Progress.queued
#self.cooking_time = 5
def add_Ingredient(self):
print('adding the egg to your fried rice...')
self.friedrice.ingredient = Ingredient.egg
time.sleep(STEP_DELAY)
print('done with egg')
def add_Vegetables(self):
print('adding some vegetables to your fried rice...')
self.friedrice.vegetables.append([i for i in (Vegetables.cabbage,Vegetables.carota)])
time.sleep(STEP_DELAY)
print('done with vegetables')
def add_sauce(self):
print('adding the hot sauce to your fried rice...')
self.friedrice.sauce = Sauce.hot
time.sleep(STEP_DELAY)
print('done with sauce')
def Packing(self):
self.progress = Progress.packing
print('Packing your egg fried rice...')
time.sleep(STEP_DELAY)
self.progress = Progress.ready
print('your egg fried rice is ready')

class SausageRiceBuilder:
def __init__(self):
self.friedrice = Fried_Rice('Sausage Fried Rice')
self.progress = Progress.queued
#self.cooking_time = 5
def add_Ingredient(self):
print('adding the sausage to your fried rice...')
self.friedrice.ingredient = Ingredient.sausage
time.sleep(STEP_DELAY)
print('done with sausage')
def add_Vegetables(self):
print('adding some vegetables to your fried rice...')
self.friedrice.vegetables.append([i for i in (Vegetables.pepper,Vegetables.lettuce)])
time.sleep(STEP_DELAY)
print('done with vegetables')
def add_sauce(self):
print('adding the hot sauce to your fried rice...')
self.friedrice.sauce = Sauce.salty
time.sleep(STEP_DELAY)
print('done with sauce')
def Packing(self):
self.progress = Progress.packing
print('Packing your sausage fried rice...')
time.sleep(STEP_DELAY)
self.progress = Progress.ready
print('your sausage fried rice is ready')

class Cook:
def __init__(self):
self.builder = None
def Cooking_Rice(self,builder):
self.builder = builder
[step() for step in (builder.add_Ingredient,
builder.add_Vegetables,builder.add_sauce,builder.Packing)]
@property
def friedrice(self):
return self.builder.friedrice

def main():
print('Which one do you like?')
print('1. Egg Fried Rice')
print('2. Sausage Fried Rice')
opt = input('Select the number\n')
opt = int(opt)
builder = EggRiceBuilder if opt ==1 else SausageRiceBuilder
cook = Cook()
cook.Cooking_Rice(builder())
friedrice = cook.friedrice
print('Enjoy your {}'.format(friedrice))
if __name__ == "__main__":
main()

流利建造者模式

将建造者本身定义为内部类，并从其每个设置方法返回自身实现，最终通过build()的方法返回对象。这种模式称之为流利的建造者。

实例代码

class Noodles:
def __init__(self,builder):
self.garlic = builder.garlic
self.pepper = builder.pepper
def __str__(self):
garlic = 'yes' if self.garlic else 'no'
pepper = 'yes' if self.pepper else 'no'
info = ('Garlic:{}'.format(garlic),'Pepper:{}'.format(pepper))
return '\n'.join(info)
class NoodlesBuilder:
def __init__(self):
self.garlic = False
self.pepper = False
def add_garlic(self):
self.garlic = True
return self
def add_pepper(self):
self.pepper = True
return self
def build(self):
return Noodles(self)

if __name__ == "__main__":
noodle = Noodles.NoodlesBuilder().add_garlic().add_pepper().build()
print(noodle)

• 点赞
• 收藏
• 分享
• 文章举报