建造者模式

0、背景

建造模式（Builder模式）

假如有一个需求：盖房子，盖房子过程是一致的：打桩、砌墙、封顶。但是房子是各式各样的，最后盖出来的房子可能是高楼或别墅。

根据直接的思路，不用设计模式思想，我们也许会：

写一个 CommonHouse 抽象类，然后里面规定了打桩、砌墙、封顶三个方法；
让不同房子继承这个类；
最后调用的时候调用分别的方法即可。

在继承抽象类、子类区分这一块，思想没有问题，问题出现这些类本身。

缺点：

过于简单，将产品（房子）和创建产品（房子建造流程）封装在了一起，耦合性增强了。（可以理解为，面向对象的思想里，房子虽然是一个类，拥有自己的方法，但是房子不应该拥有建造自己的方法）

解决方法：

解耦 - > 建造者模式。

1、建造者模式

建造者模式（Builder Pattern）又叫生成器模式，是一种对象构建模式（创建型），可以将复杂对象的建造过程抽象出来（抽象类），使这个抽象过程的不同实现方法能构造出不同表现（属性）的对象。

建造模式允许用户只通过指定复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具体构建细节。

建造者模式的四个角色：

Product产品：一个具体产品对象；
Builder（抽象建造者）：创建Product对象指定的接口或者抽象类；
ConcreteBuilder具体建造者：实现接口，构建和装配各个部件；
Director指挥者：构建一个使用Builder接口的对象，主要用于创建一个复杂度对象，有两个作用：一是隔离客户与对象的生产过程，二是负责控制产品对象的生产过程。

他们之间的关系，我们用类图来解释：

Directer里面聚合一个Builder实际上使用的是他的实现类ConcreteBuilder；
ConcreteBuilder可以有很多，就是所谓的不同的房子的建造者。

因为getRusult是一样的，所以暂时不用接口，用抽象类实现Builder，代码如下：

/*
    产品，对应product
*/
public class House {
    private String base;
    private String wall;
    private String roof;
    //对应getset方法
}

/*
    抽象的建造者，对应Builder
*/
public abstract class HouseBuilder {
    protected House house = new House();
    //写好流程的各个方法，但不约束具体执行
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void buildRoof();
    //建造方法，返回建造结果
    public House buildHouse(){
        return house;
    }
}

/*
    普通房子制造流程，继承抽象类
    可以看到，制造流程在这里，而House类拥有房子的属性，他们是分开的
    应是对House的操作，这里省略
*/
public class CommonHouse extends HouseBuilder{
    @Override
    public void buildBasic() {
        System.out.println("普通房子：建造地基。。。");
    }
    @Override
    public void buildWalls() {
        System.out.println("普通房子：砌墙。。。");
    }
    @Override
    public void buildRoof() {
        System.out.println("普通房子：盖屋顶。。。");
    }
}

/*
    另一个实现类，本来应是对House的操作，这里省略
*/
public class HighHouse extends HouseBuilder {
    @Override
    public void buildBasic() {
        System.out.println("高楼：建造地基。。。");
    }
    @Override
    public void buildWalls() {
        System.out.println("高楼：砌墙。。。");
    }
    @Override
    public void buildRoof() {
        System.out.println("高楼：盖屋顶。。。");
    }
}

/*
    Director，聚合建造者HouseBuilder
    同时决定制作流程，最后调用建造者的buildHouse方法返回
*/
public class Director {
    HouseBuilder houseBuilder = null;
    //通过构造器聚合
    public Director(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }
    //通过setter方法聚合
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }
    //指挥具体建造流程，先后顺序不由Builder决定
    public House constructHouse(){
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.buildRoof();
        return houseBuilder.buildHouse();
    }
}

/*
    客户端
*/
public class Client {
    public static void main(String[] args) {
        //new房子
        CommonHouse commonHouse = new CommonHouse();
        //new指挥者
        Director director = new Director(commonHouse);
        //完成盖房
        House house = director.constructHouse();

        //重置建造者
        HighHouse highHouse = new HighHouse();
        director.setHouseBuilder(highHouse);
        House house1 = director.constructHouse();
    }
}

上面代码总结起来：一是要把房子归为房子，有属性就够了，建造归建造，相当于是建筑工人，和房子两个对象分开，那么Director相当于包工头，对于不同的House要指挥不一样的Builder群体。

2、建造者模式在JDK中的应用（StringBuilder）

java.lang.StringBuilder类，也就是常用的可变字符串类，用到的就是建造者模式。以其中的常用方法 append 方法为例看源码。

2.1 Appendable 接口

定义了多个 append 方法（抽象方法），即 Appendable 就是我们的抽象建造者Builder 。

2.2 具体的实现类 AbstractStringBuilder

虽然也是一个抽象类，但是也已经实现了 Append able 接口的方法，所以其实相当于是具体的建造者ConcreteBuilder了；

2.3 StringBuilder，继承了AbstractStringBuilder

但是他重写 append 方法的方式只是调用了父类方法，所以应该说，StringBuilder既充当了Director，又是一个ConcreteBuilder.

3、模式的应用场景

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

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

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

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

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

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

摘自：https://www.cnblogs.com/lifegoeson/p/13500365.html

posted @ 2022-03-14 15:12 Arbitrary233 阅读(131) 评论(0) 编辑收藏举报

刷新页面返回顶部

Arbitrary233