设计模式（三）创建型模式---建造者模式（builder）

建造者模式简介

• 建造者模式（builder pattern）将对象的创建和表示分离，分离了对象的构建（Builder）和装配（Director）,实现了构建和装配的解耦。不同的构建，相同的装配，可以创建不同的对象，相同的构建器，不同的装配顺序也可以做出不同的对象。

结构

• 1.抽象建造者类（Builder）：规定了要实现复杂对象的部分的创建，但是并不涉及具体部件对象的创建。
• 2.具体建造者类（ConcreteBuilder）：实现了Builder接口，完成复杂产品各个不见的具体创建方法。在构造方法完成后，提供产品的实例。
• 3.产品类（Product）：要创建的复杂对象。
• 4.指挥者类（Director）：调用具体建造者类来创建复杂对象的各个部分，在这个过程中不涉及具体产品的信息，只保证对象各部分完整活按顺序创建。

UML图

具体实现

• UML图
  
• 自行车类（产品类）

package com.xxliao.pattern.creational.builder.demo;

/**
 * @author xxliao
 * @description: 产品类
 * @date 2024/5/24 16:59
 */
public class Bike {

    private String frame;

    private String seat;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getSeat() {
        return seat;
    }

    public void setSeat(String seat) {
        this.seat = seat;
    }

    @Override
    public String toString() {
        return "Bike{" +
                "frame='" + frame + '\'' +
                ", seat='" + seat + '\'' +
                '}';
    }
}

• 抽象建造者类

package com.xxliao.pattern.creational.builder.demo;

/**
 * @author xxliao
 * @description: 抽象建造者类
 * @date 2024/5/24 17:00
 */
public abstract class Builder {

    // 单车产品对象
    Bike bike = new Bike();

    // build frame
    public abstract void buildFrame();

    // build seat
    public abstract void buildSeat();

    // define create bike method
    public abstract Bike createBike();
}

• 凤凰自行车建造类（具体建造类）

package com.xxliao.pattern.creational.builder.demo;

/**
 * @author xxliao
 * @description: 凤凰自行车 具体建造类
 * @date 2024/5/24 17:05
 */
public class FengHuangBikeBuilder extends Builder{

    @Override
    public void buildFrame() {
        bike.setFrame("fenghuang-frame");
    }

    @Override
    public void buildSeat() {
        bike.setSeat("fenghuang-seat");
    }

    @Override
    public Bike createBike() {
        return bike;
    }
}

• 永久自行车建造类（具体建造类）

package com.xxliao.pattern.creational.builder.demo;

/**
 * @author xxliao
 * @description: 永久Bike 具体建造者类
 * @date 2024/5/24 17:03
 */
public class YongJiuBikeBuilder extends Builder{

    @Override
    public void buildFrame() {
        bike.setFrame("yongjiu-frame");
    }

    @Override
    public void buildSeat() {
        bike.setSeat("yongjiu-seat");
    }

    @Override
    public Bike createBike() {
        return bike;
    }
}

• 指挥者类（指挥者类）

package com.xxliao.pattern.creational.builder.demo;

/**
 * @author xxliao
 * @description: 指挥者类
 * @date 2024/5/24 17:06
 */

public class Director {

    // 建造者类
    private Builder builder;

    // 构造方法 填充建造者
    public Director(Builder builder) {
        this.builder = builder;
    }

    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    // 创建 产品
    public Bike construct() {
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }
}

• 测试客户端

package com.xxliao.pattern.creational.builder.demo;

/**
 * @author xxliao
 * @description: 建造者模式 测试类
 * @date 2024/5/24 17:09
 */
public class Client {

    public static void main(String[] args) {
        YongJiuBikeBuilder yongJiuBikeBuilder = new YongJiuBikeBuilder();
        Director director = new Director(yongJiuBikeBuilder);
        Bike bike1 = director.construct();
        System.out.println(bike1);

        System.out.println("=====================================");

        FengHuangBikeBuilder fengHuangBikeBuilder = new FengHuangBikeBuilder();
        director.setBuilder(fengHuangBikeBuilder);
        Bike bike2 = director.construct();
        System.out.println(bike2);

    }
}

优缺点

• 优点：

1. 建造者模式中，客户端不必知道产品内部组成的细节，将产品本身和产品的创建过程解耦，使用相同的创建过程可以创建不同的产品对象。
2. 建造者模式易于扩展，如果有新的需求，通过实现一个新的建造类就可以完成，不用修改原有代码，符合开闭原则。

• 缺点：

1. 建造者模式所创建的产品一般具有较多的共同点，组成部分相似，如果产品差异很大，则不合适使用建造者模式。

建造者使用扩展（链式编程）

• 建造者类

package com.xxliao.pattern.creational.builder.expansion;

/**
 * @author xxliao
 * @description: builder 使用模式扩展
 * @date 2024/5/24 17:43
 */

public class AppendBuilder {

    private String name;

    private String sex;

    private String address;

    private String idCard;

    public AppendBuilder(Builder builder) {
        name = builder.name;
        sex = builder.sex;
        address = builder.address;
        idCard = builder.idCard;
    }

    @Override
    public String toString() {
        return "AppendBuilder{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                ", idCard='" + idCard + '\'' +
                '}';
    }

    // 创建builder
    public static final class Builder{
        private String name;

        private String sex;

        private String address;

        private String idCard;

        public Builder() {

        }

        public Builder name(String val) {
            name = val;
            return this;
        }

        public Builder sex(String val) {
            sex = val;
            return this;
        }

        public Builder address(String val) {
            address = val;
            return this;
        }

        public Builder idCard(String val) {
            idCard = val;
            return this;
        }

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

• 测试客户端

package com.xxliao.pattern.creational.builder.expansion;

/**
 * @author xxliao
 * @description: 建造者模式 扩展测试类
 * @date 2024/5/24 17:51
 */

public class Client {

    public static void main(String[] args) {
        AppendBuilder appendBuilder = new AppendBuilder.Builder()
                .name("name")
                .sex("男")
                .idCard("500234")
                .address("重庆市")
                .build();
        System.out.println(appendBuilder);
    }
}