• 注意！！！！ 如果你是技术大牛、技术大咖，请略过这篇文章避免耽搁您的时间，这篇文章属于入门级别。😀

什么是构建者模式？

• 构建者模式是创建型设计模式（单利模式、工厂模式、构建者模式、原型模式）之一。
• 将一个复杂的对象的创建和表示进行分离，同时你创建的顺序不一样，表示也不一样。（表示：我们看到的外观，也就是程序中UI显示
  创建：制造的过程封装，在使用的时候不需要使用者关心）
• 使用场景？ 1、相同的方法，调用的顺序不一样，产生的结果不一样 2、多个部件都可以组装到一个对象上，但是产生的结果不一样 3、当一个类非常复杂的时候，并且需要初始化默认初始化参数（如：网络请求）

下面看一个基础原理程序案例(以电脑为例)：👇

//----------------------先来定义两个抽象协议-------------------
//电脑的抽象协议
@protocol IComputer <NSObject>
//处理器
- (void)cpu:(NSString *)cpu;
//显卡
- (void)display:(NSString *)display;
//主板
- (void)mainboard:(NSString *)mainboard;
//系统
- (void)os;
@end

//构建者抽象协议
@protocol IComputerBuilder <NSObject>
//构建CPU
- (id<IComputerBuilder>)buildCPU:(NSString *)cpu;
//构建显卡
- (id<IComputerBuilder>)buildDisplay:(NSString *)display;
//构建主板
- (id<IComputerBuilder>)buildMainboard:(NSString *)mainboard;
//构建系统
- (id<IComputerBuilder>)buildOS:(NSString *)os;
//构建
- (id<IComputer>)build;
@end

//----------------构建具体的类并实现协议------------------
@interface LevenoComputer ()<IComputer>
@end
@implementation LevenoComputer
//处理器
- (void)cpu:(NSString *)cpu {
    NSLog(@"Leveno处理器CPU:%@", cpu);
}
//显卡
- (void)display:(NSString *)display {
    NSLog(@"Leveno显卡:%@", display);
}
//主板
- (void)mainboard:(NSString *)mainboard {
    NSLog(@"Leveno主板:%@", mainboard);
}
//系统
- (void)os {
    NSLog(@"windows");
}
@end

//具体的构建者实现构建者抽象协议
@interface LevenoComputerBuilder ()<IComputerBuilder>
@property (nonatomic, strong) id<IComputer> computer;
@end

@implementation LevenoComputerBuilder
- (instancetype)init{
    self = [super init];
    if (self) {
        _computer = [[LevenoComputer alloc] init];
    }
    return self;
}
//构建CPU
- (id<IComputerBuilder>)buildCPU:(NSString *)cpu {
    [_computer cpu:cpu];
    return self;
}
//构建显卡
- (id<IComputerBuilder>)buildDisplay:(NSString *)display {
    [_computer display:display];
    return self;
}
//构建主板
- (id<IComputerBuilder>)buildMainboard:(NSString *)mainboard {
    [_computer mainboard:mainboard];
    return self;
}
//构建系统
- (id<IComputerBuilder>)buildOS:(NSString *)os {
    [_computer os];
    return self;
}
//构建
- (id<IComputer>)build {
    NSLog(@"构建了一台Leveno💻");
    //正式的项目中其实这里有很多的逻辑
    return _computer;
}

//----------在客户端（ViewController）里面使用一下
id<IComputerBuilder> builder2 = [[LevenoComputerBuilder alloc] init];
    //链式编程
[[[[[builder2 buildCPU:@"inter i5"] buildDisplay:@"独立显卡2G"] buildMainboard:@"三星主板"] buildOS:@""] build];

理解了上边的原理案例后 我们来看一个项目中实际运用的例子（我们平常用的UIAlertViewController）使用构建者模式来封装一下，进行项目的解耦和。如下👇：

import UIKit
//使用Builder设计模式自定义一个alert SLAlertController不能再外部实例化对象，只能在内部使用（否则没有意义）
class SLAlertController: NSObject {
    //不允许外部进行初始化
    private var params:BuilderParams?
    private init(params:BuilderParams) {
        super.init()
        self.params = params
    }
    //显示controller
    func showAlert() {
        let alert = UIAlertController(title: self.params?.title, message: self.params?.message, preferredStyle: UIAlertControllerStyle.alert)
        if self.params?.confirmTitle != nil {
            alert.addAction(UIAlertAction(title: self.params?.confirmTitle, style: UIAlertActionStyle.destructive, handler: self.params?.confirmHandle))
        }
        if self.params?.cancelTitle != nil {
            alert.addAction(UIAlertAction(title: self.params?.cancelTitle, style: UIAlertActionStyle.cancel, handler: self.params?.cancelHandle))
        }
        self.params?.context?.present(alert, animated: true) {
        }
    }

    //参数和构建的分离
    class BuilderParams: NSObject {
        //上下文,用AlertController
        var context:UIViewController?
        //alert 的提示标题
        var title:String?
        //alert 的提示信息
        var message:String?
        //确定按钮
        var confirmTitle:String?
        //取消按钮
        var cancelTitle:String?
        //确定回调
        var confirmHandle:((UIAlertAction) -> Swift.Void)?
        //取消回调
        var cancelHandle:((UIAlertAction) -> Swift.Void)?
        init(context:UIViewController) {
            super.init()
            self.context = context
        }
    }

    class Builder: NSObject {
        private var param:BuilderParams?
        init(context:UIViewController) {
            super.init()
            self.param = BuilderParams(context: context)
        }
        func setTitle(_ title:String) -> Builder {
            self.param?.title = title
            return self
        }
        func setMessage(_ message:String) -> Builder {
            self.param?.message = message
            return self
        }
        func setConfirmTitle(_ confirmTitle:String) -> Builder {
            self.param?.confirmTitle = confirmTitle
            return self
        }
        func setCancelTitle(_ cancelTitle:String) -> Builder {
            self.param?.cancelTitle = cancelTitle
            return self
        }
        func setConfirmHandle(_ confirmHandle: ((UIAlertAction) -> Swift.Void)? = nil) -> Builder {
            self.param?.confirmHandle = confirmHandle
            return self
        }
        func setCancelHandle (_ cancelHandle :((UIAlertAction) -> Swift.Void)? = nil) -> Builder {
            self.param?.cancelHandle = cancelHandle
            return self
        }
        //最后构建
        func build() -> SLAlertController {
            return SLAlertController(params: self.param!)
        }
    }
}

//============对构建者的alert我们测试一下============
//构建者设计的alert使用写方法
let alert = SLAlertController.Builder(context: self)
 alert.setTitle("提示").setMessage("你确定要删除这张图片吗？").setCancelTitle("取消").setCancelHandle { (UIAlertAction) in
       print("取消")
 }.setConfirmTitle("确定").setConfirmHandle { (UIAlertAction) in
       print("确定")
}.build().showAlert()

• 这样来写的话，避免了在一个程序中多次使用 UIAlertController后，如果需求改了，你需要去程序中一个一个的改，改的你到时候怀疑人生（改的想死）。

如有错误的地方，留言区 -> 请多多指教！😀😀 👍