设计模式~~~建造者模式-阿里云开发者社区

学习难度：※※※※

使用频率：※※

在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。例如，计算机是由 CPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。

生活中这样的例子很多，如游戏中的不同角色，其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异；还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样；每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。

以上所有这些产品都是由多个部件构成的，各个部件可以灵活选择，但其创建步骤都大同小异。这类产品的创建无法用前面介绍的工厂模式描述，只有建造者模式可以很好地描述该类产品的创建。

建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

一、定义

指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式

二、优点和缺点

优点:

封装性好，构建和表示分离。
扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

缺点：

产品的组成部分必须相同，这限制了其使用范围。
如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

2.1 特点

它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

三、使用场景

建造者模式唯一区别于工厂模式的是针对复杂对象的创建。也就是说，如果创建简单对象，通常都是使用工厂模式进行创建，而如果创建复杂对象，就可以考虑使用建造者模式。

当需要创建的产品具备复杂创建过程时，可以抽取出共性创建过程，然后交由具体实现类自定义创建流程，使得同样的创建行为可以生产出不同的产品，分离了创建与表示，使创建产品的灵活性大大增加。

建造者模式主要适用于以下应用场景：

相同的方法，不同的执行顺序，产生不同的结果。
多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用
初始化一个对象特别复杂，参数多，而且很多参数都具有默认值。

四、建造者模式的结构及使用

建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成，现在我们来分析其基本结构和实现方法。

4.1 建造者模式的结构

建造者（Builder）模式的主要角色如下。

产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

4.2 代码伺候(建造者模式的使用)

抽象建造者：包含创建产品各个子部件的抽象方法

package build.Builder;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:21
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
//抽象建造者：包含创建产品各个子部件的抽象方法。
public abstract class Builder {
    //创建产品对象
    protected Product product = new Product();
    public abstract void buildPaoA();
    public abstract void buildPaoB();
    public abstract void buildPaoC();
    //返回产品对象
    public Product getProduct(){
        return  product;
    }
}

具体建造者：实现了抽象建造者接口。

package build.Builder;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:25
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
//具体建造者：实现了抽象建造者接口。
public class ConcreteBuilder extends Builder {
    @Override
    public void buildPaoA() {
        System.out.println("建造PaoA");
    }
    @Override
    public void buildPaoB() {
        System.out.println("建造PaoB");
    }
    @Override
    public void buildPaoC() {
        System.out.println("建造PaoC");
    }
}

指挥者：调用建造者中的方法完成复杂对象的创建

package build.Builder;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:26
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
//指挥者：调用建造者中的方法完成复杂对象的创建。
public class Director {
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    //产品构建与组装方法
    public Product construct() {
        builder.buildPaoA();
        builder.buildPaoB();
        builder.buildPaoC();
        return builder.getProduct();
    }
}

产品角色：包含多个组成部件的复杂对象

package build.Builder;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:18
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
//产品角色：包含多个组成部件的复杂对象
public class Product {
    private String proA;
    private String proB;
    private String proC;
    public void setProA(String proA) {
        this.proA = proA;
    }
    public void setProB(String proB) {
        this.proB = proB;
    }
    public void setProC(String proC) {
        this.proC = proC;
    }
    public void show() {
        //显示产品特性
    }
}

测试类

package build.Builder;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:08
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
//测试类
public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();
    }
}

五、应用实例

创建产品簇

package build.Builder.user;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:46
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
public abstract class AbstractProduct {
    protected String name;
    protected String partA;
    protected String partB;
    AbstractProduct(String name){
        this.name = name;
    }
    public String getPartA() {
        return partA;
    }
    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public String toString(){
        return "name:"+name+", partA:"+partA+", partB:"+partB;
    }
}

创建建造者，建造师

package build.Builder.user;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:49
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
//创建建造者，建造师...
// 他来创建产品的细节...
public class ProductBuilder {
    private final AbstractProduct product;
    public ProductBuilder(AbstractProduct product) {
        this.product = product;
    }
    // 设置partA
    public AbstractProduct setPartA(String partA){
        this.product.setPartA(partA);
        return this.product;
    }
    // 设置partB
    public AbstractProduct setPartB(String partB){
        this.product.setPartB(partB);
        return this.product;
    }
    public AbstractProduct getProduct(){
        this.check();
        return product;
    }
    /**
     * 这个方法用来校验product的关键信息是否全部设置完成。
     * @param
     * @author caodahuan
     * @date 2019/8/21
     * @return void
     */
    private void check() {
        // todo
    }
}

package build.Builder.user;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:48
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
public class ProductXX extends AbstractProduct{
    ProductXX(String name) {
        super(name);
    }
}

package build.Builder.user;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:48
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
public class ProductYY  extends AbstractProduct{
    ProductYY(String name) {
        super(name);
    }
}

重点！如何使用建造者帮我们建造

package build.Builder.user;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:50
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
///重点！如何使用建造者帮我们建造
public class Director1 {
    private ProductBuilder builder;
    public Director1(ProductBuilder builder) {
        this.builder = builder;
    }
    public AbstractProduct getProduct(){
        builder.setPartA("零件A");
        builder.setPartB("零件B");
        return builder.getProduct();
    }
}

测试

package build.Builder.user;
/**
 * @Author Gordon
 * @Date 2020/10/9 15:46
 * @Motto: Only practice 72 changes, can laugh at 81 difficult
 */
public class Test {
    public static void main(String[] args) {
        Director1 director = new Director1(new ProductBuilder(new ProductXX("产品XX")));
        AbstractProduct product = director.getProduct();
        System.out.println(product.toString());
        director = new Director1(new ProductBuilder(new ProductXX("产品YY")));
        product = director.getProduct();
        System.out.println(product.toString());
    }
}

六、建造者模式和工厂模式的区别

建造者模式更加注重方法的调用顺序，工厂模式注重创建对象。
创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的部件组成，工厂模式创建出来的对象都一样
关注重点不一样，工厂模式只需要把对象创建出来就可以了，而建造者模式不仅要创建出对象，还要知道对象由哪些部件组成。
建造者模式根据建造过程中的顺序不一样，最终对象部件组成也不一样。

七、模式的扩展

建造者（Builder）模式在应用过程中可以根据需要改变，如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色

设计模式~~~建造者模式

一、定义

二、优点和缺点

2.1 特点

三、使用场景

四、建造者模式的结构及使用

4.1 建造者模式的结构

4.2 代码伺候(建造者模式的使用)

五、应用实例

六、建造者模式和工厂模式的区别

七、模式的扩展

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

设计模式~~~建造者模式

一、 定义

二、 优点和缺点

2.1 特点

三、 使用场景

四、 建造者模式的结构及使用

4.1 建造者模式的结构

4.2 代码伺候(建造者模式的使用)

五、应用实例

六、 建造者模式和工厂模式的区别

七、 模式的扩展

热门文章

最新文章

相关电子书

一、定义

二、优点和缺点

三、使用场景

四、建造者模式的结构及使用

六、建造者模式和工厂模式的区别

七、模式的扩展