彻底搞懂建造者模式

全篇干货，值得你用几分钟认真读完。

先看定义：将一个复杂的构建与其表示想分离，使得同样的构建过程可以创建不同的标示。

使用场景：当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。

例子

在App中用户会分成vip和普通用户，vip用户会有app的图标和用户专属图标。这里假设用户有id和name（昵称）是必选的，vipAppLogo（vip的app图标）和vipUserLogo（vip用户图标）是可选的，vipAppLogo和vipUserLogo也可能有其中一个（vip可能只开启了一个），最原始的方案大概是这样的：

class User {
    var id: Int;
    var name: String;
    var vipAppLogo: Image; // 图标存在本地的资源文件中，通过Resource.getVipAppLogo()获取
    var vipUserLogo: Image; // 图标存在本地资源文件中，通过Resource.getVipUserLogo()获取

    func init(id: Int, name: String) {
        self.id = id;
        self.name = name;
    }

    func init(id: Int, name: String, vipAppLogo: Image) {
        self.id = id;
        self.name = name;
        self.vipAppLogo = vipAppLogo;
    }

    func init(id: Int, name: String, vipUserLogo: Image) {
        self.id = id;
        self.name = name;
        self.vipUserLogo = vipUserLogo;
    }

    func init(id: Int, name: String, vipAppLogo: Image, vipUserLogo: Image) {
        self.id = id;
        self.name = name;
        self.vipAppLogo = vipAppLogo;
        self.vipUserLogo = vipUserLogo;
    }
}

使用这种方法在创建User的时候需要决定到底该使用哪个初始化方法，而且阅读起来及其不便，也非常不利于扩展，可以设想一下某次需求变化给User增加一个age的必传参数。。。相信这种情况都遇到过。

读到这里，聪明的你可能会想到，既然有的参数是可选的，那么我是否可以只使用一个初始化函数，而把其他参数都使用get、set方法传递呢，就像下面这样。

class User {
    var id: Int;
    var name: Int;
    var vipAppLogo: Image;
    var vipUserLogo: Image;

    func init(id: Int, name: String) {
        self.id = id;
        self.name = name;
    }

    func setVipAppLogo(vipAppLogo: Image) {
        self.avatarImage = avatarImage;
    }

    func setVipUserLogo(vipUserLogo: Image) {
        self.vipUserLogo = vipUserLogo;
    }
}

不得不说这种方法确实解决了上面提高的问题，但是如果在调用setNo之前就使用了no的话，是不是就取不到值了呢？而且，对外直接暴露set方法的话，调用者随时都可以修改属性值，对内部来说是很不安全的。

现在使用构建者模式可以这样做：

class User {
    var id: int; 
    var name: string; 
    var vipAppLogo: Image;
    var vipUserLogo: Image; 

    func init(id: int, name: string) {
        self.id = id;
        self.name = name;
    }

    func setVipAppLogo(vipAppLogo: Image) {
        self.vipAppLogo = vipAppLogo;
    }

    func setVipUserLogo(vipUserLogo: Image) {
        self.vipUserLogo = vipUserLogo;
    }
}

interface UserBuilder {
    func setVipAppLogo(vipAppLogo: Image);
    func setVipUserLogo(vipUserLogo: Image);

    func init(id: int, name: string);
    func getUser() -> User;
}

class ConcreteUserBuilder: UserBuilder {
    private var someUser: User;
    func init(id: int, name: string) {
        someUser = User(id, name);
    }

    func setVipAppLogo(vipAppLogo: Image) {
        someUser.no = no;
    }

    func setVipUserLogo(vipUserLogo: Image) {
        someUser.vipUserLogo = vipUserLogo;
    }

    func getUser() -> User {
        return self.someUser;
    }
}

class UserDirector {
    func createUser(build: UserBuilder, vipLevel: int) -> User {
        if (vipLevel > 10) {
            build.setVipAppLogo(Resource.getVipAppLogo(vipLevel);
            build.setVipUserLogo(Resource.getUserAppLogo(vipLevel);
        }
        return build.getUser();
    }
}

使用的时候：

let xiaomingBuilder: ConcreteUserBuilder = new ConcreteUserBuilder(id: 1, name: "xiaoming");
let director: UserDirector = new UserDirector();
let xiaoming = director.createUser(build: xiaomingBuilder, vipLevel: 20);

经过建造者模式的封装，User的创建过程被掩盖起来。尤其是在需求变动的时候优势尤为显著。比如在vipLevel大于15时才有vipAppLogo，而在vipLevel大于20时才有vipUserLogo，这时仅改动Builder里面的代码就可以完成这个需求。

下面提供一种简化的使用方式，可能在某些语言里不适用。

public class Computer {
    private final String cpu;//必须
    private final String ram;//必须
    private final int usbCount;//可选
    private final String keyboard;//可选
    private final String display;//可选

    private Computer(Builder builder){
        this.cpu=builder.cpu;
        this.ram=builder.ram;
        this.usbCount=builder.usbCount;
        this.keyboard=builder.keyboard;
        this.display=builder.display;
    }
    public static class Builder{
        private String cpu;//必须
        private String ram;//必须
        private int usbCount;//可选
        private String keyboard;//可选
        private String display;//可选

        public Builder(String cup,String ram){
            this.cpu=cup;
            this.ram=ram;
        }

        public Builder setUsbCount(int usbCount) {
            this.usbCount = usbCount;
            return this;
        }
        public Builder setKeyboard(String keyboard) {
            this.keyboard = keyboard;
            return this;
        }
        public Builder setDisplay(String display) {
            this.display = display;
            return this;
        }        
        public Computer build(){
            return new Computer(this);
        }
    }
}

当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。

本文到这里就结束了，感谢阅读。有不对之处请指正。