设计模式学习-建造者模式

建造者模式：对象创建型模式，将一个复杂对象的构建与它的表示分离，使同样的构建过程可以有不同的表示。每个具体的建造者之间相互独立，添加和删除建造者不会对其他产生影响。

建造者模式的结构分为：抽象建造者、具体建造者、产品、指挥者。使用建造者模式，调用复杂对象的时候不用关心它的生成过程。具体代码内容如下：

package builder;

public class Product {

	private String partA;
	
	private String partB;
	
	private String partC;

	public String getPartA() {
		return partA;
	}

	public void setPartA(String partA) {
		this.partA = partA;
	}

	public String getPartB() {
		return partB;
	}

	public void setPartB(String partB) {
		this.partB = partB;
	}

	public String getPartC() {
		return partC;
	}

	public void setPartC(String partC) {
		this.partC = partC;
	}
	
	public void run() {
		System.out.println("产品运行");
	}
	
}

package builder;

public abstract class Builder {
	
	Product product = new Product();

	public abstract void buildA();
	
	public abstract void buildB();
	
	public abstract void buildC();
	
	public Product generate() {
		return product;
	}
}

package builder;

public class ConcreteBuilder extends Builder{

	@Override
	public void buildA() {
		product.setPartA("partA");
	}

	@Override
	public void buildB() {
		product.setPartB("partB");
	}

	@Override
	public void buildC() {
		product.setPartB("partC");
	}

}

package builder;

public class Director {

	private Builder builder;

	public Builder getBuilder() {
		return builder;
	}

	public void setBuilder(Builder builder) {
		this.builder = builder;
	}
	
	public Director(Builder builder) {
		this.builder = builder;
	}
	
	public Product assemble() {
		builder.buildA();
		builder.buildB();
		builder.buildC();
		return builder.generate();
	}
	
}

package builder;

public class TestMain {

	public static void main(String[] args) {
		Director director = new Director(new ConcreteBuilder());
		Product product1 = director.assemble();
		product1.run();
		System.out.println("--------------------------------------");
		Builder builder = new ConcreteBuilder();
		Product product2 = builder.generate();
		product2.run();
		
	}
}

在上面的例子中，Director扮演的一个调用者的过程，他控制着Builder具体对象的每一步的执行过程和执行顺序，在实际应用中，我们可以通过Builder中的组合方法进行控制，例子如下。这两种可以根据具体代码内容和习惯进行选择，但是如果严格遵守单一职责原则，最好还是将Director和Builder进行分离。

package builder;

public class ComplexBuilder extends Builder{

	@Override
	public void buildA() {
		product.setPartA("partA");
	}

	@Override
	public void buildB() {
		product.setPartB("partB");
	}

	@Override
	public void buildC() {
		product.setPartB("partC");
	}
	
	@Override
	public Product generate() {
		this.buildA();
		this.buildB();
		this.buildC();
		return product;
	}

}

建造模式优点：建造者模式中，调用方不用知道对象生成的具体细节，每个建造者也与其他建造者进行分离，互不干扰，完成了解耦，符合开闭原则；我们在创建复杂对象的时候，由于对产品的每个部分生成进行了拆分，因此能够更加精细的控制产品的创建过程，方便代码的分析、优化等。

缺点：如果产品内部变化很大，那么需要定义很多的建造者，代码量比较大。

应用：产品对象内部结构复杂，成员变量比较多；需要控制产品的每个部分的生成并且按顺序组装。