搞懂建造者模式，世界都由你来建造！

​

大家好，洪爵又来啦，今天又是设计模式的一天！

​ 洪爵今天想和大家聊一下建造者模式，建造者模式和工厂模式一样，是一种创建型模式，它提供了一种创建对象的方式。

​ 当一个类的构造方法参数比较多，并且并不是每个参数都必须要填时，比较适合用建造者模式去创建对象。

​ 我们列举一个场景，现在某个类有5个属性。

public class Car {
    private String wheel;       //need
    private String engine;      //need
    private String carBody;     //need
    private String stereo;      //optional
    private String decorations; //optional
}

​ 然后你的构造方法为了兼顾到其他的参数，就会写成这样：

public class Car {
    
    //属性
    
    public Car(String wheel, String engine, String carBody) {
        this(wheel, engine, carBody, "");
    }
    
    public Car(String wheel, String engine, String carBody, String stereo) {
        this(wheel, engine, carBody, stereo, "");
    }
    public Car(String wheel, String engine, String carBody, String stereo, string decorations) {
        this.wheel = wheel;
        this.engine = engine;
        this.carBody = carBody;
        this.stereo = stereo;
        this.decorations = decorations;
    }
}

​ 第一个构造函数的三个参数是必须的，所以是必须要填的，这种创建对象的方式称作重叠构造器模式，这种模式阅读不方便，当你要初始化一个对象，你就要去选择使用哪一个构造方法，然后又要去看里面的参数，非常的不爽。

​ 也有用JavaBean模式去构建对象，请看：

public class Car {
    // 属性
    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }

    public String getEngine() {
        return engine;
    }

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public String getCarBody() {
        return carBody;
    }

    public void setCarBody(String carBody) {
        this.carBody = carBody;
    }

    public String getStereo() {
        return stereo;
    }

    public void setStereo(String stereo) {
        this.stereo = stereo;
    }

    public String getDecorations() {
        return decorations;
    }

    public void setDecorations(String decorations) {
        this.decorations = decorations;
    }
    
}

​ 当我想要去给对象中的属性赋值时：

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.setWheel("wheel");
        car.setEngine("engine");
        car.setCarBody("carbody");
        car.setStereo("stereo");
        car.setDecorations("decorations");
    }
}

​ JavaBean模式构造一个对象的过程中，拆分成了好几步set，不利于维护，容易造成错误。

​ 而建造者模式就能很好的解决这些问题，能使得构造函数不会多到让人头昏眼花，也不会把new一个对象，拆分成好几部分来完成。

​ 老样子，先上代码：

public class Demo {
    public static void main(String[] args) {
        Language language = Language.builder().Chinese("中文").English("english").Japanese("hasagi").build();
        System.out.println(language.toString());
    }
}

Language{chinese='中文', english='english', japanese='hasagi'}

public class Language {
    private String chinese;
    private String english;
    private String japanese;

    public Language(String chinese, String english, String japanese) {
        this.chinese = chinese;
        this.english = english;
        this.japanese = japanese;
    }

    public static Language.LanguageBuilder builder() {
        return new Language.LanguageBuilder();
    }

    @Override
    public String toString() {
        return "Language{" +
                "chinese='" + chinese + '\'' +
                ", english='" + english + '\'' +
                ", japanese='" + japanese + '\'' +
                '}';
    }

    public static class LanguageBuilder {

        private String chinese;
        private String english;
        private String japanese;

        public LanguageBuilder() {}

        public Language.LanguageBuilder Chinese(String chinese) {
            this.chinese = chinese;
            return this;
        }

        public Language.LanguageBuilder English(String english) {
            this.english = english;
            return this;
        }

        public Language.LanguageBuilder Japanese(String japanese) {
            this.japanese = japanese;
            return this;
        }

        public Language build() {
            return new Language(this.chinese, this.english, this.japanese);
        }

    }

}

​ 建造者模式提供了一种创建对象的方式，通过链式构造对象，使得new一个对象的过程紧密连在一起，同时也避免了多个构造函数的头疼情况。建造者模式更加关注零件装配的顺序和过程。

​ 当然了，建造者模式也不是没有缺点的，大家可能已经看出来了，代码的量比使用构造方法多的多，并且需要先建造出一个Builder对象，才能拿到想要的Car对象。这在一定程度上，增加了维护的成本。

​ 建造者模式有利有弊，反正我是喜欢用建造者模式，因为很装x，能不断的点出方法，不要太舒服… …，咳咳，并且现在有lombok提供的@Builder注解，不需要自己实现建造者模式，所以大家还在等什么，还不行动起来，自己写一个建造者模式！

​ Java中的StringBuilder就是使用到了建造者模式，感兴趣的同学可以深入去了解下源码。

​ 好啦，本章有关于建造者模式的知识分享就到这里啦，感谢观看呀！

愿每个人都能带着怀疑的态度去阅读文章并探究其中原理。

道阻且长，往事作序，来日为章。

期待我们下一次相遇！