建造者模式

目录

什么是建造模式

构成

例子

---

什么是建造模式

建造者模式是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

构成

1) 抽象建造者角色(Builder)：这个角色用来规范产品对象的各个组成成分的建造。一般而言，此角色独立于应用程序的业务逻辑。

2) 具体建造者角色(ConcreteBuilder)：担任这个角色的是于应用程序紧密相关的类，它们在指导者的调用下

创建产品实例。这个角色在实现抽象建造者角色提供的方法的前提下，达到完成产品组装，提供成品的功能。

3) 指导者角色(Director)：调用具体建造者角色以创建产品对象。指导者并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者对象。

4) 产品角色(Product)：建造中的复杂对象。它要包含那些定义组件的类，包括将这些组件装配成产品的接口。

例子

传统的建造模式

public class Computer {
    private String cpu;

    private String board;

    private String graphicsCard;

    private String memory;

    public Computer(String cpu, String board , String memory) {
        this.cpu = cpu;
        this.board = board;
        this.memory = memory;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getBoard() {
        return board;
    }

    public void setBoard(String board) {
        this.board = board;
    }

    public String getGraphicsCard() {
        return graphicsCard;
    }

    public void setGraphicsCard(String graphicsCard) {
        this.graphicsCard = graphicsCard;
    }

    public String getMemory() {
        return memory;
    }

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

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", board='" + board + '\'' +
                ", graphicsCard='" + graphicsCard + '\'' +
                ", memory='" + memory + '\'' +
                '}';
    }

/**
 * 抽象建造者类
 */
public abstract class ComputerBuilder {

    public abstract void setGraphicsCard();
    public abstract Computer getComputer();
}

/**
 * 我的电脑建造类
 */
public class MyComputerBuilder extends ComputerBuilder {
    private Computer computer;

    public MyComputerBuilder(String cpu, String board, String memory) {
        computer = new Computer(cpu, board, memory);
    }


    @Override
    public void setGraphicsCard() {
        computer.setGraphicsCard("原有的显卡");
    }


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

/**
 * 指导者类（Director）
 */
public class ComputerDirector {

    public void buildComputer(ComputerBuilder builder){
        builder.setGraphicsCard();
    }
}

public class BuildTest {
    public static void main(String[] args) {
        // 创建一个director对象
        ComputerDirector director = new ComputerDirector();
        //创建builder
        ComputerBuilder mybuilder = new MyComputerBuilder("新cpu", "新board", "新内存");
        //director的组装build对象
        director.buildComputer(mybuilder);
        //使用builder创建产品实例
        Computer computer = mybuilder.getComputer();
        System.out.println(computer);


    }
}

结果:

Computer{cpu='新cpu', board='新board', graphicsCard='原有的显卡', memory='新内存'}

javabean形式的建造者

参考lombok 中的@Builder

省略了director，将构建方法放在了建造者角色中，将builder 写到了要构建的产品类里面

/**
 * @author ysw
 * @date 2021/11/17 3:15 下午
 */
//product
public class NewComputer {
    private String cpu;

    private String board;

    private String graphicsCard;

    private String memory;

    /**
     * 创建一个静态内部类 Builder，然后将Computer 中的参数都复制到Builder类中。
     */
    public static class Builder {
        private String cpu;

        private String board;

        private final String graphicsCard;

        private String memory;

        /**
         * 在Builder中创建一个public的构造函数
         */
        public Builder(String graphicsCard ) {
            this.graphicsCard = graphicsCard;
        }

        /**
         * 在Builder中创建设置函数，对Computer中那些可选参数进行赋值，返回值为Builder类型的实例
         *
         * @param val
         * @return
         */
        public Builder cpu(String val) {
            cpu = val;
            return this;
        }

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

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

        /**
         * 在Builder中创建一个build()方法，在其中构建实例并返回
         *
         * @return
         */
        public NewComputer build() {
            return new NewComputer(this);
        }
    }

    /**
     * 创建一个private的构造函数，参数为Builder类型
     *
     * @param builder
     */
    private NewComputer(Builder builder) {
        cpu = builder.cpu;
        board = builder.board;
        memory = builder.memory;
        graphicsCard = builder.graphicsCard;
    }

    /**
     * 静态方法内部new 对象 不用build 的时候去new
     *
     * @return
     */
    public static Builder builder(String graphicsCard) {
        return new Builder(graphicsCard);
    }

    @Override
    public String toString() {
        return "NewComputer{" +
                "cpu='" + cpu + '\'' +
                ", board='" + board + '\'' +
                ", graphicsCard='" + graphicsCard + '\'' +
                ", memory='" + memory + '\'' +
                '}';
    }
}

public class MainRun {
    public static void main(String[] args) {
        //链式调用
        NewComputer newComputer = NewComputer.builder("老的显卡")
                .board("b1")
                .cpu("c1")
                .memory("m1")
                .build();
        System.out.println(newComputer);

    }
}

结果:

NewComputer{cpu='c1', board='b1', graphicsCard='老的显卡', memory='m1'}

实际应用 

Httpclient中的 HttpClientBuilder