1.构建者模式
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
2.实用范围
1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2 当构造过程必须允许被构造的对象有不同表示时。
3.构建者模式优势：
1.不需要知道细节怎么完成
2.模块化处理，各个承建者负责独有模块，解耦
3.组合性好：不同的模块间，顺序，执行步骤都可以随意改变，互不影响
主要角色
director : 总承包商 --> 管理各种抽象类的实现，分配任务，组合产品。
builder : 各个步骤、模块承建者 --> 负责各个抽象类抽象接口实现，和具体实现类的实现
两者关系：：
每个 builder 完成的功能不一样，director管理所有的生成器,指导完成产品 ，交付使用者。
4. 具体案例
用一个建造房子举例，建造房子可分为三个步骤
1.夯实地基
2.建造房子
3.装修布置
每个步骤都有自己的承建商来建设，咱们只要把这个工程交给一个总得开发商，然后开发商去找相应的承建着，等开发完成，咱们和开发商确认签收就可以使用了……
用构建者模式设计设计时，可分给几个角色
1.承建商资质 ：必须具有指定的能力，必须遵守相关协议
/ 所有builder 都需要遵守这个协议
@protocol BuilderProtocol <NSObject>
/**
承建商开始构建
@return 返回构建对象
*/
-(void)build;
/**
构建完成，返回构建信息
@return 返回构建信息
*/
- (NSString*)info;
@end
1.1夯实地基承建商
// 承建商需要遵守协议，代表具有承建能力
@protocol HousesPlatformProtocol <NSObject>
// 打地基的方法
- (void)housesPlatformBuild;
@end
//具体的承建商：遵守对应的方法协议
@interface HousesPlatformBuilder : NSObject<BuilderProtocol,HousesPlatformProtocol>
@end
#pragma 实现协议方法
@implementation HousesPlatformBuilder
- (void)build{
[self housesPlatformBuild];
}
- (NSString*)info{
return @"housesPlatformBuild info：：";
}
- (void)housesPlatformBuild{
NSLog(@"housesPlatformBuild finish");
}
1.2房屋建造承建着：遵守自己的协议，
// 房间建造能力
@protocol HousesWallProtocol <NSObject>
- (void)housesWallBuild;
@end
// 具体的承建商
@interface HousesWallBuilder : NSObject<BuilderProtocol,HousesWallProtocol>
@end
#pragma 实现协议方法
@implementation HousesWallBuilder
- (void)build{
[self housesWallBuild];
}
- (NSString*)info{
return @"housesWallBuild info：：";
}
- (void)housesWallBuild{
NSLog(@"housesWallBuild finish");
}
@end
1.3装修的承建角色
// 具有装修能力
@protocol HousesDecorateProtocol <NSObject>
- (void)housesDecorateBuild;
@end
//具体承建者
@interface HousesDecorateBuilder : NSObject<BuilderProtocol,HousesDecorateProtocol>
@end
#pragma 实现协议方法
@implementation HousesDecorateBuilder
- (void)build{
[self housesDecorateBuild];
}
- (NSString*)info{
return @"housesDecorateBuild info：：";
}
- (void)housesDecorateBuild{
NSLog(@"housesDecorateBuild finish");
}
@end
2.指挥者director：含有各个承建商，组合商品
// 具体的构建者
#import "HousesPlatformBuilder.h" // 地基
#import "HousesWallBuilder.h"// 建造
#import "HousesDecorateBuilder.h"// 装修
// 产品
#import "House.h" // 组合产品
@interface Director : NSObject
// 承建商对象
@property (nonatomic,strong) id <BuilderProtocol,HousesPlatformProtocol> platfromBuilder;
@property (nonatomic,strong) id <BuilderProtocol,HousesWallProtocol> wallBuilder;
@property (nonatomic,strong) id <BuilderProtocol,HousesDecorateProtocol> decorateBuilder;
//产品对象
@property (nonatomic,strong) House * house;
// 构建组合产品
- (void)buildAllParts;
@end
@implementation Director
// 组装各个部件
- (void)buildAllParts{
// 构建各个部分
[self.platfromBuilder build];
[self.wallBuilder build];
[self.decorateBuilder build];
//组装部件 完成房子建造
NSString * information = [NSString stringWithFormat:@"%@\n%@\n%@\n",[self.platfromBuilder info], [self.wallBuilder info],[self.decorateBuilder info]];
// NSLog(@"完成楼房建造：\n %@",information);
self.house = [House creatHouseWithInfo:information];
}
@end
3.产品角色：
@interface House : NSObject
@property (nonatomic,strong) NSString * info;
/**
便利构造器
@param info 房屋信息
@return 房屋实体
*/
+(instancetype)creatHouseWithInfo:(NSString *)info;
@end
@implementation House
+(instancetype)creatHouseWithInfo:(NSString *)info{
House * house = [House new];
house.info = info;
return house;
}
@end
设计完成，客户端调用
vc 客户端调用
#import "Director.h"
// 创建组装者
Director * d = [Director new];
// 指定承包商
d.platfromBuilder = [HousesPlatformBuilder new];
d.wallBuilder = [HousesWallBuilder new];
d.decorateBuilder = [HousesDecorateBuilder new];
// 构建所有的部件
[d buildAllParts];
// 获取产品
NSLog(@"完成楼房建造：\n%@",d.house.info);
5.构建者模式的UML
构建者模式.png
director ：指挥类，含有各个承建对象，组合成对应的产品
builder ：抽象承建类，可以是父类，可以是协议……
concreteBuilder：具体承建类
pruduct： 承建类完成的各个模块
uml解析：
director -- builder ：聚合关系
builder--concreteBuilder ：泛化关系 / 实现关系
concreteBuilder -- pruduct: 依赖关系
uml 注释：
聚合（aggregation）关系：：
是关联关系的特例，是强的关联关系，聚合是整个与个体的关系，即has-a关系，此时整体和部分是可以分离的，他们具有各自的生命周期，部分可以属于多个对象，也可以被多个对象共享；比如计算机和CPU，公司与员工的关系；在代码层面聚合与关联是一致的，只能从语义上来区分。聚合关系也是使用实例变量来实现的。
网友评论