设计模式_建造者模式

设计模式_建造者模式

问题

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

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

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，即一个具体的产品对象。
2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口/抽象类，通常还包含一个返回复杂产品的方法 getResult()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（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）模式在应用过程中可以根据需要改变，如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。