设计模式之建造者模式

技术分享 2年前 (2022-08-02) 0 999+

关注

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

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

一、引出问题

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

因为如果两台电脑都要，那么采购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:n" +                 "t CPU: " + CPU + "n" +                 "t GPU: " + GPU + "n" +                 "t memory: " + memory + "n" +                 "t motherboard: " + motherboard + "n" +                 "t hardDisk: " + hardDisk + "n";     }     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 就是建设者。