设计模式之建造者模式

一、模式定义

建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以创建它们，用户不需要知道内部的具体构造细节。建造者模式属于对象创建型模式。

二、模式结构

建造者模式包含如下对象：（所有图片来源）

• Builder：抽象建造者
• ConcreteBuilder：具体建造者
• Director：指挥者
• Product：产品角色

三、时序图

四、简单实现

电脑的组装过程较为复杂，步骤繁多，但是顺序却是不固定的。

下面我们以组装电脑为例来演示下简单且景点的builder模式：（程序来源）

1、首先创建抽象类

在该类中，主要是完成具体的成员变量的setter()，同时也要完成getter()。

但是setter()方法是抽象方法。

public abstract class Computer {

	protected int mCpuCore = 1;
	protected int mRamSize = 0;
	protected String mOs = "Dos";

	protected Computer() {

	}

	// 设置CPU核心数
	public abstract void setCPU(int core);

	// 设置内存
	public abstract void setRAM(int gb);

	// 设置操作系统
	public abstract void setOs(String os);

	@Override
	public String toString() {
		return "Computer [mCpuCore=" + mCpuCore + ", mRamSize=" + mRamSize
				+ ", mOs=" + mOs + "]";
	}

}

2、创建具体类继承它

重写抽象类中的setter()方法，以便后续builder具体类中进行赋值操作。

public class AppleComputer extends Computer {

	protected AppleComputer() {

	}

	@Override
	public void setCPU(int core) {
		mCpuCore = core;
	}

	@Override
	public void setRAM(int gb) {
		mRamSize = gb;
	}

	@Override
	public void setOs(String os) {
		mOs = os;
	}

}

3、创建builder抽象类

抽象类中，具体是定义具体在产品中定义的setter()方法的赋值过程的抽象方法。

以及创建返回产品的抽象实例的抽象方法。

public abstract class Builder {
	// 设置CPU核心数
	public abstract void buildCPU(int core);

	// 设置内存
	public abstract void buildRAM(int gb);

	// 设置操作系统
	public abstract void buildOs(String os);

	// 创建Computer
	public abstract Computer create();

}

4、创建具体类继承Builder抽象类

重写Builder中的抽象方法，通过create()来创建具体产品的实例，而后在通过多个build()方法来实现对该产品的具体成员变量的赋值。

public class ApplePCBuilder extends Builder {
	private Computer mApplePc = new AppleComputer();

	@Override
	public void buildCPU(int core) {
		mApplePc.setCPU(core);
	}

	@Override
	public void buildRAM(int gb) {
		mApplePc.setRAM(gb);
	}

	@Override
	public void buildOs(String os) {
		mApplePc.setOs(os);
	}

	@Override
	public Computer create() {
		return mApplePc;
	}

}

5、创建Director类

最后在Director类的构造函数中获得Builder的实例对象，而后对construct()方法进行赋值操作。

public class Director {
	Builder mBuilder = null;

	/**
	 * 
	 * @param builder
	 */
	public Director(Builder builder) {
		mBuilder = builder;
	}

	/**
	 * 构建对象
	 * 
	 * @param cpu
	 * @param ram
	 * @param os
	 */
	public void construct(int cpu, int ram, String os) {
		mBuilder.buildCPU(cpu);
		mBuilder.buildRAM(ram);
		mBuilder.buildOs(os);
	}
}

6、进行测试

public class Test {
	public static void main(String[] args) {
		// 构建器
		Builder builder = new ApplePCBuilder();
		// Director
		Director pcDirector = new Director(builder);
		// 封装构建过程, 4核, 内存2GB, Mac系统
		pcDirector.construct(4, 2, "Mac OS X 10.9.1");
		// 构建电脑, 输出相关信息
		System.out.println("Computer Info : " + builder.create().toString());
	}
}

总结：

创建两个抽象类，产品抽象类与Builder抽象类，

创建三个实现类，具体产品类，具体Builder类，Director类。

产品类中完成setter与getter方法过程

Builder类中创建具体产品类的实例，并通过void buildPart(Object o)对产品类中的setter()进行赋值；并且通过create()返回具体的产品实例。

Director类有成员变量——Builder变量，通过构造函数获得Builder对象的引用，并通过void construct(Object paramter ....(多个参数))来实现对Builder对象中的buildPart()进行赋值，从而最终对具体产品类进行赋值。

五、优缺点

1、优点

• 良好的封装性，使得建筑者模式可以使用户不必知道产品内部组成的细节；
• 建造者独立，容易扩展；
• 在对象创建过程中会使用系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到。

2、缺点

• 会产生多余的Builder对象以及Director对象，消耗内存。
• 对象的构建过程暴露。