设计模式建造者模式
# 建造者模式
1.简介
建造者模式是一种创建型设计模式，使你能够分步骤创建复杂对象。该模式允许你使用相关的创建代码生成不同类型和形式的对象。
2.uml图
3.示例
首先我们来看一看传统的建造者模式：
Product: 最终要生成的对象，例如 Computer实例。
Builder： 构建者的抽象基类（有时会使用接口代替）。其定义了构建Product的抽象步骤，其实体类需要实现这些步骤。其会包含一个用来返回最终产品的方法Product getProduct()。
ConcreteBuilder: Builder的实现类。
Director: 决定如何构建最终产品的算法. 其会包含一个负责组装的方法void Construct(Builder builder)， 在这个方法中通过调用builder的方法，就可以设置builder，等设置完成后，就可以通过builder的 getProduct() 方法获得最终的产品。
主要核心就是将一系列的生成步骤(Builder)和创建产品的一系列生成器步骤调用(Director)抽象出来，使其解耦开来。严格来说程序中并非一定需要Director对象，但是Director中非常适合放入各种例行构造流程， 以便在程序中反复使用。
Computer类：
package com.gs.designmodel.builder.tradition; /** * @author: Gaos * @Date: 2023-07-19 16:37 * * 目标电脑类 **/ public class Computer { private String cpu; // 必选 private String ram;// 必选 private int usbCount; private String keyBoard; private String display; public Computer(String cpu, String ram) { this.cpu = cpu; this.ram = ram; } public void setUsbCount(int usbCount) { this.usbCount = usbCount; } public void setKeyBoard(String keyBoard) { this.keyBoard = keyBoard; } public void setDisplay(String display) { this.display = display; } @Override public String toString() { return "Computer{" + "cpu='" + cpu + ''' + ", ram='" + ram + ''' + ", usbCount=" + usbCount + ", keyBoard='" + keyBoard + ''' + ", display='" + display + ''' + '}'; } }
抽象构建者类：
package com.gs.designmodel.builder.tradition; /** * @author: Gaos * @Date: 2023-07-19 16:46 * * 抽象构建者类 **/ public abstract class ComputerBuilder { public abstract void setUsbCount(); public abstract void setKeyBoard(); public abstract void setDisplay(); public abstract Computer getComputer(); }
实体构建者类--->苹果电脑构建者类
package com.gs.designmodel.builder.tradition; /** * @author: Gaos * @Date: 2023-07-19 16:47 * * 苹果电脑构建者类 **/ public class MacComputerBuilder extends ComputerBuilder{ private Computer computer; public MacComputerBuilder(String cpu, String ram) { computer = new Computer(cpu, ram); } @Override public void setUsbCount() { computer.setUsbCount(2); } @Override public void setKeyBoard() { computer.setKeyBoard("Mac键盘"); } @Override public void setDisplay() { computer.setDisplay("Mac显示器"); } @Override public Computer getComputer() { return computer; } }
实体构建者类-->联想电脑构建者类
package com.gs.designmodel.builder.tradition; /** * @author: Gaos * @Date: 2023-07-19 16:50 **/ public class LenovoComputerBuilder extends ComputerBuilder{ private Computer computer; public LenovoComputerBuilder(String cpu, String ram) { computer = new Computer(cpu, ram); } @Override public void setUsbCount() { computer.setUsbCount(4); } @Override public void setKeyBoard() { computer.setKeyBoard("Lenovo键盘"); } @Override public void setDisplay() { computer.setDisplay("Lenovo显示器"); } @Override public Computer getComputer() { return computer; } }
Director 指导者类
package com.gs.designmodel.builder.tradition; /** * @author: Gaos * @Date: 2023-07-19 16:56 * * 指导者类(Director) **/ public class ComputerDirector { public void makeComputer(ComputerBuilder builder) { builder.setUsbCount(); builder.setDisplay(); builder.setKeyBoard(); } }
测试:
package com.gs.designmodel.builder.tradition; /** * @author: Gaos * @Date: 2023-07-19 16:57 * * 首先生成一个director->生成一个目标builder->使用director组装builder->组装完毕后创建产品实例 **/ public class Test { public static void main(String[] args) { ComputerDirector director = new ComputerDirector(); MacComputerBuilder builder = new MacComputerBuilder("I5处理器", "三星122"); director.makeComputer(builder); Computer macComputer = builder.getComputer(); System.out.println("mac computer :" + macComputer.toString()); LenovoComputerBuilder lenovoBuilder = new LenovoComputerBuilder("I7处理器", "海尔155"); director.makeComputer(lenovoBuilder); Computer lenovoComputer = lenovoBuilder.getComputer(); System.out.println("lenovo computer: " + lenovoComputer.toString()); } }
结果：
mac computer :Computer{cpu='I5处理器', ram='三星122', usbCount=2, keyBoard='Mac键盘', display='Mac显示器'} lenovo computer: Computer{cpu='I7处理器', ram='海尔155', usbCount=4, keyBoard='Lenovo键盘', display='Lenovo显示器'}
再下来我们再来看一下目前比较流行的建造者模式:
首先我们上述电脑类中有两个必选参数，cpu ram。其他三个为非必选参数，那么我们通常需要如何去构造电脑类的实例呢。
- 首先第一种方式就是构造方法，通过构造函数去实现对象的创建。但是当参数类型数量过多的时候，不同的实例所需要的构造函数也不同，就会导致构造函数特别多。同时如果需要构造函数的参数类型都是一致的，比如说都为
int或String就会导致参数顺序十分容易写错，接手的人维护也不易。 - 第二种方式就是 使用
set方法构造实例，其实也就是使用构造函数(空的或者带必选参数的)方法去生成实例并含有必要的属性，再使用set方法去对其他属性赋值。这种对象的创建方式可以有效的防止赋值属性错乱的问题，因为看上去一目了然，基本上不会出错，代码可读性也很强。但是一方面如果字段多了，对应的代码行数也会比较多。另一种是如果我希望这个对象构建完后，就不可以再被修改了，这一点也是set方法做不到的，因为他就是提供给调用者使用的，在这种情况下可能会存在一些安全隐患。
在这中情况下一种新型的建造者模式就出现了，类似像lombok中给对象加了@Builder注解之后的创建方式。因为lombok中的@Builder就是建造者模式。我们使用这种方式来对上面的代码进行实现。
大概的思路：
1、在Computer 中创建一个静态内部类 Builder，然后将Computer 中的参数都复制到Builder类中。
2、在Computer中创建一个private的构造函数，参数为Builder类型
3、在Builder中创建一个public的构造函数，参数为Computer中必填的那些参数，cpu 和ram。
4、在Builder中创建设置函数，对Computer中那些可选参数进行赋值，返回值为Builder类型的实例
5、在Builder中创建一个build()方法，在其中构建Computer的实例并返回
按照上述的思路改造原本的 Computer类：
package com.gs.designmodel.builder.popularity; /** * @author: Gaos * @Date: 2023-07-20 10:49 * * 链式调用的Computer类 **/ public class Computer { private final String cpu; // 必选 private final String ram; // 必选 private final int usbCount; private final String keyBoard; private final String display; private Computer (Builder builder) { this.cpu=builder.cpu; this.ram=builder.ram; this.usbCount=builder.usbCount; this.keyBoard=builder.keyboard; this.display=builder.display; } public static class Builder { private String cpu;//必须 private String ram;//必须 private int usbCount;//可选 private String keyboard;//可选 private String display;//可选 public Builder (String cpu, String ram) { this.cpu = cpu; this.ram = ram; } public Builder setUsbCount(int usbCount) { this.usbCount = usbCount; return this; } public Builder setKeyboard(String keyboard) { this.keyboard = keyboard; return this; } public Builder setDisplay(String display) { this.display = display; return this; } public Computer build(){ return new Computer(this); } } }
同时返回自身来实现链式调用，下面来进行一下测试类：
package com.gs.designmodel.builder.popularity; /** * @author: Gaos * @Date: 2023-07-20 11:35 **/ public class Test { public static void main(String[] args) { Computer computer=new Computer.Builder("因特尔","三星") .setDisplay("三星24寸") .setKeyboard("罗技") .setUsbCount(2) .build(); } }
结果：
Computer{cpu='因特尔', ram='三星', usbCount=2, keyBoard='罗技', display='三星24寸'}
可能有人会有疑惑，为什么不能写成这种模式:
Computer = new Computer("因特尔","三星") .setDisplay("三星24寸") .setKeyboard("罗技") .setUsbCount(2);
这里我个人的理解是建造者模式是不能依赖于set方法的，它需要对构建过程闭合不能向外暴露方法。假如lombok中的@Builder中使用的是这种，那不就以为着使用这个注解的对象默认对外暴露所有的修改方法吗，这与建造者模式本身的理念是相反的，缺少了builder这一层。
这种模式其实就是取消掉了director这一层。将构建算法交给了client端，其次将builder 写到了要构建的产品类里面，最后采用了链式调用。
4.总结
使用建造者模式可以避免重叠构造函数的出现，你可以使用建造者模式创建不同形式的产品，也可以用来构造复杂对象。
建造者模式重点关注如何分步生成复杂对象。 抽象工厂专门用于生产一系列相关对象。 抽象工厂会马上返回产品， 生成器则允许你在获取产品前执行一些额外构造步骤。
相关参考文章：
blog.csdn.net/ShuSheng000…
refactoringguru.cn/design-patt…
juejin.cn/post/684490…
