赞
踩
将一个复杂对象的构建与表示分离,使得同样的构建过程可以创建不同的表示。
建造者(Builder)模式包含如下角色:
类图如下:
创建共享单车
生产自行车是一个复杂的过程,它包含了车架,车座等组件的生产。而车架又有碳纤维,铝合金等材质的,车座有橡胶,真皮等材质。对于自行车的生产就可以使用建造者模式。
这里Bike是产品,包含车架,车座等组件;Builder是抽象建造者,MobikeBuilder和OfoBuilder是具体的建造者;Director是指挥者。类图如下:
具体的代码如下:
产品类Bike
:
要创建的复杂对象。
/** * @author zzay * @className Bike * @description 创建型模式-建造者模式:产品类 * @create 2022/02/26 23:33 */ public class Bike { private String frame; private String seat; public String getFrame() { return frame; } public void setFrame(String frame) { this.frame = frame; } public String getSeat() { return seat; } public void setSeat(String seat) { this.seat = seat; } }
抽象建造者类Builder
:
这个接口规定要实现的复杂对象的部件的创建,并不涉及具体的部件对象的创建。
/** * @author zzay * @className Builder * @description 创建型模式-建造者模式:抽象建造者类 * @create 2022/02/26 23:34 */ public abstract class Builder { protected Bike myBike = new Bike(); public abstract void buildFrame(); public abstract void buildSeat(); public abstract Bike createBike(); }
具体建造者类 MobikeBuilder
和OfoBuilder
:
实现Builder接口,完成复杂产品的各个部件的具体创建方法。在构造过程完成后,提供产品的实例。
/** * @author zzay * @className MobikeBuilder * @description 创建型模式-建造者模式:具体建造者类 * @create 2022/02/26 23:34 */ public class MobikeBuilder extends Builder { @Override public void buildFrame() { myBike.setFrame("铝合金"); System.out.println("制造了Mobike的铝合金车架"); } @Override public void buildSeat() { myBike.setSeat("真皮"); System.out.println("制造了Mobike的真皮车座"); } @Override public Bike createBike() { return myBike; } } /** * @author zzay * @className OfoBuilder * @description 创建型模式-建造者模式:具体建造者类 * @create 2022/02/26 23:34 */ public class OfoBuilder extends Builder { @Override public void buildFrame() { myBike.setFrame("碳纤维"); System.out.println("制造了OfoBike的碳纤维车架"); } @Override public void buildSeat() { myBike.setSeat("橡胶"); System.out.println("制造了OfoBike的橡胶车座"); } @Override public Bike createBike() { return myBike; } }
指挥者类Director
:
调用具体建造者来创建复杂对象的各个部分,指导者不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建。
/** * @author zzay * @className Director * @description 创建型模式-建造者模式:指挥者类 * @create 2022/02/26 23:34 */ public class Director { private Builder myBuilder; public Director(Builder builder) { myBuilder = builder; } // 调用具体建造者来创建复杂对象的各个部分。 // 指导者不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建。 public Bike construct() { myBuilder.buildFrame(); myBuilder.buildSeat(); return myBuilder.createBike(); } }
测试类Client
:
/** * @author zzay * @className Client * @description 创建型模式-建造者模式:测试类 * @create 2022/02/26 23:34 */ public class Client { public static void main(String[] args) { showBike(new MobikeBuilder()); showBike(new OfoBuilder()); } /** * 展示建造的Bike的具体信息。 */ private static void showBike(Builder builder) { // 根据需求,传入想要建造的产品的对应Builder。 Director director = new Director(builder); // 之后,指挥者会指挥该Builder进行相应的产品建造。 Bike bike = director.construct(); System.out.println(bike.getFrame() + "-" + bike.getSeat()); } }
注意:
上面示例是 Builder模式的常规用法,指挥者类 Director 在建造者模式中具有很重要的作用,它用于指导具体构建者如何构建产品,控制调用先后次序,并向调用者返回完整的产品类。
但是有些情况下需要简化系统结构,可以把指挥者类和抽象建造者进行结合。代码如下:
// 指挥者类Director和抽象建造者类Builder结合而成的Builder类 public abstract class Builder { protected Bike mBike = new Bike(); public abstract void buildFrame(); public abstract void buildSeat(); public abstract Bike createBike(); public Bike construct() { this.buildFrame(); this.BuildSeat(); return this.createBike(); } }
说明:
这样做确实简化了系统结构,但同时也加重了抽象建造者类的职责,也不是太符合单一职责原则,如果construct()
过于复杂,建议还是封装到Director
中。
优点:
缺点:
建造者模式(Builder Pattern)创建的是复杂对象,其产品的各个部分经常面临着剧烈的变化,但将它们组合在一起的算法却相对稳定。因此,通常在以下场合使用:
建造者模式除了上面的用途外,在开发中还有一个常用的使用方式:就是当一个类构造器需要传入很多参数时,如果创建这个类的实例,代码可读性会非常差,而且很容易引入错误。此时,就可以利用建造者模式进行重构。
重构前–实体类PhoneBefore
代码:
在客户端代码中构建Phone对象,传递了四个参数。如果参数更多呢?代码的可读性及使用的成本比较高。
/** * @author zzay * @className PhoneBefore * @description 创建型模式-建造者模式:优化前的多参数构造器 * @create 2022/02/27 00:10 */ public class PhoneBefore { private String cpu; private String screen; private String memory; private String mainboard; public PhoneBefore(String cpu, String screen, String memory, String mainboard) { this.cpu = cpu; this.screen = screen; this.memory = memory; this.mainboard = mainboard; } public String getCpu() { return cpu; } public void setCpu(String cpu) { this.cpu = cpu; } public String getScreen() { return screen; } public void setScreen(String screen) { this.screen = screen; } public String getMemory() { return memory; } public void setMemory(String memory) { this.memory = memory; } public String getMainboard() { return mainboard; } public void setMainboard(String mainboard) { this.mainboard = mainboard; } @Override public String toString() { return "PhoneBefore{" + "cpu='" + cpu + '\'' + ", screen='" + screen + '\'' + ", memory='" + memory + '\'' + ", mainboard='" + mainboard + '\'' + '}'; } }
重构前–测试类ClientBefore
代码:
/**
* @author zzay
* @className ClientBefore
* @description 测试类-Before
* @create 2022/02/27 00:16
*/
public class ClientBefore {
public static void main(String[] args) {
PhoneBefore phoneBefore = new PhoneBefore("intel","Samsung","Kingston","华硕");
System.out.println(phoneBefore);
}
}
重构后–实体类PhoneAfter
代码如下:
重构后的代码在使用起来更方便,某种程度上也可以提高开发效率。从软件设计上,对程序员的要求比较高。
/** * @author zzay * @className PhoneAfter * @description 创建型模式-建造者模式:优化后的多参数构造器 * @create 2022/02/27 00:10 */ public class PhoneAfter { private String cpu; private String screen; private String memory; private String mainboard; public PhoneAfter(Builder builder) { cpu = builder.cpu; screen = builder.screen; memory = builder.memory; mainboard = builder.mainboard; } @Override public String toString() { return "Phone{" + "cpu='" + cpu + '\'' + ", screen='" + screen + '\'' + ", memory='" + memory + '\'' + ", mainboard='" + mainboard + '\'' + '}'; } /** * 建造者模式除了上面的用途外,在开发中还有一个常用的使用方式: * 就是当一个类构造器需要传入很多参数时,如果创建这个类的实例, * 代码可读性会非常差,而且很容易引入错误。此时,就可以利用建造者模式进行重构。 */ public static final class Builder { private String cpu; private String screen; private String memory; private String mainboard; public Builder() {} public Builder cpu(String val) { cpu = val; return this; } public Builder screen(String val) { screen = val; return this; } public Builder memory(String val) { memory = val; return this; } public Builder mainboard(String val) { mainboard = val; return this; } public PhoneAfter build() { return new PhoneAfter(this); } } }
重构后–测试类ClientAfter
代码:
/** * @author zzay * @className ClientAfter * @description 测试类:After * @create 2022/02/27 00:17 */ public class ClientAfter { public static void main(String[] args) { PhoneAfter phoneAfter = new PhoneAfter.Builder() .cpu("intel") .mainboard("华硕") .memory("Kingston") .screen("Samsung") .build(); System.out.println(phoneAfter); } }
举个例子说明两者的差异:如要制造一个超人,若使用工厂方法模式,直接产生出来的就是一个力大无穷、能够飞翔的超人;而如果使用建造者模式,则需要组装手、头、脚、躯干等部分,再组装成为超人。
举个例子,如果将抽象工厂模式看成汽车配件生产工厂,生产一个产品族的产品;那建造者模式就是一个汽车组装工厂,通过对部件的组装返回一辆完整的汽车。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。