23中设计模式-创建型模式-建造者模式

建造者模式

1. 建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。
2. 建造者(Builder)模式包含如下角色：
   • 抽象建造者类(Builder):这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的对象部分的创建。
   • 具体建造者类(ConcreteBuilder):实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
   • 产品类(Product):要创建的复杂对象。
   • 指挥者类(Director):调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
3. 适用场景：
   • 所创建的产品其生产过程没有太大变化，其组成部分相似，创建过程相对复杂。如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

通用UML模型

本例UML模型

具体代码实现如下

第一种建造者模式

Build抽象类

package com.lcq.builderpattern.build1;

/**
 * 建造者
 * 只注重电脑的生产过程
 */
public abstract class Builder {

    protected Computer computer = new Computer();

    //组装主板
    public abstract void buildMotherboard();
    //组装cpu
    public abstract void buildCpu();
    //组装内存
    public abstract void buildMemory();
    //组装显卡
    public abstract void buildGpu();

    //生产电脑
    public Computer build(){
        buildMotherboard();
        buildCpu();
        buildMemory();
        buildGpu();
        return computer;
    }
}

MacBuilder实现类

package com.lcq.builderpattern.build1;

/**
 * 苹果电脑建造者
 */
public class MacBuilder extends Builder{

    public void buildMotherboard() {
        computer.setMotherboard("ATX");//标准型主板
    }

    public void buildCpu() {
        computer.setCpu("Intel酷睿2双核 T7200");
    }

    public void buildMemory() {
        computer.setMemory("64G");
    }

    public void buildGpu() {
        computer.setGpu("集成显卡");
    }
}

ThinkPadBuilder实现类

package com.lcq.builderpattern.build1;

/**
 * 联想电脑建造者
 */
public class ThinkPadBuilder extends Builder{

    @Override
    public void buildMotherboard() {
        computer.setMotherboard("MATX");//紧凑型主板
    }

    @Override
    public void buildCpu() {
        computer.setCpu("英特尔酷睿i5处理器");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("8G");
    }

    @Override
    public void buildGpu() {
        computer.setGpu("独立显卡");
    }
}

Director指挥者

package com.lcq.builderpattern.build1;

/**
 * 指挥者
 * 指挥建造者生产产品
 */
public class Director {
    private Builder builder;

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

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

    public Computer product(){
        return builder.build();
    }
}

Computer电脑(产品)

package com.lcq.builderpattern.build1;

import lombok.Data;

/**
 * 电脑
 */
@Data
public class Computer {
    private String motherboard;//主板
    private String cpu;//cpu
    private String memory;//内存
    private String gpu;//显卡
}

测试

package com.lcq.builderpattern.build1;

public class Test {
    public static void main(String[] args) {
        //测试
            //生产苹果电脑
            Director director = new Director(new MacBuilder());
            Computer macComputer = director.product();
            System.out.println(macComputer);

            //生产联想电脑
            director.setBuilder(new ThinkPadBuilder());
            Computer thinkPadComputer = director.product();
            System.out.println(thinkPadComputer);
    }
}

运行结果

适用场景：通过测试结果我们可以发现，我们无需关注电脑的组装过程即可生产不同的电脑。当创建对象的过程过于复杂时，且这类对象的创建过程没有太大的变化，我们可以采用这种将创建部分的过程交给建造者的方式创建对象。

---

第二种建造者模式(链式创建)

Computer电脑(产品)

package com.lcq.builderpattern.build2;

import lombok.Data;
import lombok.Getter;
import lombok.ToString;

/**
 * 电脑
 */
@ToString
public class Computer {
    private String motherboard;//主板
    private String cpu;//cpu
    private String memory;//内存
    private String gpu;//显卡

    private Computer(Build build){
        this.motherboard = build.motherboard;
        this.cpu = build.cpu;
        this.memory = build.memory;
        this.gpu = build.gpu;
    }

    public static final class Build{
        private String motherboard;
        private String cpu;
        private String memory;
        private String gpu;

        public Build motherboard(String motherboard){
            this.motherboard = motherboard;
            return this;
        }
        public Build cpu(String cpu){
            this.cpu = cpu;
            return this;
        }
        public Build memory(String memory){
            this.memory = memory;
            return this;
        }
        public Build gpu(String gpu){
            this.gpu = gpu;
            return this;
        }

        //使用建造者生产电脑
        public Computer build(){
            return new Computer(this);
        }
    }
}

测试

package com.lcq.builderpattern.build2;

public class Test {
    public static void main(String[] args) {
        Computer thinkPadComputer = new Computer.Build().
                motherboard("MATX")
                .cpu("英特尔酷睿i5处理器")
                .memory("16G")
                .gpu("独立显卡").build();
        System.out.println(thinkPadComputer);
    }
}

运行结果

适用场景：创建的对象属性太多时，我们可以采用这种链式调用的方式创建对象，相对于有参构造与set方法更加灵活。