Java设计模式之创建型-建造者模式 (Builder)

已于 2024-02-05 11:19:58 修改
阅读量449 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式
于 2020-02-12 15:03:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dh_chao/article/details/104279007
版权

👉文章示例代码👈

附链

你也可以在这些平台阅读本文：

定义

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

用户只需指定需要建造的类型就可以得到它们，建造过程及细节不需要知道。

建造者模式注重于方法的调用顺序，而工厂模式注重于创建产品。

四要素

标准建造者模式有四个要素：

  • 产品类：既可以是具体的实体类，也可以是抽象类与其具体实现组成。
  • 抽象建造者：接口或者抽象类，将具体的实现过程移交给子类。
  • 具体建造者：抽象建造者的具体实现类，用于构建产品。
  • 指挥者类：调用合适的建造者方法来构建产品。

场景示例

笔者这里以攒电脑为例。攒机需要购买一些配置，例如：CPU、主板、内存条、硬盘、显卡、机箱、电源、显示器等。然后按照自己的需求和喜好将这些配置攒起来组装成电脑，满足自己的个性化需求。当然也会有一些攒机的商家，来帮用户处理攒机的过程。

创建产品类

/**
 * @author zhh
 * @description 电脑类
 * @date 2020-02-11 14:01
 */
public class Computer {

    /**
     * cpu
     */
    private String cpu;

    /**
     * 主板
     */
    private String mainboard;

    /**
     * 内存
     */
    private String memory;

    /**
     * 硬盘
     */
    private String hardDisk;

    /**
     * 显卡
     */
    private String gpu;

    /**
     * 机箱
     */
    private String crate;

    /**
     * 电源
     */
    private String powerSupply;

    /**
     * 显示器
     */
    private String monitor;

    // 此处省略getter、setter方法

    @Override
    public String toString() {
        return "Computer{" + "cpu='" + cpu + '\'' + ", mainboard='" + mainboard + '\'' + ", memory='" + memory + '\'' +
                ", hardDisk='" + hardDisk + '\'' + ", gpu='" + gpu + '\'' + ", crate='" + crate + '\'' +
                ", powerSupply='" + powerSupply + '\'' + ", monitor='" + monitor + '\'' + '}';
    }
}

创建抽象建造者

抽象电脑建造者类中，额外提供一个组装电脑的方法，其返回参数为产品类。

/**
 * @author zhh
 * @description 抽象电脑建造者类
 * @date 2020-02-11 14:32
 */
public abstract class ComputerBuilder {

    public abstract void buyCpu(String cpu);
    public abstract void buyMainboard(String mainboard);
    public abstract void buyMemory(String memory);
    public abstract void buyHardDisk(String hardDisk);
    public abstract void buyGpu(String gpu);
    public abstract void buyCrate(String crate);
    public abstract void buyPowerSupply(String powerSupply);
    public abstract void buyMonitor(String monitor);

    /**
     * 组装电脑
     */
    public abstract Computer assembleComputer();
}

创建具体建造者

创建具体的建造者类，继承我们的抽象创建者，实现抽象方法。

/**
 * @author zhh
 * @description 实际的电脑建造者类
 * @date 2020-02-11 14:41
 */
public class ComputerActualBuilder extends ComputerBuilder {

    private Computer computer = new Computer();

    @Override
    public void buyCpu(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void buyMainboard(String mainboard) {
        computer.setMainboard(mainboard);
    }

    @Override
    public void buyMemory(String memory) {
        computer.setMemory(memory);
    }

    @Override
    public void buyHardDisk(String hardDisk) {
        computer.setHardDisk(hardDisk);
    }

    @Override
    public void buyGpu(String gpu) {
        computer.setGpu(gpu);
    }

    @Override
    public void buyCrate(String crate) {
        computer.setCrate(crate);
    }

    @Override
    public void buyPowerSupply(String powerSupply) {
        computer.setPowerSupply(powerSupply);
    }

    @Override
    public void buyMonitor(String monitor) {
        computer.setMonitor(monitor);
    }

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

创建指挥者类

攒机商家是我们的指挥者，商家推荐配置供用户购买参考，帮助用户进行组装。

/**
 * @author zhh
 * @description 商家类
 * @date 2020-02-11 14:55
 */
public class Enterprise {

    private ComputerBuilder computerBuilder;

    public void setComputerBuilder(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    /**
     * 组装电脑
     */
    public Computer assembleComputer(String cpu, String mainboard,
                                     String memory, String hardDisk,
                                     String gpu, String crate,
                                     String powerSupply, String monitor) {
        computerBuilder.buyCpu(cpu);
        computerBuilder.buyMainboard(mainboard);
        computerBuilder.buyMemory(memory);
        computerBuilder.buyHardDisk(hardDisk);
        computerBuilder.buyGpu(gpu);
        computerBuilder.buyCrate(crate);
        computerBuilder.buyPowerSupply(powerSupply);
        computerBuilder.buyMonitor(monitor);

        return computerBuilder.assembleComputer();
    }
}

测试类及输出

/**
 * @author zhh
 * @description 测试类
 * @date 2020-02-11 15:05
 */
public class Test {
    public static void main(String[] args) {
        ComputerBuilder computerBuilder = new ComputerActualBuilder();
        Enterprise enterprise = new Enterprise();
        enterprise.setComputerBuilder(computerBuilder);
        Computer computer = enterprise.assembleComputer("Intel 酷睿i7 8700K",
                "影驰B360M-M.2",
                "影驰GAMER 8GB DDR4 2400",
                "希捷Barracuda 1TB 7200转 64MB",
                "七彩虹iGame750Ti 烈焰战神U-Twin-2GD5",
                "金河田峥嵘Z30",
                "航嘉WD600K",
                "三星C27F390FHC");

        System.out.println(computer);
    }
}

测试类的输出结果如下：

Computer{cpu=‘Intel 酷睿i7 8700K’, mainboard=‘影驰B360M-M.2’, memory=‘影驰GAMER 8GB DDR4 2400’, hardDisk=‘希捷Barracuda 1TB 7200转 64MB’, gpu=‘七彩虹iGame750Ti 烈焰战神U-Twin-2GD5’, crate=‘金河田峥嵘Z30’, powerSupply=‘航嘉WD600K’, monitor=‘三星C27F390FHC’}

类结构图

以上示例类的结构图如下所示

我们可以看到我们的 Test 类和抽象建造者 ComputerBuilder 和产品类 Computer 都没有关系，只和指挥者类 Enterprise 、具体的建造者 ComputerActualBuilder 有关。

Test 类创建指挥者类 Enterprise，指挥者类 Enterprise 通过组合的方式使用 ComputerBuilder ，实际使用 ComputerActualBuilder 创建产品类 Computer 。

示例演进

上述示例建造者的使用方式只是一种标准的使用方式。

我们发现我们的指挥者类并不是必须的。我们可以不需要攒机商家帮忙组装，我们可以自己动手。

下面来进行代码的演进。

调整产品类

这里使用静态内部类，依靠链式调用的方式来调整产品类。

/**
 * @author zhh
 * @description 电脑类
 * @date 2020-02-11 14:01
 */
public class Computer {

    /**
     * cpu
     */
    private String cpu;

    /**
     * 主板
     */
    private String mainboard;

    /**
     * 内存
     */
    private String memory;

    /**
     * 硬盘
     */
    private String hardDisk;

    /**
     * 显卡
     */
    private String gpu;

    /**
     * 机箱
     */
    private String crate;

    /**
     * 电源
     */
    private String powerSupply;

    /**
     * 显示器
     */
    private String monitor;

    public Computer(ComputerBuilder computerBuilder) {
        this.cpu = computerBuilder.cpu;
        this.mainboard = computerBuilder.mainboard;
        this.memory = computerBuilder.memory;
        this.hardDisk = computerBuilder.hardDisk;
        this.gpu = computerBuilder.gpu;
        this.crate = computerBuilder.crate;
        this.powerSupply = computerBuilder.powerSupply;
        this.monitor = computerBuilder.monitor;
    }

    @Override
    public String toString() {
        return "Computer{" + "cpu='" + cpu + '\'' + ", mainboard='" + mainboard + '\'' + ", memory='" + memory + '\'' +
                ", hardDisk='" + hardDisk + '\'' + ", gpu='" + gpu + '\'' + ", crate='" + crate + '\'' +
                ", powerSupply='" + powerSupply + '\'' + ", monitor='" + monitor + '\'' + '}';
    }

    /**
     * 声明静态内部类
     */
    public static class ComputerBuilder {
        /**
         * cpu
         */
        private String cpu;

        /**
         * 主板
         */
        private String mainboard;

        /**
         * 内存
         */
        private String memory;

        /**
         * 硬盘
         */
        private String hardDisk;

        /**
         * 显卡
         */
        private String gpu;

        /**
         * 机箱
         */
        private String crate;

        /**
         * 电源
         */
        private String powerSupply;

        /**
         * 显示器
         */
        private String monitor;

        public ComputerBuilder buyCpu(String cpu){
            this.cpu = cpu;
            return this;
        }

        public ComputerBuilder buyMainboard(String mainboard){
            this.mainboard = mainboard;
            return this;
        }

        public ComputerBuilder buyMemory(String memory){
            this.memory = memory;
            return this;
        }

        public ComputerBuilder buyHardDisk(String hardDisk){
            this.hardDisk = hardDisk;
            return this;
        }

        public ComputerBuilder buyGpu(String gpu){
            this.gpu = gpu;
            return this;
        }

        public ComputerBuilder buyCrate(String crate){
            this.crate = crate;
            return this;
        }

        public ComputerBuilder buyPowerSupply(String powerSupply){
            this.powerSupply = powerSupply;
            return this;
        }

        public ComputerBuilder buyMonitor(String monitor){
            this.monitor = monitor;
            return this;
        }

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

测试类及输出

/**
 * @author zhh
 * @description 测试类
 * @date 2020-02-11 15:05
 */
public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer.ComputerBuilder()
                .buyCpu("Intel 酷睿i7 8700K")
                .buyMainboard("影驰B360M-M.2")
                .buyMemory("影驰GAMER 8GB DDR4 2400")
                .buyHardDisk("希捷Barracuda 1TB 7200转 64MB")
                .buyGpu("七彩虹iGame750Ti 烈焰战神U-Twin-2GD5")
                .buyCrate("金河田峥嵘Z30")
                .buyPowerSupply("航嘉WD600K")
                .buyMonitor("三星C27F390FHC")
                .build();

        System.out.println(computer);
    }
}

测试类的输出结果如下：

Computer{cpu=‘Intel 酷睿i7 8700K’, mainboard=‘影驰B360M-M.2’, memory=‘影驰GAMER 8GB DDR4 2400’, hardDisk=‘希捷Barracuda 1TB 7200转 64MB’, gpu=‘七彩虹iGame750Ti 烈焰战神U-Twin-2GD5’, crate=‘金河田峥嵘Z30’, powerSupply=‘航嘉WD600K’, monitor=‘三星C27F390FHC’}

类结构图

以上演进的结构图如下所示

源码中的用例

  • java.lang.StringBuilder 和 java.lang.StringBuffer
  • Spring 中的 BeanDefinitionBuilder
  • MyBatis 中的 SqlSessionFactoryBuilder

总结

适用场景

  • 一个对象有非常复杂的内部结构(很多属性)
  • 想把复杂对象的创建和使用分离

优点

  • 封装性比较好，创建和使用分离
  • 扩展性好，建造类之间独立，在一定程度上解耦

缺点

  • 会产生多余的Builder对象
  • 产品内部结构发生变化，建造者都需要修改，成本比较大

参考

黑豪Horace
关注
专栏目录
Java创建型设计模式-建造者模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 1992
以上就是关于建造者模式的详细介绍，你学会了吗？从建造者模式的产生背景，原理，以及代码示例、优缺点分析等多维度进行了阐述。相信通过本文的学习，大家对建造者模式有了更加深入的认识！工厂模式抽象工厂模式。
Java创建型设计模式之建造者模式详解.rar
07-10
建造者模式是软件设计模式中的一种，属于创建型模式，它的主要目的是将对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。在Java中，建造者模式经常用于构造复杂对象，通过一步一步地创建对象，使得...
javabuilder
11-28
matlab 与 Java 联合调用 jar包支持
Builder模式 初体验
weixin_30457551的博客
05-04 120
看来Java构造器模式，决定动手体验下。构造器模式是什么？干什么用的？推荐大家看下ITEYE的一篇文章http://www.iteye.com/topic/71175 了解构造器模式对于系统的重构，也是很有帮助的。例如，可以优化多构造器类的设计。首先，我先寻找一个应用场景。拿民工和设计师来写固然可以，但觉得有点类似写Hello word的感觉。学习...
Java 设计模式 构建者模式
最新发布
今晚看星星的博客
10-09 467
作用：将一个复杂对象的构建与他的表示分离，可以一步一步构建对象，而不是使用构造函数构造一次性构造。通过一步步构造复杂对象，使得代码更加清晰，避免构造器中参数过多导致代码的可读性和易用性变差。Builder模式 Java Builder 模式。builder模式又叫。
JAVA构建器Builder模式
云守护的专栏
07-01 5096
/** * 构建器Builder模式 * Android中的AlertDialog的构建器模式 */ public class Lunch { private String cake; private String meat; private String milk; private String drink;
Java设计模式--Java Builder模式
weixin_34356555的博客
11-02 91
1、Java Builder模式主要是用一个内部类去实例化一个对象，避免一个类出现过多构造函数，而且构造函数如果出现默认参数的话，很容易出错。 public Person(String name) Person(String name, int age) Person(String name, int age, boolean sex) 2、Android O...
java设计模式--创建模式--建造者模式
a304096740的博客
08-01 87
对于建造者模式，小编个人理解为就是一个组装型的模式。 建造者模式 概述 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 适用性 1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。 2.当构造过程必须允许被构造的对象有不同的表示时。 参与者 ...
Java设计模式之建造者模式（Builder模式）介绍
09-03
Java设计模式中的建造者模式（Builder模式）是一种创建型设计模式，它的主要目的是将对象的构建过程和表示分离开来，使构建过程更加灵活，同时允许相同构建过程创建不同的表示形式。这种模式常用于创建复杂对象，...
69-Java设计模式之建造者 Builder1
08-08
建造者模式（Builder Pattern）是Java设计模式中的一种，它属于创建型模式，主要用于构建复杂的对象。这种模式将对象的创建过程与表示分离，使得同样的创建过程可以创建不同的表示。在实际开发中，当我们需要创建的...
Java设计模式之Builder建造者模式
08-27
Java设计模式之Builder建造者模式是一种创建型设计模式，主要用于创建复杂对象。该模式的主要思想是将对象的创建过程拆分成多个步骤，让客户端可以通过一步步的方式来创建对象。 Builder模式的结构主要包括四个部分...
JavaBuilder:Java项目管理和构建工具，使用Java语言（适用于Java 6+）
05-11
项目开发和源代码已移至 JavaBuilder的 JavaBuilder项目是使用Java语言的Java项目管理和构建工具。 该工具与其他工具（例如Ant，Maven，Ivy，Gradle等）之间的主要区别在于，该构建工具使您可以直接在Java中工作。 由于您正在构建Java项目，因此可以安全地假定您已经知道Java。 另外，由于它正在运行编译的代码（而不是解释或解析冗长的配置文件），因此它速度很快。 为什么要使用XML，Groovy，Scala，JavaScript或其他某种语言来构建项目？ 这是供跨平台使用的，特别是-linux 32/64，mac 32/64和Windows 32/64。 Java 6+ 能够复制与远程构建完全相同的构建（提供相同的“ builddate”） 这也允许使用交叉编译项目，甚至可以使用项目中的特定类（例如，当一个项目被编译为java6时，但是具有一
javabuilder.jar
10-21
该文件用于java调用matlab文件，存放于：matlabInstallRoot \toolbox\javabuilder\jar\javabuilder.jar 下载同时也支持下我的博客吧，关注最新的代码吧http://blog.csdn.net/msl1121
Java Builder 模式
robinson_911的专栏
03-21 187
package com.JXWork.test; /** * @auther: TF12778 * @date: 2020/3/21 13:17 * @description: */ public final class Car { /** * 必需属性 */ final String carBody;//车身 final String t...
Java中的builder设计模式
SakuraMG的博客
12-28 1794
builder设计模式的简单介绍
Java构建器（Builder）
u012301050的博客
01-13 2323
Java构建器（Builder） 在设计模式中对Builder模式的定义是用于构建复杂对象的一种模式，所构建的对象往往需要多步初始化或赋值才能完成。那么，在实际的开发过程中，我们哪些地方适合用到Builder模式呢？其中使用Builder模式来替代多参数构造函数是一个比较好的实践法则。
Java build模式
cuiyaoqiang的博客
09-09 8923
当一个类的参数多的情况下，使用重叠构造器模式客户端代码会很难编写，并且可读性差；使用javabean模式，调用一个无参的构造器，然后调用setter方法来设置每个必要的参数。但是javabean自身有着严重的缺点，因为构造过程被分到几个调用中，在构造javabean可能处于不一致的状态，类无法仅仅通过检验构造器参数的有效性来保证一致性。另一点不足之处，javabean模式阻止了把类做成不可变的可能，
java Build模式
紫蝶侠的博客
04-11 402
java Build模式 建造者模式 简明版 java中的builder模式
Java设计模式：解析建造者模式与原型模式
本文主要探讨了Java设计模式中的两种重要模式——建造者模式（Builder Pattern）和原型模式（Prototype Pattern）。这两种模式在软件开发中，尤其是团队协作时，能够提高代码的可维护性和复用性。 建造者模式： ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值