设计模式 ~ 创建型模式 ~ 建造者模式 ~ Builder Pattern。

lyfGeek

已于 2023-02-16 17:48:06 修改

阅读量128

点赞数 1

分类专栏：设计模式。文章标签：建造者模式设计模式创建型模式

于 2020-12-20 16:09:36 首次发布

本文链接：https://blog.csdn.net/lyfGeek/article/details/111439598

版权

设计模式。专栏收录该内容

24 篇文章 0 订阅

订阅专栏

设计模式 ~ 创建型模式 ~ 建造者模式 ~ Builder Pattern。

文章目录

- 设计模式 ~ 创建型模式 ~ 建造者模式 ~ Builder Pattern。

what。

将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

（组装电脑）。

分离了部件的构造（由 Builder 来负责）和装配（由 Director 负责）。从而可以构造出复杂的对象。

这个模式适用于：某个对象的构建过程复杂的情况。

由于实现了构建和装配的解耦。
不同的构建器，相同的装配顺序，也可以做出不同的对象。
相同的构建器，不同的装配顺序，也可以做出不同的对象。
也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

结构。

建造者（Builder）模式包含如下角色。

抽象建造者类（Builder）。
这个接口（规范（接口）或抽象类）规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。
具体建造者类（ConcreteBuilder）。
实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
产品类（Product）。
要创建的复杂对象。
指挥者类（Director）。
调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

在这里插入图片描述
【eg.】创建共享单车。

生产自行车是一个复杂的过程，它包含了车架，车座等组件的生产。而车架又有碳纤维，铝合金等材质的，车座有橡胶，真皮等材质。对于自行车的生产就可以使用建造者模式。

这里 Bike 是产品，包含车架，车座等组件。
Builder 是抽象建造者。
MobikeBuilder 和 OfoBuilder 是具体的建造者。
Director 是指挥者。

package com.geek.builder.pattern.demo;

import lombok.Data;

/**
 * 产品对象。
 *
 * @author geek
 */
@Data
public class Bike {

    /**
     * 车架。
     */
    private String frame;

    /**
     * 车座。
     */
    private String seat;

}

package com.geek.builder.pattern.demo;

/**
 * 建造者抽象类。
 *
 * @author geek
 */
public abstract class AbstractClassBuilder {

    /**
     * 声明 Bike 类型的变量，并进行赋值。
     */
    protected Bike bike = new Bike();

    /**
     * 构建车架。
     */
    public abstract void buildFrame();

    /**
     * 构建车座。
     */
    public abstract void buildSeat();

    /**
     * 构建自行车。
     *
     * @return
     */
    public abstract Bike createBike();

    public Bike construct() {
        this.buildFrame();
        this.buildSeat();
        return this.createBike();
    }

}

package com.geek.builder.pattern.demo;

/**
 * 具体的构建者 ~ 构建摩拜单车。
 *
 * @author geek
 */
public class MobikeBuilder extends AbstractClassBuilder {

    /**
     * 构建车架。
     */
    @Override
    public void buildFrame() {
        bike.setFrame("碳纤维车架。");
    }

    /**
     * 构建车座。
     */
    @Override
    public void buildSeat() {
        bike.setSeat("真皮车座。");
    }

    /**
     * 构建自行车。
     *
     * @return
     */
    @Override
    public Bike createBike() {
        return bike;
    }

}

package com.geek.builder.pattern.demo;

/**
 * 具体的构建者 ~ 构建 ofo 单车。
 *
 * @author geek
 */
public class OfoBuilder extends AbstractClassBuilder {

    /**
     * 构建车架。
     */
    @Override
    public void buildFrame() {
        bike.setFrame("铝合金车架。");
    }

    /**
     * 构建车座。
     */
    @Override
    public void buildSeat() {
        bike.setSeat("橡胶车座。");
    }

    /**
     * 构建自行车。
     *
     * @return
     */
    @Override
    public Bike createBike() {
        return bike;
    }

}

package com.geek.builder.pattern.demo;

/**
 * 指挥者类。
 *
 * @author geek
 */
public class Director {

    /**
     * 声明 Builder 类型的变量。
     */
    private final AbstractClassBuilder builder;

    public Director(AbstractClassBuilder builder) {
        this.builder = builder;
    }

    public Bike construct() {
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }

}

package com.geek.builder.pattern.demo;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        // 创建指挥者对象。
        Director director = new Director(new MobikeBuilder());
        // 指挥者指挥组装自行车。
        Bike bike = director.construct();
        System.out.println("bike = " + bike);
        // bike = Bike(frame=碳纤维车架。, seat=真皮车座。)
    }

}

在这里插入图片描述
建造者模式也属于创建型模式，ta 提供了一种创建对象的最佳方式。

定义：将一个复杂对象的构建与 ta 的表示分离，使得同样的构建过程可以创建不同的表示。
作用：在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。
用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）。

eg.

工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）。
汽车购买者（用户）：只需要说出型号（对象的类型和内容），然后直接购买就可以使用了（不需要知道汽车是怎么组装的（车轮、车门、发动起、方向盘等））。

工厂模式创建零件，建造者模式组装。

package com.geek.builder.pattern.demo00;

/**
 * 抽象建造者。
 *
 * @author geek
 */
public abstract class AbstractClassBuilder {

    /**
     * 地基。
     */
    abstract void buildA();

    /**
     * 钢筋工程。
     */
    abstract void buildB();

    /**
     * 铺电线。
     */
    abstract void buildC();

    /**
     * 粉刷。
     */
    abstract void buildD();

    /**
     * 完工，得到产品。
     *
     * @return
     */
    abstract Product getProduct();

}

package com.geek.builder.pattern.demo00;

/**
 * 具体的建造者 ~ 工人。
 *
 * @author geek
 */
public class Worker extends AbstractClassBuilder {

    private Product product;

//    public Worker(Product product) {
//        this.product = product;
//    }

    // 工人不是参数传进来的，是 new。
    // 工人负责创建产品。
    public Worker() {
        this.product = new Product();
    }

    // 工人干活。

    @Override
    void buildA() {
        product.setBuildA("地基。");
        System.out.println("地基。");
    }

    @Override
    void buildB() {
        product.setBuildB("钢筋工程。");
        System.out.println("钢筋工程。");
    }

    @Override
    void buildC() {
        product.setBuildC("铺电线。");
        System.out.println("铺电线。");
    }

    @Override
    void buildD() {
        product.setBuildD("粉刷。");
        System.out.println("粉刷。");
    }

    @Override
    Product getProduct() {
        return this.product;
    }

}

package com.geek.builder.pattern.demo00;

import lombok.Data;

/**
 * 产品 ~ 房子。
 *
 * @author geek
 */
@Data
public class Product {

    private String buildA;

    private String buildB;

    private String buildC;

    private String buildD;

}

package com.geek.builder.pattern.demo00;

/**
 * 指挥 ~ 核心。
 * 负责指挥构建一个工程。
 * 工程如何构建，由 ta 决定。
 *
 * @author geek
 */
public class Director {

    /**
     * 指挥工人按照顺序建房子。
     *
     * @param builder
     * @return
     */
    public Product build(AbstractClassBuilder builder) {
        builder.buildA();
        builder.buildB();
        builder.buildC();
        builder.buildD();

        return builder.getProduct();
    }

}

package com.geek.builder.pattern.demo00;

/**
 * @author geek
 */
public class Test {

    public static void main(String[] args) {
        // 指挥。
        Director director = new Director();
        // 指挥具体不同的工人完成产品。
        Product build = director.build(new Worker());
        System.out.println(build);
    }

}

上面示例是 Builder 模式的常规用法，指挥者类 Director 在 Builder 模式中具有很重要的作用，它用于指导具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有些情况下需要简化系统结构，可以把 Director 和抽象建造者进行结合。

package com.geek.builder.pattern.demo;

/**
 * 建造者抽象类。
 *
 * @author geek
 */
public abstract class AbstractClassBuilder {

    /**
     * 声明 Bike 类型的变量，并进行赋值。
     */
    protected Bike bike = new Bike();

    /**
     * 构建车架。
     */
    public abstract void buildFrame();

    /**
     * 构建车座。
     */
    public abstract void buildSeat();

    /**
     * 构建自行车。
     *
     * @return
     */
    public abstract Bike createBike();

    public Bike construct() {
        this.buildFrame();
        this.buildSeat();
        return this.createBike();
    }

}

通过静态内部类方式实现零件无序装配构造，这种方式使用更加灵活，更符合定义。内部有复杂对象的默认实现，使用时可以根据用户需求自由定义更改内容，并且无需改变具体构造方式。就可以生产出不同复杂产品。

eg. 麦当劳的套餐，服务员（具体建造者）可以随意搭配任意几种产品（零件）组成一款套餐（产品），然后出售给客户。比第一种方式少了指挥者，主要是因为第二种方式把指挥者交给用户来操作，使得产品的创建更加简单灵活。

package com.geek.builder.pattern.demo01;

/**
 * 建造者。
 *
 * @author geek
 */
public abstract class AbstractClassBuilder {

    /**
     * （// 汉堡。）
     *
     * @param msg
     * @return
     */
    public abstract AbstractClassBuilder buildA(String msg);

    /**
     * （// 可乐。）
     *
     * @param msg
     * @return
     */
    public abstract AbstractClassBuilder buildB(String msg);

    /**
     * （// 薯条。）
     *
     * @param msg
     * @return
     */
    public abstract AbstractClassBuilder buildC(String msg);

    /**
     * （// 甜点。）
     *
     * @param msg
     * @return
     */
    public abstract AbstractClassBuilder buildD(String msg);

    /**
     * get。
     *
     * @return
     */
    public abstract Product getProduct();

}

package com.geek.builder.pattern.demo01;

import lombok.Data;

/**
 * 产品 ~ 套餐。
 *
 * @author geek
 */
@Data
public class Product {

    private String buildA = "汉堡";
    private String buildB = "可乐";
    private String buildC = "薯条";
    private String buildD = "甜点";

}

package com.geek.builder.pattern.demo01;

/**
 * 具体的建造者。
 *
 * @author geek
 */
public class Worker extends AbstractClassBuilder {

    private final Product product;

    public Worker() {
        this.product = new Product();
    }

    @Override
    public AbstractClassBuilder buildA(String msg) {
        product.setBuildA(msg);
        return this;
    }

    @Override
    public AbstractClassBuilder buildB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    public AbstractClassBuilder buildC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    public AbstractClassBuilder buildD(String msg) {
        product.setBuildD(msg);
        return this;
    }

    @Override
    public Product getProduct() {
        return product;
    }

}

package com.geek.builder.pattern.demo01;

/**
 * @author geek
 */
public class Test {

    public static void main(String[] args) {
        // 服务员。
        Worker worker = new Worker();
        Product product = worker.getProduct();
        System.out.println("product = " + product);
        // 顺序交给客户端自由指定。在原来的基础上，可以自由组合。如果不自由组合，也有默认的套餐。
        Product product1 = worker.buildA("全家桶").buildB("雪碧").getProduct();
        System.out.println("product1 = " + product1);
    }

}


/*
product = Product{buildA='汉堡', buildB='可乐', buildC='薯条', buildD='甜点'}
product1 = Product{buildA='全家桶', buildB='雪碧', buildC='薯条', buildD='甜点'}

Process finished with exit code 0
 */

优点。

建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
在建造者模式中，客户端不必知道产品内部的组成细节，将产品本身与产品的场景过程解耦，是的相同的场景过程可以创建不同的产品对象。
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清洗，也更方便使用程序来控制创建过程。
建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则。

产品的建造和表示分离，实现了解耦。使用建造者模式可以使客户端不必知道产品内部组成的细节。
将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰。
具体的建造者类之间是相互独立的，这有利于系统的扩展。增加新的具体建造者无需修改原有类库的代码，符合“开闭原则”。

缺点。

建造者模式所创建的产品一般具有较多的共同点，其组成部分相似.如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

应用场景。

需要生成的产品对象复杂的内部结构，这些产品对象具备共性。
隔离复杂对象的创建和使用并使得相同的创建过程可以创建不同的产品。
适合于一个具有较多的零件（属性）的产品（对象）的创建过程。

建造者与抽象工厂模式的比较。

与抽象工厂模式相比，建造者模式返回一个组装好的完整产品，而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。
在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤，它侧重于一步步构造一个复杂对象，返回一个完整的对象。
如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车。

链式编程。

package com.geek.builder.pattern.chain;

import lombok.Data;

/**
 * @author geek
 */
@Data
public class Phone {

    private String cpu;

    private String screen;

    private String memory;

    private String mainBoard;

    /**
     * 私有构造方法。
     *
     * @param builder
     */
    private Phone(Builder builder) {
        this.cpu = builder.cpu;
        this.screen = builder.screen;
        this.memory = builder.memory;
        this.mainBoard = builder.mainBoard;
    }

    public static final class Builder {

        private String cpu;

        private String screen;

        private String memory;

        private String mainBoard;

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

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

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

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

        /**
         * 使用构建者创建对象。
         *
         * @return
         */
        public Phone build() {
            return new Phone(this);
        }

    }

}

package com.geek.builder.pattern.chain;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        // 创建手机对象。通过构建者对象获取手机对象。
        Phone build = new Phone.Builder()
                .cpu("intel")
                .screen("三星屏幕")
                .memory("金士顿内存条")
                .mainBoard("华硕主板")
                .build();
        System.out.println("build = " + build);
    }

}