建造者模式

概述

当复杂的构建过程通常不变，改变的只是内部的实现算法和业务逻辑时使用；
将复杂的构建过程和具体的内部实现相分离，使得构建过程公用化。

UML

结构

产品：需要被建造的目标；
抽象建造者：规划好建造者类的任务，如需要实现A项任务，B项任务和C项任务，需要返回指定产品；
具体建造者：具体实现每项任务，如怎样实现A项任务，B项任务和C项任务；
指挥者：指挥完成任务的顺序和方式，如先完成A项任务再完成B项任务，再有选择地完成C项任务，需要指定具体的建造者和安排建造顺序。

代码

package com.builder;
// 以下有两个类
/**
 * 产品类
 */
public class Product {
	private String componentA;
	private String componentB;

	public String getComponentA() {
		return componentA;
	}

	public void setComponentA(String componentA) {
		this.componentA = componentA;
	}

	public String getComponentB() {
		return componentB;
	}

	public void setComponentB(String componentB) {
		this.componentB = componentB;
	}

	public void show() {
		System.out.println(toString());
	}

	@Override
	public String toString() {
		return "Product [componentA=" + componentA + ", componentB="
				+ componentB + "]";
	}
}

/**
 * 创建者抽象类
 */
public abstract class Builder {
	protected Product product = new Product();
	public abstract void buildOne();
	public abstract void buildTwo();
	public Product getResult() {
		return product;
	}
}

package com.builder;
// 以下有三个类
/**
 * 建造者A类
 */
public class ConcreteBuilderA extends Builder {

	@Override
	public void buildOne() {
		product.setComponentA("建造者A组件1");
	}

	@Override
	public void buildTwo() {
		product.setComponentB("建造者A组件2");
	}
}

/**
 * 建造者B类
 */
public class ConcreteBuilderB extends Builder {

	@Override
	public void buildOne() {
		product.setComponentA("建造者B组件1");
	}

	@Override
	public void buildTwo() {
		product.setComponentB("建造者B组件2");
	}
}

/**
 * 指挥者类
 */
public class Director {

	private Builder builder;

	public Director(Builder builder) {
		this.builder = builder;
	}

	public void construct() {
		builder.buildOne();
		builder.buildTwo();
	}

}

/**
 * 测试类
 */
public class TestMain {
	public static void main(String[] args) {
		Builder builderA = new ConcreteBuilderA();
		Director director = new Director(builderA);
		director.construct();
		Product productA = builderA.getResult();
		productA.show();
		
		Builder builderB = new ConcreteBuilderB();
		director = new Director(builderB);
		director.construct();
		Product productB = builderB.getResult();
		productB.show();
	}
}

  优缺点

优点：建造者独立，便于扩展，如果有新的内部逻辑只需继承/实现建造者即可，细节修改不容易影响其他逻辑；
缺点：结构相对固化，不同的构造过程难以使用同一个指挥者，如果内部细节变化过多需要更多的建造者类。

才疏学浅，如文中有错误，感谢大家指出。