创建型模式之建造者模式

(Builder Pattern)使用多个简单的对象一步一步创建成一个复杂的对象,属于创建性模式

介绍

意图: 将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示
主要解决:在软件系统中,有时候面临着"一个复杂对象"的创建工作,其通常由各个部分的子对象用一定的算法构成,由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定
何时使用:一些基本不会变,而其组合经常变化的时候
如何解决:将变与不变分离开
关键代码:建造者:创建和提供实例,导演:管理建造出来的实例的依赖关系
应用实例:去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"
优点:1. 建造者独立,易扩展 2.便于控制风险
缺点:1.产品必须有共同点,范围有限制 2.如内部变化复杂,会有很多的建造类
使用场景:1. 需要生成的对象具有复杂的内部结构 2.需要生成的对象内部属性本身相互依赖
注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

模式结构和说明

建造者(生成器)模式的结构如图所示：

Builder：生成器接口，定义创建一个Product对象所需的各个部件的操作。
ConcreteBuilder: 具体的生成器实现,实现各个部件的创建,并负责组装product对象的各个部件,同时还提供一个让用户获取组装完成后的产品对象的方法
Director:指导者,也被称为导向者,主要用来使用Builder接口,以一个统一的过程来构建锁需要的Product对象
Product:产品,表示被生成器构建的复杂对象,包含多个部件

示例实现

我们假设一个快餐店的商业案列,其中,一个典型的套餐可以是一个汉堡(Burger)和一杯冷饮(cold drink).汉堡（Burger）可以是素食汉堡（Veg Burger）或鸡肉汉堡（Chicken Burger），它们是包在纸盒中。冷饮（Cold drink）可以是可口可乐（coke）或百事可乐（pepsi），它们是装在瓶子中。

我们将创建一个表示食物条目（比如汉堡和冷饮）的 Item 接口和实现 Item 接口的实体类,以及一个表示食物包装的 Packing 接口和实现 Packing 接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。然后我们创建一个 Meal 类,带有item的ArrayList和一个通过结合item来创建不同类型的Meal对象的MealBuilder。

步骤1:

创建Packing(包装)接口的实体类

@interface Pack : NSObject
//包装
- (void)pack;

@end

//包装纸
@interface Wrapper : Pack

@end
@implementation Wrapper
- (void)pack
{
    NSLog(@"包装纸包装");
}
@end

//瓶子
@interface Bottle : Pack

@end
@implementation Bottle
- (void)pack
{
    NSLog(@"瓶子包装");
}
@end

步骤2:
创建一个表示食物条目和食物包装的接口

@interface Item : NSObject
/**/
@property (nonatomic,strong) NSString *name;
/**/
@property (nonatomic,assign) float price;
/**/
@property (nonatomic,strong) Pack *pack;

@end

步骤3:
创建实现Item接口的抽象类,该类提供默认的功能

//汉堡抽象类
@interface Burger : Item

@end
@implementation Burger

- (Pack *)pack
{
    return [Wrapper new];
}

@end

//冷饮抽象类
@interface ColdDrink : Item

@end
@implementation ColdDrink

- (Pack *)pack
{
    return [Bottle new];
}
@end

步骤4:
创建扩展Buger(汉堡抽象类)和coldDrink(冷饮抽象类)的实体类

//鸡肉汉堡
@interface ChickenBurger : Burger

@end
@implementation ChickenBurger
- (float)price
{
    return 50.0;
}

- (NSString *)name
{
    return @"Chicken Burger";
}
@end

//素食汉堡
@interface VegBurger : Burger

@end
@implementation VegBurger

- (float)price
{
    return 25.0;
}

- (NSString *)name
{
    return @"veg burger";
}
@end

//可口可乐
@interface Coke : ColdDrink

@end
@implementation Coke
- (float)price
{
    return 30.0;
}
- (NSString *)name
{
    return @"coke";
}
@end

//百事可乐
@interface Pepsi : ColdDrink

@end
@implementation Pepsi
- (float)price
{
    return 35.0;
}
- (NSString *)name
{
    return @"Pepsi";
}
@end

步骤5:
创建一个Meal(套餐)类,带有上面定义的Item对象

@interface Meal ()
/**/
@property (nonatomic,strong) NSMutableArray <Item *>*items;

@end

@implementation Meal

- (instancetype)init
{
    self = [super init];
    if (self) {
        self.items = [NSMutableArray array];
    }
    return self;
}
-(void)addItem:(Item *)item
{
    [self.items addObject:item];
}
- (float)getCost
{
    float cost = 0.0;
    for (Item *item in self.items) {
        cost += item.price;
    }
    return cost;
}

- (void)showItems
{
    for (Item  *item in self.items) {
        NSLog(@"Item name:%@ ,Packing:%@ ,Price:%f", item.name,item.pack,item.price);
    }
}

@end

步骤6:
创建一个MealBuilder类,实际的builder类服装创建Meal对象

@implementation MealBuilder

- (Meal *)prepareVegMeal
{
    Meal *meal = [Meal new];
    [meal addItem:[VegBurger new]];
    [meal addItem:[Coke new]];
    return meal;
}
- (Meal *)prepareNonVegMeal
{
    Meal *meal = [Meal new];
    [meal addItem:[ChickenBurger new]];
    [meal addItem:[Pepsi new]];
    return meal;
}
@end

步骤7:
使用 MealBuider 来演示建造者模式（Builder Pattern）

   MealBuilder *builder = [MealBuilder new];
    Meal *vegMeal =  [builder prepareVegMeal];
    [vegMeal showItems];
    NSLog(@"veg meal 总价格 %f",[vegMeal getCost]);
    
    Meal *vegNonMeal =  [builder prepareNonVegMeal];
    [vegNonMeal showItems];
    NSLog(@"veg non meal 总价格 %f",[vegNonMeal getCost]);
    

执行程序:

总结:

示例整体思路:套餐(Meal)的组合是不断变化的,套餐的变化只需改变Burger和ColdDrink组合即可,但是Burger和ColdDrink必须有共同点,才能产生Item,也就是说Item是Burger和ColdDrink共同点的抽象,通过Item抽象实例化Burger和ColdDrink的具体类

建造者模式的主要功能是构建复杂的产品,而且是细化的,分步骤的构建产品,也就是建造者模式重在解决一步一步构造复杂对象的问题.更为重要的是,这个构建的过程是统一的,固定不变的,变化的部分放在生成器部分了,只要配置不同的生成器,那么同样的构建过程,就能构建出不同的产品来.直白点说**,建造者模式的重心在于分离构建算法和具体的构造实现,从而使得构建算法可以重用,具体的构造实现可以很方便的扩展和切换**,从而可以灵活的组合来构造出不同的产品对象

Demo地址