设计模式-建造者模式及应用
在系统开发中，往往会有创建一个复杂对象的需求。这个复杂对象由多个子部件组合而成。例如我们现在需要组装一台计算机，计算机由CPU、主板、硬盘、内存、显示器、鼠标、键盘......等组装而成，而选择需要根据我们真实的使用场景去组装不同配置的电脑。例如同一个公司的同事，不同岗位对计算机配置的需求也不同，研发同学的配置可能会高，而文职类工作的同学配置就无须那么高。
公司IT运维部门的同学就需要按照不同需要组装不同配置的电脑。各个组件灵活替换，按需装配。类似于这种场景产品的创建，下面介绍的建造者模式，就能很好的描述此类场景。
建造者模式
建造者（Builder）模式的定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。此外建造者模式是一种对象创建型模式。
结构与实现
建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成，现在我们来分析其基本结构和实现方法。
产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。
结构图如下：
实例代码： 使用本文开始时候介绍的组装电脑的案例，来完成建造者模式的案例；
产品角色
public class Computer { private String cpu; private String disk; private String ram; private String screen; private String mouse; private String keyboard; public String getCpu() { return cpu; } public void setCpu(String cpu) { this.cpu = cpu; } public String getDisk() { return disk; } public void setDisk(String disk) { this.disk = disk; } public String getRam() { return ram; } public void setRam(String ram) { this.ram = ram; } public String getScreen() { return screen; } public void setScreen(String screen) { this.screen = screen; } public String getMouse() { return mouse; } public void setMouse(String mouse) { this.mouse = mouse; } public String getKeyboard() { return keyboard; } public void setKeyboard(String keyboard) { this.keyboard = keyboard; } @Override public String toString() { return "Computer [cpu=" + cpu + ", disk=" + disk + ", ram=" + ram + ", screen=" + screen + ", mouse=" + mouse + ", keyboard=" + keyboard + "]"; } } 复制代码抽象建造者
public abstract class AbstractBuilder { /** * 具体产品 */ protected Computer computer = new Computer(); /** * 配置cpu */ protected abstract void setCpu(); /** * 配置disk */ protected abstract void setDisk(); /** * 配置 ram */ protected abstract void setRam(); /** * 配置screen */ protected abstract void setScreen(); /** * 配置keyboard */ protected abstract void setKeyboard(); /** * 配置mouse */ protected abstract void setMouse(); /** * 返回创建具体对象 * @return */ public Computer getResult() { return computer; } } 复制代码具体建造者1
public class ConcreteBuilderApple extends AbstractBuilder{ @Override protected void setCpu() { computer.setCpu("M1"); } @Override protected void setDisk() { computer.setDisk("Seagate 2TB"); } @Override protected void setRam() { computer.setRam("Kingston 16G"); } @Override protected void setScreen() { computer.setScreen("Sasung"); } @Override protected void setKeyboard() { computer.setKeyboard("apple keyboard"); } @Override protected void setMouse() { computer.setMouse("apple mouse"); } } 复制代码具体建造者2
public class ConcreteBuilderHuawei extends AbstractBuilder{ protected void setCpu() { computer.setCpu("Intel"); } protected void setDisk() { computer.setDisk("Sasung 1TB"); } protected void setRam() { computer.setRam("AMD 8G"); } protected void setScreen() { computer.setScreen("Sony"); } protected void setKeyboard() { computer.setKeyboard("Huawei"); } protected void setMouse() { computer.setKeyboard("Logitech"); } } 复制代码指挥者
public class ComputerDirector { AbstractBuilder builder = null; public ComputerDirector(AbstractBuilder builder){ this.builder = builder; } // 创建实例 public Computer builderComputer() { builder.setCpu(); builder.setDisk(); builder.setRam(); builder.setRam(); builder.setMouse(); builder.setKeyboard(); builder.setScreen(); return builder.getResult(); } } 复制代码使用方
public class Client { public static void main(String[] args) { ConcreteBuilderApple concreteBuilderApple = new ConcreteBuilderApple(); // 假设生产苹果电脑 ComputerDirector computerDirector = new ComputerDirector(concreteBuilderApple); Computer macBookPro =computerDirector.builderComputer(); System.out.println(macBookPro.toString()); } } 复制代码执行结果：
Computer [cpu=M1, disk=Seagate 2TB, ram=Kingston 16G, screen=Sasung, mouse=apple mouse, keyboard=apple keyboard] 复制代码
案例结构图：
使用场景
当需要创建的产品具备复杂创建过程时，可以抽取出共性创建过程，然后交由具体实现类自定义创建流程，使得同样的创建行为可以生产出不同的产品，分离了创建与表示，使创建产品的灵活性大大增加。
建造者模式主要适用于以下应用场景：
相同的方法，不同的执行顺序，产生不同的结果。
多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。
产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用。
初始化一个对象特别复杂，参数多，而且很多参数都具有默认值。
项目中经常使用的，静态类的方式实现建造者
还以我们上面的案例来演示，需要变动产品类;
public class Computer2 { private String cpu; private String disk; private String ram; private String screen; private String mouse; private String keyboard; public String getCpu() { return cpu; } public void setCpu(String cpu) { this.cpu = cpu; } public String getDisk() { return disk; } public void setDisk(String disk) { this.disk = disk; } public String getRam() { return ram; } public void setRam(String ram) { this.ram = ram; } public String getScreen() { return screen; } public void setScreen(String screen) { this.screen = screen; } public String getMouse() { return mouse; } public void setMouse(String mouse) { this.mouse = mouse; } public String getKeyboard() { return keyboard; } public void setKeyboard(String keyboard) { this.keyboard = keyboard; } @Override public String toString() { return "Computer [cpu=" + cpu + ", disk=" + disk + ", ram=" + ram + ", screen=" + screen + ", mouse=" + mouse + ", keyboard=" + keyboard + "]"; } public static class Builder{ Computer2 product = new Computer2(); public Builder setCpu(String cpu) { product.cpu = cpu; return this; } public Builder setRam(String ram) { product.ram = ram; return this; } public Builder setDisk(String disk) { product.disk = disk; return this; } public Builder setScreen(String screen) { product.screen = screen; return this; } public Builder setMouse(String mouse) { product.mouse = mouse; return this; } public Builder setKeyboard(String keyboard) { product.keyboard = keyboard; return this; } public Computer2 getResult() { return product; } } } 复制代码使用方：
public class Client2 { public static void main(String[] args) { Computer2 computer2 = new Builder().setCpu("Intel").setDisk("wd").setRam("AMD").setScreen("索尼").getResult(); System.out.println(computer2); } } 复制代码执行结果
Computer [cpu=Intel, disk=wd, ram=AMD, screen=索尼, mouse=null, keyboard=null] 复制代码
通过静态内部类（指挥者、建造者）构造具体产品的方式，简化建造者模式的使用。使得代码更简介，缺点是违反开闭原则，产品属性更改，内部类也要更改。
优缺点
优点：
封装性好，讲复杂对象的构建过程与表示分开
扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。
缺点：
产品的组成部分必须相同，这限制了其使用范围。
如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。
建造者模式在源码中的使用
1.建造者模式在MyBatis源码中的应用 MyBatis 中 SqlSessionFactoryBuiler 类用到了建造者模式，SqlSessionFactory由具体SqlSessionFactoryBuilder产生；下面分析一下源码部分
public SqlSessionFactory build(Configuration config) { return new DefaultSqlSessionFactory(config); } 复制代码这里DefaultSqlSessionFactory创建需要Configuration对象，这里SqlSessionFactoryBuilder 充当了我们的指挥者；
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { SqlSessionFactory var5; try { XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties); var5 = this.build(parser.parse()); } catch (Exception var14) { throw ExceptionFactory.wrapException("Error building SqlSession.", var14); } finally { ErrorContext.instance().reset(); try { inputStream.close(); } catch (IOException var13) { } } return var5; } 复制代码Configuration对象是一个复杂对象，具体的创建Configuration的建造者为XMLConfigBuilder，抽象建造者为BaseBuilder，具体建造者的构建过程,通过parseConfiguration（）方法，构造配置项，parse（）方法获取我们构造的 Configuration对象。
// 构造过程 private void parseConfiguration(XNode root) { try { Properties settings = this.settingsAsPropertiess(root.evalNode("settings")); this.propertiesElement(root.evalNode("properties")); this.loadCustomVfs(settings); this.typeAliasesElement(root.evalNode("typeAliases")); this.pluginElement(root.evalNode("plugins")); this.objectFactoryElement(root.evalNode("objectFactory")); this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); this.reflectionFactoryElement(root.evalNode("reflectionFactory")); this.settingsElement(settings); this.environmentsElement(root.evalNode("environments")); this.databaseIdProviderElement(root.evalNode("databaseIdProvider")); this.typeHandlerElement(root.evalNode("typeHandlers")); this.mapperElement(root.evalNode("mappers")); } catch (Exception var3) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3); } } // 获取结果 public Configuration parse() { if (this.parsed) { throw new BuilderException("Each XMLConfigBuilder can only be used once."); } else { this.parsed = true; this.parseConfiguration(this.parser.evalNode("/configuration")); return this.configuration; } }
作者：fw19940314
链接：https://juejin.cn/post/7025626338950119431