Builder建造者模式

最新推荐文章于 2022-09-26 16:33:30 发布

Perkinl

最新推荐文章于 2022-09-26 16:33:30 发布

阅读量3.9k

点赞数

分类专栏：设计模式文章标签： java 设计模式 builder

本文链接：https://blog.csdn.net/lp284558195/article/details/111013654

版权

设计模式专栏收录该内容

4 篇文章 0 订阅

订阅专栏

建造者模式是日常开发中比较常见的设计模式，它的主要作用就是将复杂事物创建的过程抽象出来，该抽象的不同实现方式不同，创建出的对象也不同。通俗的讲，创建一个对象一般都会有一个固定的步骤，这个固定的步骤我们把它抽象出来，每个抽象步骤都会有不同的实现方式，不同的实现方式创建出的对象也将不同。举个常见的例子，想必大家都买过电脑，电脑的生产或者组装其实就是属于建造者模式，我们知道，电脑的生产都需要安装CPU、内存条、硬盘等元器件。我们可以把这个安装步骤抽象出来，至于到底装哪种CPU，比如i5还是i7就是对该抽象安装步骤的具体实现。

建造者模式？

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建一个复杂的对象。

建造者模式主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

Builder模式

建造者模式分为两种，一种为经典建造者模式，另一种为变种建造者模式。

经典Builder模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kCfIdMxk-1607609422922)(/Users/lipan/app/typora-pic/image-20201210205916789.png)]

从上图可以看到，经典Buider模式中有四个角色：

Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。在建造过程完成后，提供产品的实例。
Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
Product：要创建的复杂对象。

1.首先创建一个Product对象：

public class Computer {
    /*CPU*/
    private String CPU;
    /*内存*/
    private String memory;
    /*硬盘*/
    private String hardDisk;
    /*键盘*/
    private String keyboard;
    /*鼠标*/
    private String mouse;

    public String getCPU() {
        return CPU;
    }

    public void setCPU(String CPU) {
        this.CPU = CPU;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public String getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String getKeyboard() {
        return keyboard;
    }

    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }

    public String getMouse() {
        return mouse;
    }

    public void setMouse(String mouse) {
        this.mouse = mouse;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "CPU='" + CPU + '\'' +
                ", memory='" + memory + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", keyboard='" + keyboard + '\'' +
                ", mouse='" + mouse + '\'' +
                '}';
    }
}

2. 创建一个抽象的电脑组装过程的Builder类：

public interface IComputerConfigBuilder {
    /**
     * CPU
     */
    void setCpu();

    /**
     * 内存
     */
    void setMemory();

    /**
     * 磁盘
     */
    void setHardDisk();

    /**
     * 键盘
     */
    void setKeyboard();

    /**
     * 鼠标
     */
    void setMouse();

    /**
     * 电脑
     *
     * @return
     */
    Computer getComputer();
}

电脑组装一般都需要安装CPU、内存条、硬盘、键盘鼠标等，我们把这一安装过程给抽象出来，也就是这里的ComputerConfigBuilder ，至于具体安装什么需要其实现类来实现，另外其中还定义了一个获取Conputer的方法。

3.有了抽象的组装过程，接下来我们就需要创建具体的实现类(ConcreteBuilder)

我们知道电脑一般都有低配版和高配版，不同配置，组装成的电脑自然就不一样。接下我们首先来创建一个低配版的套餐LowConfigBuilder ，让其实现ComputerConfigBuilder：

//i5的CPU、8G内存、500G硬盘、薄膜键盘和有线鼠标。
public class LowConfigBuilder implements IComputerConfigBuilder {

    private Computer mComputer;

    public LowConfigBuilder() {
        this.mComputer = new Computer();
    }

    @Override
    public void setCpu() {
        mComputer.setCPU("i5");
    }

    @Override
    public void setMemory() {
        mComputer.setMemory("8G");
    }

    @Override
    public void setHardDisk() {
        mComputer.setHardDisk("500G");
    }

    @Override
    public void setKeyboard() {
        mComputer.setKeyboard("薄膜键盘");
    }

    @Override
    public void setMouse() {
        mComputer.setMouse("有线鼠标");
    }

    @Override
    public Computer getComputer() {
        return mComputer;
    }
}

接着我们再创建一个高配版的套餐：

// i7的CPU、16G内存、1T硬盘、机械键盘和无线鼠标
public class HighConfigBuilder implements IComputerConfigBuilder {

    private Computer mComputer;

    public HighConfigBuilder() {
        this.mComputer = new Computer();
    }

    @Override
    public void setCpu() {
        mComputer.setCPU("i7");
    }

    @Override
    public void setMemory() {
        mComputer.setMemory("16G");
    }

    @Override
    public void setHardDisk() {
        mComputer.setHardDisk("1T");
    }

    @Override
    public void setKeyboard() {
        mComputer.setKeyboard("机械键盘");
    }

    @Override
    public void setMouse() {
        mComputer.setMouse("无线鼠标");
    }

    @Override
    public Computer getComputer() {
        return mComputer;
    }
}

4.Director是建造者模式的核心，调用具体建造者来创建不通配置的电脑：

public class Director {
    private IComputerConfigBuilder mBuilder;

    /**
     * setBuilder来告诉需要什么配置电脑
     *
     * @param builder
     */
    public void setBuilder(IComputerConfigBuilder builder) {
        this.mBuilder = builder;
    }

    /**
     * 一步步组装电脑
     */
    public void createComputer() {
        mBuilder.setCpu();
        mBuilder.setMemory();
        mBuilder.setHardDisk();
        mBuilder.setKeyboard();
        mBuilder.setMouse();
    }

    /**
     * 获取组装后的电脑
     *
     * @return
     */
    public Computer getComputer() {
        return mBuilder.getComputer();
    }
}

我们需要通过setBuilder来告诉他电脑需要什么配置，然后就可以通过createComputer来一步步组装电脑，组装完之后就可以调用getComputer方法来获取我们需要的电脑啦。

// 测试
    @Test
    public void buildPatternsV1Test() {
        Director director = new Director();//创建装机人员
        director.setBuilder(new LowConfigBuilder()); //告诉装机人员电脑配置，这里为低配版
        director.createComputer(); //装机人员开始组装
        Computer computer = director.getComputer(); //从装机人员获取组装好的电脑
        System.out.print("电脑配置：" + computer.toString());  //查看电脑配置

//        director.setBuilder(new HighConfigBuilder());
//        director.createComputer();
//        Computer computer = director.getComputer();
//        System.out.print("电脑配置：" + computer.toString());
    }

变种Builder模式

今天Boss突然跑过来扔了一个需求给你：需要创建一个不可变的Person对象，这个Person可以拥有以下几个属性：名字、性别、年龄、职业、车、鞋子、衣服、钱、房子。其中名字和性别是必须有的。

public class Person {
    /*名字（必须）*/
    private final String name;
    /*性别（必须）*/
    private final String gender;
    /*年龄（非必须）*/
    private final String age;
    /*鞋子（非必须）*/
    private final String shoes;
    /*衣服（非必须）*/
    private final String clothes;
    /*钱（非必须）*/
    private final String money;
    /*房子（非必须）*/
    private final String house;
    /*汽车（非必须）*/
    private final String car;
    /*职业（非必须）*/
    private final String career;

    public Person(String name,String gender,String age,String shoes,String clothes,String money,String house,String car,String career){
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.shoes = shoes;
        this.clothes = clothes;
        this.money = money;
        this.house = house;
        this.car = car;
        this.career = career;
    }

    public Person(String name, String gender){
        this(name,gender,null,null,null,null,null,null,null);
    }

}

由于要创建出的Person对象是不可变的，所以你将类中的属性都声明为final的，然后定义了一个参数为所有属性的构造方法，又因为name和gender为必须项，所以你为了调用者方便又单独定义了一个参数为name和gender的构造方法。这样Person类就好了，你信心满满的把这个类提交给了Boss,Boss看了，还是很满意的，不过一段时间后，Boss向你反馈了一个问题，就是如果需要传入非必须属性的时候，这个构造方法调用起来不是很方便，因为这个构造方法参数太多了，很容易传错。你试了下，发现确实有这个问题，看来不能把参数全都都放在构造方法中，很快你想到了用set方法设置：

public class Person {
    /*名字（必须）*/
    private String name;
    /*性别（必须）*/
    private String gender;
    /*年龄（非必须）*/
    private String age;
    /*鞋子（非必须）*/
    private String shoes;
    /*衣服（非必须）*/
    private String clothes;
    /*钱（非必须）*/
    private String money;
    /*房子（非必须）*/
    private String house;
    /*汽车（非必须）*/
    private String car;
    /*职业（非必须）*/
    private String career;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getShoes() {
        return shoes;
    }

    public void setShoes(String shoes) {
        this.shoes = shoes;
    }

    ......

}

如果要创建对象的话只用如下操作就行了：

        Person person = new Person();
        person.setName("张三");
        person.setAge("22");
        person.setGender("男");
        person.setCareer("程序员");
        ......

这样看上去比较清晰了，只要创建一个对象，想要赋什么值set上去就可以了，不过你细细看了下，还是发现了不少的问题的，首先用这个set方法，违背了刚开始这个对象不可变的需求，其次用这种set方法一条一条赋值，逼格不够高，另外用这种方式很可能会得到一个不完整的Person对象，因为当你建完了Person对象，可能出于各方面的原因有些信息忘记set了，那么你得到的Person对象就不是你预期的对象。这时，你有点困惑了，只好打开谷歌一顿搜索，没想到还真的找到了解决办法，就是用下面这种变种的Builder模式：

public class Person {
    /*名字（必须）*/
    private final String name;
    /*性别（必须）*/
    private final String gender;
    /*年龄（非必须）*/
    private final String age;
    /*鞋子（非必须）*/
    private final String shoes;
    /*衣服（非必须）*/
    private final String clothes;
    /*钱（非必须）*/
    private final String money;
    /*房子（非必须）*/
    private final String house;
    /*汽车（非必须）*/
    private final String car;
    /*职业（非必须）*/
    private final String career;

    private Person(Builder builder) {
        this.name = builder.name;
        this.gender = builder.gender;
        this.age = builder.age;
        this.shoes = builder.shoes;
        this.clothes = builder.clothes;
        this.money = builder.money;
        this.house = builder.house;
        this.car = builder.car;
        this.career = builder.career;
    }

    public static class Builder {
        private final String name;
        private final String gender;
        private String age;
        private String shoes;
        private String clothes;
        private String money;
        private String house;
        private String car;
        private String career;

        public Builder(String name,String gender) {
            this.name = name;
            this.gender = gender;
        }

        public Builder age(String age) {
            this.age = age;
            return this;
        }

        public Builder car(String car) {
            this.car = car;
            return this;
        }

        public Builder shoes(String shoes) {
            this.shoes = shoes;
            return this;
        }

        public Builder clothes(String clothes) {
            this.clothes = clothes;
            return this;
        }

        public Builder money(String money) {
            this.money = money;
            return this;
        }

        public Builder house(String house) {
            this.house = house;
            return this;
        }

        public Builder career(String career) {
            this.career = career;
            return this;
        }

        public Person build(){
            return new Person(this);
        }
    }

由于这个Person对象是不可变的，所以毫无疑问我们给他的所有属性都加了final修饰，当然如果没有不可变的需求也是可以不加的，然后在Person类中定义一个内部类Builder，这个Builder内部类中的属性要和Person中的相同，并且必须有的属性要用final修饰，防止这些属性没有被赋值，其他非必须的属性不能用final，因为如果加了final，就必须对其进行初始化，这样这些非必须的属性又变成必须的。然后内部类中定义了一个构造方法，传入必须有的属性。其他非必须的属性都通过方法设置，每个方法都返回Builder对象自身。最后定义了一个build方法，将Builder对象传入Person的私有构造方法，最终返回一个对象。

接下来我们来看下Person的创建：

        Person person = new Person.Builder("张三","男")
                .age("12")
                .money("1000000")
                .car("宝马")
                .build();

是不是看上去逼格瞬间提高了，非必须的属性可以根据需要任意设置，非常灵活，而且这样先设置属性再创建对象，最终获取的对象一定是你预期的完整对象，不会像用之前set的方法创建的对象可能还没有设置完全。好了，写完之后，你迫不及待的把这个Person类提交给了Boss，果然Boss对这种对象创建方式非常满意。

它使用了内部类的方式，将原来自己的类方法变成私有的，而后提供一个静态的内部类来创建对象。另外通过返回this对象来链式调用，本类同时为对象提供了一个默认值

Builder模式使用注意事项

客户端（使用程序）不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程
增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”
建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不符合使用建造者模式，因此其使用范围受到一定的限制。
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式。
抽象工厂模式 VS 建造者模式 抽象工厂模式实现对产品家族的创建，一个产品的家族是这样的一系列产品；具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。而建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。

建造者模式与工厂模式类似，他们都是建造者模式，适用的场景也很相似。一般来说，如果产品的建造很复杂，那么请用工厂模式；如果产品的建造更复杂，那么请用建造者模式。

参考文章

https://www.jianshu.com/p/afe090b2e19c (大部分来源于此文章)
https://zhuanlan.zhihu.com/p/58093669
https://cloud.tencent.com/developer/article/1600768
http://www.manongjc.com/article/12059.html

Perkinl

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Builder建造者模式

建造者模式是日常开发中比较常见的设计模式，它的主要作用就是将复杂事物创建的过程抽象出来，该抽象的不同实现方式不同，创建出的对象也不同。通俗的讲，创建一个对象一般都会有一个固定的步骤，这个固定的步骤我们把它抽象出来，每个抽象步骤都会有不同的实现方式，不同的实现方式创建出的对象也将不同。举个常见的例子，想必大家都买过电脑，电脑的生产或者组装其实就是属于建造者模式，我们知道，电脑的生产都需要安装CPU、内存条、硬盘等元器件。我们可以把这个安装步骤抽象出来，至于到底装哪种CPU，比如i5还是i7就是对该抽象安装步.
复制链接

扫一扫

专栏目录