23种设计模式之建造者模式

上一节 23种设计模式之抽象工厂模式

建造模式的本质

1、分离了对象子组件的单独构造（由Builder来负责）和装配（由Director负责）。从而可以构造出复杂的对象。

这个模式适用于：某个对象的构建过程复杂的情况下使用。

2、由于实现了构建和装配的解耦。

不同的构建器，相同的装配，也可以做出不同的对象；

相同的构建器，不同的装配顺序也可以做出不同的对象。

也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

场景

1、我们要建造一个复杂的产品。比如：飞船、手机。这个复杂的产品的创建。

有这样一个问题需要处理：装配这些子组件是不是有个步骤问题？

2、实际开发中，我们所需要的对象构建时，也非常复杂，有很多步骤需要处理。

类图

封装类：

//封装各个组件
public class AirShip {
	private OrbitalModule orbitalModule;
	private Engine engine;
	private EscapeTower escapeTower;
	
	public OrbitalModule getOrbitalModule() {
		return orbitalModule;
	}
	public void setOrbitalModule(OrbitalModule orbitalModule) {
		this.orbitalModule = orbitalModule;
	}
	public Engine getEngine() {
		return engine;
	}
	public void setEngine(Engine engine) {
		this.engine = engine;
	}
	public EscapeTower getEscapeTower() {
		return escapeTower;
	}
	public void setEscapeTower(EscapeTower escapeTower) {
		this.escapeTower = escapeTower;
	}
	
	public void launch(){
		System.out.println("发射！");
	}
}

//子组件一封装
class OrbitalModule {
	private String name;
	public OrbitalModule(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

//子组件二封装
class Engine {
	private String name;
	public Engine(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

//子组件三封装
class EscapeTower {
	private String name;
	public EscapeTower(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

建造接口及实现类：

public interface AirShipBuilder {
	OrbitalModule builderOrbitalModule();
	Engine builderEngine();
	EscapeTower builderEscapeTower();
}

public class SxtAirShipBuilder implements AirShipBuilder{

	@Override
	public OrbitalModule builderOrbitalModule() {
		System.out.println("构建轨道舱！");
		return new OrbitalModule("轨道舱");
	}

	@Override
	public Engine builderEngine() {
		System.out.println("构建发动机！");
		return new Engine("发动机");
	}

	@Override
	public EscapeTower builderEscapeTower() {
		System.out.println("构建逃逸塔！");
		return new EscapeTower("逃逸塔");
	}

}

装配接口及实现类：

public interface AirShipDirector {
	//组装飞船对象
	AirShip directorAirShip();
}

public class SxtAirShipDirector implements AirShipDirector{
	private AirShipBuilder builder;
	public SxtAirShipDirector(AirShipBuilder builder) {
		this.builder=builder;
	}
	@Override
	public AirShip directorAirShip() {
		OrbitalModule o=builder.builderOrbitalModule();
		Engine e=builder.builderEngine();
		EscapeTower et=builder.builderEscapeTower();
		
		//组装
		AirShip as=new AirShip();
		as.setOrbitalModule(o);
		as.setEngine(e);
		as.setEscapeTower(et);
		return as;
	}

}

测试方法：

public class Test1 {
	public static void main(String[] args) {
		AirShipDirector sad=new SxtAirShipDirector(new SxtAirShipBuilder());
		AirShip ship=sad.directorAirShip();
		System.out.println(ship.getEngine().getName());
		ship.launch();
	}

}

测试结果：

构建轨道舱！
构建发动机！
构建逃逸塔！
发动机
发射！

---

开发中应用场景

1、StringBuilder类的append方法。

2、SQL中PreparedStatement

3、JDOM中，DomBuilder、SAXBuilder

建造者模式的使用场景

1、相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用创建者模式。

2、多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。

3、产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，使用该模式非常合适。

建造者模式的优点

1、封装性

2、建造者独立，容易扩展

3、便于控制细节风险

建造者模式和工厂模式

这两个模式非常相似，但是记住：

建造者模式最主要的功能是基本方法的调用顺序安排。也就是这些基本方法已经实现了，通俗的说就是零件的装配，顺序不同产生的对象也不同。

而工厂模式则重点是创建，创建零件是它的主要职责，安装顺序则不是它关心的。

 

下一节 23种设计模式之原型模式   待续......