设计模式之建造者模式

1.建造者模式概述

• 建造者模式也属于创建型模式，它提供了一种创建对象的最佳方式
• 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
• 主要作用：在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象
• 用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂的对象（把内部的建造过程和细节隐藏起来）

• 工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）
• 汽车购买者（用户）：只需要说成你需要的型号（对象的类型和内容），然后直接购买就可以直接使用（不需要知道汽车怎么组装的） 

 

---

2.建造者模式常规用法

Builder.java

package builder;
/**
 * 抽象的建造者：方法
 * @author Admin
 *
 */
public abstract class Builder {

	abstract void buildA();	//地基
	abstract void buildB();	//钢筋工程
	abstract void buildC();	//铺电线
	abstract void buildD();	//粉刷
	
//	完工，得到产品
	abstract Product getProduct();
}

Product.java

package builder;
/**
 * 产品：房子
 * @author Admin
 *
 */
public class Product {

	private String buildA;
	private String buildB;
	private String buildC;
	private String buildD;
	public String getBuildA() {
		return buildA;
	}
	public void setBuildA(String buildA) {
		this.buildA = buildA;
	}
	public String getBuildB() {
		return buildB;
	}
	public void setBuildB(String buildB) {
		this.buildB = buildB;
	}
	public String getBuildC() {
		return buildC;
	}
	public void setBuildC(String buildC) {
		this.buildC = buildC;
	}
	public String getBuildD() {
		return buildD;
	}
	public void setBuildD(String buildD) {
		this.buildD = buildD;
	}
	@Override
	public String toString() {
		return "Product [buildA=" + buildA + ", buildB=" + buildB + ", buildC=" + buildC + ", buildD=" + buildD + "]";
	}
	
	
}

Worker.java

package builder;
/**
 * 具体建造者:工人
 * @author Admin
 *
 */
public class Worker extends Builder{
	
	private Product product;
	
	public Worker() {
		product=new Product();
	}

	@Override
	void buildA() {
		product.setBuildA("地基");
		System.out.println("地基");
	}

	@Override
	void buildB() {
		product.setBuildB("钢筋工程");
		System.out.println("钢筋工程");
	}

	@Override
	void buildC() {
		product.setBuildC("铺电线");
		System.out.println("铺电线");
	}

	@Override
	void buildD() {
		product.setBuildD("粉刷");
		System.out.println("粉刷");
	}

	@Override
	Product getProduct() {
		return product;
	}

}

Director.java

package builder;
/**
 * 指挥：核心，负责指挥构建一个工程，工程如何构建，由它决定
 * @author Admin
 *
 */
public class Director {

//	指挥工人按照顺序建房子
	public Product build(Builder builder) {
		builder.buildA();
		builder.buildB();
		builder.buildC();
		builder.buildD();
		
		return builder.getProduct();
	}
}

Test.java

package builder;

public class Test {

	public static void main(String[] args) {
//		指挥
		Director director=new Director();
//		指挥具体工人完成
		Product product=director.build(new Worker());
		System.out.println(product.toString());
	}
}

控制台 

地基
钢筋工程
铺电线
粉刷
Product [buildA=地基, buildB=钢筋工程, buildC=铺电线, buildD=粉刷]

---

3.建造者模式的第二种用法

• 上面是Builder模式的常用用法，导演类Director在Builder模式中具有重要作用，用于指导具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有些情况下需要简化系统结构，可以把Director和抽象类进行结合。
• 通过静态内部类方式实现零件无序装配构造，这种方式使用更加灵活，更符合定义。内部有复杂对象的默认实现，使用时可以根据用户需求自由定义更改内容，并且无需改变具体的构造方式。就可以生产出不同复杂产品。
• 如麦当劳的套餐，服务员（具体建造者）可以随意搭配几种产品（零件）组成一款套餐（产品），然后出售给客户，比第一种少了指挥者，主要是第二种方式把指挥者交给用户来操作，使得产品的创建更加简单灵活。

Builder.java

package builder.demo2;
/**
 * 抽象建造者
 * @author Admin
 *
 */
public abstract class Builder {

	abstract Builder buildA(String msg);	//汉堡
	abstract Builder buildB(String msg);	//可乐
	abstract Builder buildC(String msg);	//薯条
	abstract Builder buildD(String msg);	//甜点
	
	abstract Product getProduct();
}

 Product.java

package builder.demo2;
/**
 * 产品：套餐
 * @author Admin
 *
 */
public class Product {

	private String BuildA="汉堡";
	private String BuildB="可乐";
	private String BuildC="薯条";
	private String BuildD="甜点";
	public String getBuildA() {
		return BuildA;
	}
	public void setBuildA(String buildA) {
		BuildA = buildA;
	}
	public String getBuildB() {
		return BuildB;
	}
	public void setBuildB(String buildB) {
		BuildB = buildB;
	}
	public String getBuildC() {
		return BuildC;
	}
	public void setBuildC(String buildC) {
		BuildC = buildC;
	}
	public String getBuildD() {
		return BuildD;
	}
	public void setBuildD(String buildD) {
		BuildD = buildD;
	}
	@Override
	public String toString() {
		return "Product [BuildA=" + BuildA + ", BuildB=" + BuildB + ", BuildC=" + BuildC + ", BuildD=" + BuildD + "]";
	}
	
	
	
}

Worker.java

package builder.demo2;

public class Worker extends Builder {

	private Product product;
	
	public Worker() {
		product=new Product();
	}
	
	@Override
	Builder buildA(String msg) {
		product.setBuildA(msg);
		return this;
	}

	@Override
	Builder buildB(String msg) {
		product.setBuildB(msg);
		return this;
	}

	@Override
	Builder buildC(String msg) {
		product.setBuildC(msg);
		return this;
	}

	@Override
	Builder buildD(String msg) {
		product.setBuildD(msg);
		return this;
	}

	@Override
	Product getProduct() {
		return product;
	}

}

Test.java

package builder.demo2;

public class Test {

	public static void main(String[] args) {
//		服务员
		Worker worker=new Worker();
//		Product product=worker.getProduct();
//		链式编程,在原来基础上，可以自由组合，如果不组合，也有默认的套餐
		Product product=worker.buildA("全家桶").buildB("雪碧").getProduct();
		System.out.println(product.toString());
	}
}

控制台输出 

Product [BuildA=全家桶, BuildB=雪碧, BuildC=薯条, BuildD=甜点]

---

4.建造者的优缺点以及和抽象工厂模式的比较

优点：

• 产品的建造和表示分离，实现了解耦。使用建造者模式可以使客户端不必知道产品内部组成的细节
• 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
• 具体的建造者类之间是相互独立的，有利于系统的扩展，增加新的具体建造者无需修改原有类库的代码，符合开闭原则。

缺点

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似。如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制
• 如果产品的内部变化复制，可能会导致需要定义很多具体建造者来实现这种变化，导致系统变得很庞大

应用场景  

• 需要生产的产品对象有复杂的内部结构，这些产品对象具备共性
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品
• 适合一个具有较多的零件（属性）的产品（对象）的创建过程

建造者模式和抽象工厂模式的比较

1. 与抽象工厂模式比，建造者模式返回一个组装好的完整产品，而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成一个产品族
2. 在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象。但在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤，它侧重于一步步构造一个复杂对象，返回一个完整的对象。
3. 如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品。那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车