首页
编程最新

分类

当前位置: 云海天教程网 > 技术新闻 > 编程最新 >正文

Java设计模式之建造者模式

更新时间:2022-09-24  作者:佚名   来源: 网络转载

Java设计模式之建造者模式【java入门】

本文由老王家组装电脑引出——建造者设计模式,详细介绍建造者模式的基本概念和实现代码,为了便于理解建造者模式,我们会对实际应用中的典型案例进行介绍。最后对比工厂模式和建造者模式之间的区别,让我们在实际使用时能更加灵活的选择设计模式。

读者可以拉取完整代码到本地进行学习,实现代码均测试通过后上传到码云。

一、引出问题

老王家需要组装一台笔记本电脑,但是就先买办公本还是游戏本的问题,老王和小王吵了起来。

因为如果两台电脑都要,那么采购CPU、内存.......一系列配件不仅需要专业的知识,而且办公本和游戏本的配置也是不一样的,对于老王和小王来说,这都是现实的复杂问题。就这样,他们从家一路吵到了电脑店......

售货员给他们出来一个主意,如果将配置电脑这个活交给一个专业的指挥者,然后让指挥者将采购配件交给具体的游戏本和办公本的的采购人员,这样你们只需要将需要的信息交给指挥者就行了,而无需关注采购和组装过程。

这是老板又出来补充了一句,为了让指挥者不依赖具体的采购人员,可以将采购人员进一步抽象出来。

二、模式概念与使用

实际上,上面涉及到的问题的解决办法正是设计模式中的——建造者模式,也是创建型设计模式中的最后一个。

建造者模式将对象的创建过程和表现分离,并且调用方通过指挥者调用方法对对象进行构建,使得调用方不再关心对象构建过程,构建对象的具体过程可以根据传入类型的不同而改变。

老王、小王就相当于客户端调用方,指挥采购电脑的就是调用方法,他们的最终目的就是构建复杂的对象(组装电脑),老王、小王只需要把相关信息交给指挥者,指挥者直接交给他成品,小王、老王无需关心具体的细节。

在这个设计模式中包括四个角色:

产品、建造者、具体建造者、指挥者

在实际使用中为了简化也并不是四个角色都需要,往往只保留具体的构建过程。

我们以老王组建电脑为例,看具体的实现代码:

产品类(电脑)

/**
 * 产品
 * @author tcy
 * @Date 30-07-2022
 */
public class Computer {
    private String CPU;
    private String GPU;
    private String memory;
    private String motherboard;
    private String hardDisk;


    public void setCPU(String CPU) {
        this.CPU = CPU;
    }

    public void setGPU(String GPU) {
        this.GPU = GPU;
    }

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

    public void setMotherboard(String motherboard) {
        this.motherboard = motherboard;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    @Override
    public String toString() {
        return "you have a computer:
" +
                "	 CPU: " + CPU + "
" +
                "	 GPU: " + GPU + "
" +
                "	 memory: " + memory + "
" +
                "	 motherboard: " + motherboard + "
" +
                "	 hardDisk: " + hardDisk + "
";
    }
    Computer() {

    }

    Computer(String CPU, String GPU, String memory, String motherboard, String hardDisk) {
        this.CPU = CPU;
        this.GPU = GPU;
        this.memory = memory;
        this.motherboard = motherboard;
        this.hardDisk = hardDisk;
    }
}

抽象建造者:

/**
 * 抽象建造者
 * @author tcy
 * @Date 30-07-2022
 */
public abstract class AbstractComputerBuilder {

    protected Computer computer = new Computer();

    public abstract void CPU();

    public abstract void GPU();

    public abstract void memory();

    public abstract void motherboard();

    public abstract void hardDisk();

    public abstract Computer getComputer();
}

具体建造者1(办公本组装者):

/**
 * 具体建造者2
 * @author tcy
 * @Date 30-07-2022
 */
public class OfficeComputerBuilder extends AbstractComputerBuilder{
    @Override
    public void CPU() {
        computer.setCPU("i7-7700k");
    }

    @Override
    public void GPU() {
        computer.setGPU("GTX 1050 Ti");
    }

    @Override
    public void memory() {
        computer.setMemory("32GB");
    }

    @Override
    public void motherboard() {
        computer.setMotherboard("ASUS  B560M-PLUS");
    }

    @Override
    public void hardDisk() {
        computer.setHardDisk("1TB SSD");
    }

    @Override
    public Computer getComputer() {
        System.out.println("得到了一个办公电脑...");
        return computer;
    }
}

具体建造者2(游戏本组装者):

/**
 * 具体建造者1
 * @author tcy
 * @Date 30-07-2022
 */
public class GameComputerBuilder extends AbstractComputerBuilder{
    @Override
    public void CPU() {
        computer.setCPU("i9-12900K");
    }

    @Override
    public void GPU() {
        computer.setGPU("RTX 3090 Ti");
    }

    @Override
    public void memory() {
        computer.setMemory("64GB");
    }

    @Override
    public void motherboard() {
        computer.setMotherboard("Z590 AORUS MASTER");
    }

    @Override
    public void hardDisk() {
        computer.setHardDisk("2TB SSD");
    }

    @Override
    public Computer getComputer() {
        System.out.println("得到了一个游戏电脑...");
        return computer;
    }
}

指挥者:

/**
 * 指挥者
 * @author tcy
 * @Date 30-07-2022
 */
public class Director {
    private AbstractComputerBuilder builder;

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

    public Computer construct() {
        builder.CPU();
        builder.GPU();

        Computer product = builder.getComputer();
        return product;
    }
}

调用方(老王和小王):

/**
 * @author tcy
 * @Date 30-07-2022
 */
public class Client {

    public static void main(String[] args) {

        new Director(new GameComputerBuilder()).construct();

        new Director(new OfficeComputerBuilder()).construct();
        }
}

这样对于老王(调用方)来说,他需要办公本就直接将他需要办公本告诉指挥者,指挥者去调用相应的采购员。老王无需知道具体的采购过程,小王也同样适用。

为了让读者理解的更加清晰,我们以Jdk、Mybatis、Spring中的典型适用再做介绍和讲解。

三、典型应用

1、Jdk应用及Lombok应用

①StringBuilder就是使用的建造者模式。

StringBuilder 类继承AbstractStringBuilder而我们每次在调用 append 方法的时候就是在往 AbstractStringBuilder 类中变量 value 中追加字符。

所以此时 AbstractStringBuilder 就对应抽象建造者,StringBuilder 就是具体的建造者,String 对象就是我们所需要的产品。

但是此时我们并没有发现 Director,其实此时的 StringBuilder 类同时也充当着 Director 的角色,其 toString() 方法就是返回最终 String 对象。

②在我们使用Lombok时在实体会加注解 @Builder。

在实体上加@Builder 实际上生成了一个内部类,反编译后我们看内部类的具体代码。

public static Computer.ComputerBuilder builder() {
    return new Computer.ComputerBuilder();
}

public static class ComputerBuilder {
    private String CPU;
    private String GPU;
    private String memory;
    private String motherboard;
    private String hardDisk;

    ComputerBuilder() {
    }
    //链式调用----------------start
    public Computer.ComputerBuilder CPU(String CPU) {
        this.CPU = CPU;
        return this;
    }

    public Computer.ComputerBuilder GPU(String GPU) {
        this.GPU = GPU;
        return this;
    }

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

    public Computer.ComputerBuilder motherboard(String motherboard) {
        this.motherboard = motherboard;
        return this;
    }

    public Computer.ComputerBuilder hardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
        return this;
    }
    //链式调用----------------end
    public Computer build() {
        return new Computer(this.CPU, this.GPU, this.memory, this.motherboard, this.hardDisk);
    }

    public String toString() {
        return "Computer.ComputerBuilder(CPU=" + this.CPU + ", GPU=" + this.GPU + ", memory=" + this.memory + ", motherboard=" + this.motherboard + ", hardDisk=" + this.hardDisk + ")";
    }
}

静态内部类实际上充当建造者、指挥者的角色,创建对象时直接调用 实体.builder() 会生成该对象 然后调用set链式调用赋值。

Computer.ComputerBuilder computerBuilder=Computer.builder();
computerBuilder.CPU("it-9000")
        .memory("500m");

这就大大简化了对象的创建过程,还可以通过链式调用赋值。

2、Mybatis中的应用

MyBatis中的SqlSessionFactoryBuilder使用的建造者模式。

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。

而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先定制的 Configuration 的实例构建出 SqlSessionFactory 的实例。

SqlSessionFactory 就是Mybatis需要的“产品”,SqlSessionFactoryBuilder就是一个建造者,从xml配置文件或者Configuration 中取出需要的信息构成不用的对象。

3、Spring中的应用

Spring中的BeanDefinitionBuilder

BeanDefinition 是一个复杂对象,通过 BeanDefinitionBuilder 来创建它。在启动过程中,会通过BeanDefinitionBuilder 来一步步构造复杂对象 BeanDefinition,然后通过 getBeanDefinition() 方法获取 BeanDefinition 对象。得到 BeanDefinition 后,将它注册到 IOC 容器中(存放在 beanDefinitionMap 中)

BeanDefinition 就是需要的“产品”,BeanDefinitionBuilder 就是建设者。

四、总结

我们可以看到,工厂模式和建造者模式用属于创建型设计模式,最终目的都是创建对象,那他们之间有什么区别呢?在实际运用时又如何选择呢?

其实对比看我们在上篇文章、工厂模式的例子,我们举的例子是老王购买产品A、B、C看名字就像是批量生产,而且我们并没有说构建过程,就像是工厂生产产品一样。而我们这篇文章举的例子却是电脑这么具体且复杂的产品,且更注重每一步的组装过程,看到这我们模模糊糊能感受到他们之间的区别。

①工厂模式创建对象无需分步骤,获取的产品对象完全一样;而建造者模式会因为建造的顺序不同,导致产出的产品不同(比如上面的StringBuilder);
②建造者模式更适合构建复杂的对象,可以分步骤逐步充实产品特性,而工厂模式要求在创建对象的时候就需要把所有属性设置好;

如果只看概念性东西还是有些苍白无力,我们举一个典型的Spring中的例子做对比。

Spring 中的 FactoryBean 接口用的就是工厂方法模式,FactoryBean 是一个工厂 bean,我们可以通过实现 FactoryBean 接口并重写它的 getObject() 方法来自定义工厂 bean,并自定义我们需要生成的 bean。

Spring 中自身就有很多 FactoryBean 的实现,他们隐藏了实例化一些复杂 bean 的细节,调用者无需关注那些复杂 bean 是如何创建的,只需要通过这个工厂 bean 来获取就行了!

而BeanDefinition是一个复杂且高度个性化的一个bean,里面有很多Bean的信息,例如类名、scope、属性、构造函数参数列表、依赖的bean、是否是单例类、是否是懒加载等,其实就是将Bean的定义信息存储到这个BeanDefinition相应的属性中,创建过程使用建造者模式更合适。

结合典型应用,认真体会建造者模式和工厂模式区别,参考软件设计七大原则 在实际应用中更加灵活的使用,不生搬硬套。

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对云海天教程的支持。如果你想了解更多相关内容请查看下面相关链接

上一篇:Java数组队列及环形数组队列超详细讲解【java面试】 下一篇:Django 使用VScode 创建工程
小编推荐
快速导航更多>>
JavaScript 教程 HTML5 教程 CSS3 教程 jQuery 教程 Vue.js 教程 Node.js 教程 SQL 教程 C 教程 PHP 教程 Linux 教程 Docker 教程 Nginx 教程 Python 教程 Java 教程

云海天教程网 版权所有

 陕公网安备 61050202000585号

陕ICP备14013131号-3