建造者模式

建造者模式(Builder Pattern)

定义

将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

屏蔽建造的具体细节,用户不需要知道对象的建造过程和细节,就可以创建出复杂的对象;

通过先设置好建造者的变量,然后再一次性地创建对象,能够避免无效状态,让对象一直处于有效的状态;

避免冗长的构造函数参数;

设置好所有需要的参数之后进行集中校验,能够避免使用set() 时由于属性志军存在依赖关系而产生的由于 set() 顺序错乱而导致的校验失败的问题。

属于创建型模式。

适用场景

  • 创建对象需要很多步骤,但是步骤的顺序不一定固定。
  • 对象有非常复杂的内部结构(属性较多)
  • 希望把复杂对象的创建和使用分离

标准示例

抽象建造者(Builder):定义了构建复杂对象所需的各个部件的接口,但不涉及具体的部件对象的创建。

java 复制代码
public abstract class Builder {
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public abstract Product getResult();
}

具体建造者(ConcreteBuilder):实现抽象建造者的接口,完成复杂产品的各个部件的具体创建方法。在构造过程完成后,提供一个方法返回创建好的产品对象。

java 复制代码
public class ConcreteBuilder1 extends Builder{
    public void buildPartA() {
        product.setPartA("builder1--A");
    }

    public void buildPartB() {
        product.setPartB("builder1--B");
    }

    public void buildPartC() {
        product.setPartC("builder1--C");
    }

    public Product getResult() {
        return product;
    }
}

指挥者(Director):负责安排复杂对象的建造次序,调用具体建造者来创建复杂对象的各个部分。指挥者不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建。

java 复制代码
public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public Product construct(){
        builder.buildPartC();
        builder.buildPartB();
        builder.buildPartA();
        return builder.getResult();
    }
}

产品(Product):需要创建的复杂对象,包含多个组成部件。

java 复制代码
@Data
public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void show() {
        System.out.println("Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}');
    }
}

ClientTest 测试类:

java 复制代码
public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder1();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();

    }
}

输出结果:

java 复制代码
Product{partA='builder1--A', partB='builder1--B', partC='builder1--C'}

我们来举个生活中的例子:

我们想买一台高配置的电脑。

需要选购:CPU、内存、硬盘、显卡、等等。

下面我就通过建造者模式,来模拟这个过程。

涉及到的类有:
ComputerProduct 电脑产品

java 复制代码
@Data
public class ComputerProduct {
    private String cpu;
    private String ram;
    private String hardDisk;
    private String videoCard;

    public String showConfig() {
        return "电脑 " +
                "[" + cpu + ']' +
                "+[" + ram + ']' +
                "+[" + hardDisk + ']' +
                "+[" + videoCard + ']' ;
    }
}

Director 组装指挥者

java 复制代码
public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
	//独立显卡
    public ComputerProduct construct(){
        builder.buildCpu()
                .buildRam()
                .buildHardDisk()
                .buildVideoCard();
        return builder.getResult();
    }
	//集成显卡
    public ComputerProduct construct2(){
        builder.buildCpu()
                .buildRam()
                .buildHardDisk();
        return builder.getResult();
    }
}

Builder 抽象建造者

java 复制代码
public abstract class Builder {
    protected ComputerProduct computerProduct = new ComputerProduct();

    public abstract Builder buildCpu();
    public abstract Builder buildRam();
    public abstract Builder buildHardDisk();
    public abstract Builder buildVideoCard();
    public abstract ComputerProduct getResult();

}

BuiderUser 具体电脑建造者

java 复制代码
/**
 * 组装人员
 */
public class BuiderUser extends Builder{

    public Builder buildCpu() {
        computerProduct.setCpu("cpu");
        return this;
    }

    public Builder buildRam() {
        computerProduct.setRam("内存");
        return this;
    }

    public Builder buildHardDisk() {
        computerProduct.setHardDisk("硬盘");
        return this;
    }

    public Builder buildVideoCard() {
        computerProduct.setVideoCard("显卡");
        return this;
    }

    public ComputerProduct getResult() {
        return this.computerProduct;
    }
}

ClientTest 测试代码

java 复制代码
public class ClientTest {
    public static void main(String[] args) {
        //装机人员
        Director user = new Director(new BuiderUser());
        ComputerProduct computer = user.construct();
        System.out.println(computer.showConfig());
    }
}

输出结果:

java 复制代码
电脑 [cpu]+[内存]+[硬盘]+[显卡]

以上就是 建造者模式全部内容,感谢阅读。

相关推荐
Kay_Liang7 分钟前
大语言模型如何精准调用函数—— Function Calling 系统笔记
java·大数据·spring boot·笔记·ai·langchain·tools
自由的疯24 分钟前
Java 如何学习Docker
java·后端·架构
自由的疯25 分钟前
Java Docker本地部署
java·后端·架构
007php00727 分钟前
猿辅导Java面试真实经历与深度总结(二)
java·开发语言·python·计算机网络·面试·职场和发展·golang
摇滚侠30 分钟前
Spring Boot 3零基础教程,WEB 开发 内容协商机制 笔记34
java·spring boot·笔记·缓存
一勺菠萝丶30 分钟前
在 macOS 上用 Docker 为 Java 后端 & 常见开发需求搭建完整服务(详尽教程)
java·macos·docker
顾漂亮36 分钟前
JVM底层攻坚
java·jvm·spring
编程岁月37 分钟前
java面试-0215-HashMap有序吗?Comparable和Comparator区别?集合如何排序?
java·数据结构·面试
木井巳1 小时前
[Java数据结构与算法]详解排序算法
java·数据结构·算法·排序算法
没有bug.的程序员2 小时前
分布式架构未来趋势:从云原生到智能边缘的演进之路
java·分布式·微服务·云原生·架构·分布式系统