设计模式

设计模式_建造者模式

问题

​ 一个复杂对象的创建，各部分可以灵活选择，步骤大同小异。以往的创建过程如下：

AbstractHouse.java

public abstract class AbstractHouse { public abstract void buildBasic();// 地基 public abstract void buildWalls();// 砌墙 public abstract void roofed();// 封顶 public void build() { buildBasic(); buildWalls(); roofed(); } }

CommonHouse.java

public class CommonHouse extends AbstractHouse { @Override public void buildBasic() { // TODO Auto-generated method stub System.out.println("给普通房屋打地基。"); } @Override public void buildWalls() { // TODO Auto-generated method stub System.out.println("给普通房屋砌墙。"); } @Override public void roofed() { // TODO Auto-generated method stub System.out.println("给普通房屋封顶。"); } }

client.java

public class Client { public static void main(String[] args) { CommonHouse commonHouse = new CommonHouse(); commonHouse.build(); } }

特点

比较好理解，简单易操作。没有设计缓存层对象，程序的扩展和维护性不好。把产品和创建产品的过程封装在了一起，耦合性增强了。

改进

​ 将产品和产品的建造过程进行解耦->原型模式。

基本介绍

原型模式：指将一个复杂对象的构造与它的表示分离，将复杂对象的创建过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

​ 建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

优点

各个具体的创建者相互独立，有利于系统的扩展。客户端不需要知道产品内部的组成细节，便于控制细节风险。

缺点

产品的组成部分必须相同，这点限制了其使用范围。如果产品的内部变化复杂，该模式将会增加很多的建造者类。

建造者模式的结构和实现

结构

图1

产品角色（Product）：它是包含多个组成部件的复杂对象，即一个具体的产品对象。抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口/抽象类，通常还包含一个返回复杂产品的方法 getResult()。具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。指挥者（Director）：构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。主要的作用有二，一：隔离了客户与对象的生产过程，二：复杂控制产品对象的上产过程。

实现

House.java

//产品->Product public class House { private String baise; private String wall; private String roofed; public String getBaise() { return baise; } public void setBaise(String baise) { this.baise = baise; } public String getWall() { return wall; } public void setWall(String wall) { this.wall = wall; } public String getRoofed() { return roofed; } public void setRoofed(String roofed) { this.roofed = roofed; } @Override public String toString() { return "House [baise=" + baise + ", wall=" + wall + ", roofed=" + roofed + "]"; } }

HouseBuilder.java

//抽象建造者->Builder public abstract class HouseBuilder { protected House house = new House(); public abstract void buildBasic();// 地基 public abstract void buildWalls();// 砌墙 public abstract void roofed();// 封顶 public House buildHouse() {// 产品生产好之后，将其返回 return house; } }

CommonHouse.java

//具体建造者->Concrete Builder public class CommonHouse extends HouseBuilder { @Override public void buildBasic() { System.out.println("普通房子打地基。"); house.setBaise("3m"); } @Override public void buildWalls() { System.out.println("普通房子砌墙。"); house.setWall("20cm"); } @Override public void roofed() { System.out.println("普通房子封顶。"); house.setRoofed("已封顶"); } }

HighBuilding.java

//具体建造者->Concrete Builder public class HighBuilding extends HouseBuilder { @Override public void buildBasic() { System.out.println("高楼打地基。"); house.setBaise("20m"); } @Override public void buildWalls() { System.out.println("高楼砌墙。"); house.setWall("40cm"); } @Override public void roofed() { System.out.println("高楼封顶。"); house.setRoofed("已封顶"); } }

HouseDirector.java

//指挥者->Director public class HouseDirector { HouseBuilder houseBuilder = null; public HouseDirector(HouseBuilder houseBuilder) {// 构造器传入houseBuilder super(); this.houseBuilder = houseBuilder; } public void setHouseBuilder(HouseBuilder houseBuilder) {// setter传入houseBuilder this.houseBuilder = houseBuilder; } // 构造房子的流程，交给指挥者处理 public House constructHouse() { houseBuilder.buildBasic(); houseBuilder.buildWalls(); houseBuilder.roofed(); return houseBuilder.buildHouse(); } }

Client.java

public class Client { public static void main(String[] args) { CommonHouse commonHouse = new CommonHouse();// 普通房子 // 准备创建房子的指挥者 HouseDirector houseDirector = new HouseDirector(commonHouse); // 盖房子完成，返回产品 House house1 = houseDirector.constructHouse(); System.out.println(house1.toString()); HighBuilding highBuilding = new HighBuilding(); houseDirector.setHouseBuilder(highBuilding); House house2 = houseDirector.constructHouse(); System.out.println(house2.toString()); } }

结果：

JDK中的建造者模式

StringBuilder str = new StringBuilder("hello"); str.append(" Builder."); System.out.println(str);

StringBuilder.java中的append方法(有很多个，这里是其中一个)。

public StringBuilder append(String str) { super.append(str); return this; }

StringBuilderd父类AbstractStringBuilder的append方法

public AbstractStringBuilder append(String str) { if (str == null) str = "null"; int len = str.length(); ensureCapacityInternal(count + len); str.getChars(0, len, value, count); count += len; return this; }

角色分析

Appendable接口定义了多个append方法(抽象方法),即Appendable为抽象建造者，定义了抽象方法。AbstractStringBuilder实现了Appendable接口方法，这里的AbstractStringBuilder已经作为建造者了，只是不能实例化。StringBuilderd即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现由AbstractStringBuilder完成，而StringBuilderd继承了AbstractStringBuilder。

​ 此处的角色划分并不像标志的建造者模式一样，但却体现了建造者模式的核心内容——订做这个产品的具体细节，不管调用了多少次append()，返回的还是这个StringBuilderd对象，也就是产品不变，但是里面的细节已经按照新的要求重新制作。将产品和产品的制造过程进行分离。

建造者模式的应用场景

建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

​ 建造者（Builder）模式在应用过程中可以根据需要改变，如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。