建造者模式

  建造者模式是一种对象创建型模式，它允许用户只通过复杂对象的类型和内容就可以构建它们，而不需要用户知道内部的具体细节。建造者模式是将一个复杂对象的构建与它的表示进行分离，使得一个相同的构建过程可以创建不同的表示。

1、模式结构

  Director：指挥者，用于构造使用Builder接口的对象。
  Builder：抽象建造者，定义产品对象的各个部件的抽象接口。
  ConcreteBuilder：具体建造者，实现Builder的接口用于构造和装配该产品的各个部件。
  Product：产品角色。

2、模式实例

  一个汽车大致是由轮胎、方向盘、发动机等配件组成，汽车厂的员工可以根据顾客的不同要求适用不同型号的配件进行组装汽车构造成一个完整的汽车，可以使用建造者模式实现。

2.1 应用场景类图

2.2 代码实现

（1）Car.java

public class Car {
	private String tyre;  //轮胎
	private String fangxiangpan;//方向盘
	private String engine;  //发动机
	public String getTyre() {
		return tyre;
	}
	public void setTyre(String tyre) {
		this.tyre = tyre;
	}
	public String getFangxiangpan() {
		return fangxiangpan;
	}
	public void setFangxiangpan(String fangxiangpan) {
		this.fangxiangpan = fangxiangpan;
	}
	public String getEngine() {
		return engine;
	}
	public void setEngine(String engine) {
		this.engine = engine;
	}
}

（2）CarBuilder.java

public abstract class CarBuilder {
	protected Car car = new Car();
	public abstract void buildTyre();
	public abstract void buildFangxiangpan();
	public abstract void buildEngine();
	
	public Car getCar(){
		return car;
	}
}

（3）SubCarBuilderA.java

public class SubCarBuilderA extends CarBuilder{
	@Override
	public void buildTyre() {
		car.setTyre("轮胎A");
	}
	@Override
	public void buildFangxiangpan() {
		car.setFangxiangpan("方向盘A");
	}
	@Override
	public void buildEngine() {
		car.setEngine("发动机A");
	}
}

（4）SubCarBuilderB.java

public class SubCarBuilderB extends CarBuilder{
	@Override
	public void buildTyre() {
		car.setTyre("轮胎B");
	}
	@Override
	public void buildFangxiangpan() {
		car.setFangxiangpan("方向盘B");
	}
	@Override
	public void buildEngine() {
		car.setEngine("发动机B");
	}
}

（5）Employee.java

public class Employee {
	private CarBuilder cBuilder;
	public void setCarBuilder(CarBuilder cBuilder){
		this.cBuilder = cBuilder;
	}
	public Car construct() {
		cBuilder.buildEngine();
		cBuilder.buildFangxiangpan();
		cBuilder.buildTyre();
		return cBuilder.getCar();
	}
}

（6）Client.java

public class Client {
	public static void main(String[] args) {
		//获取用户确定的汽车组成套餐
		CarBuilder carBuilder = (CarBuilder)XMLUtil.getBean();
		//由员工准备该套餐的车子
		Employee employee = new Employee();
		employee.setCarBuilder(carBuilder);
		Car car = employee.construct();
		System.out.println("您的车子由以下配置组成：");
		System.out.println("方向盘型号："+car.getFangxiangpan());
		System.out.println("发动机型号："+car.getEngine());
		System.out.println("轮胎型号："+car.getTyre());
	}
}

（7）XMLUtil.java

public class XMLUtil {
	public static Object getBean(){
		DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
		try {
			DocumentBuilder builder = dFactory.newDocumentBuilder();
			Document document = builder.parse(new File("./config/builder.xml"));
			
			NodeList nList = document.getElementsByTagName("className");
			Node classNode  = nList.item(0).getFirstChild();
			String carBrand =classNode.getNodeValue();
			
			//通过类名生成实例对象并将其返回
            Class c=Class.forName(carBrand);
	  	    Object obj=c.newInstance();
            return obj;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
}

（8）builder.xml

<config>
	<className>gc.builder.SubCarBuilderA</className>
</config>

3、模式分析

  建造者模式分离了产品本身和产品的创建过程，实现了解耦，使得相同的创建过程可以用于创建不同的产品对象，用户只需要指定对象的类型和内容就可以创键它们。

3.1 优点

（1）使得用户端无需确定产品内部组成的细节与装配方式，只需要知道自己所需建造者的类型即可。
（2）具体的建造者之间相互独立，互不影响，可以很方便地进行具体建造者之间的替换和新增具体建造者，符合设计模式的开闭原则。

3.2 缺点

（1）如果一个产品之间内部变化复杂，就需要定义许多具体建造者去实现，这样就会导致系统的理解程度和运行成本的增加。
（2）适用范围具有一定局限性，只适用于相似的产品之间，这些产品之间要具有较多的相同的组成部分。

3.3 适用场景

  需要生成的产品具有较多的相同点，它们的组成部分相似，具有较为复杂的内部结构，这些结构可以分离独立。

参考文献：设计模式（第2版）.清华出版社