设计模式之05构建者模式（笔记）

1 定义：

1.1 定义：Separate theconstruction of a complex object from its representation so that the sameconstruction process can create different representations.(将一个复杂对象的构建与它的表示分离，使用同样的构建过程可以创建不同的表示。)

1.2 通用类图：

1.3 通用代码：

角色解说：

Ｐroduct产品类

通常是实现了模板方法模式，也就是模板方法和基本方法。

Ｂuilder抽象构造者

规范产品的组建，一般是由子类实现。

ＣoncreteＢuilder具体建造者

实现抽象类定义的所有方法，并且返回一个组建好的对象。

Ｄirector导演类

负责安排已有模块的顺序，然后告诉Ｂuilder开始建造。

通用源码如下：

public class Product {        
         publicvoid doSomething(){
                   //独立业务处理
         }
}
 
public abstract class Builder {        
         //设置产品的不同部分，以获得不同的产品
         publicabstract void setPart();        
        
         //建造产品
         publicabstract Product buildProduct();
}
 
public class ConcreteBuilder extendsBuilder {
         privateProduct product = new Product();
        
         //设置产品零件
         publicvoid setPart(){
                   /*
                    * 产品类内的逻辑处理
                    */
         }        
        
         //组建一个产品
         publicProduct buildProduct() {
                   returnproduct;
         }        
}
 
public class Director {
         privateBuilder builder = new ConcreteBuilder();
        
         //构建不同的产品
         publicProduct getAProduct(){
                   builder.setPart(); 
                   /*
                    * 设置不同的零件，产生不同的产品
                    */
                   returnbuilder.buildProduct();
         }
}

 

2 优点

2.1　封装性：导演类起到封装（应该是封装产品构造参数设定，避免高层模块深入到建造者内部的实现类。当然，在建造者模式比较庞大时，导演类可以有多个）的作用，可以使客户端不呢知道产品内部组成的细节。

2.2　建造者独立，容易扩展：具体的建造者之间是相互独立的，对系统扩展有利。

2.3　便于控制细节风险：由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

 

3 缺点

暂无

 

4 应用场景

4.1　相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。

4.2　多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用此模式。

4.3　产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能。

4.4　在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。{补偿方法：弥补设计不足}

 

5 注意事项

建造者模式关注的是零件类型和装配顺序，这是它与工厂方法模式（关注对象的创建，创建零件是它的主要职责，组装顺序则不关心）最大的不同。

 

6 扩展

7 范例

（用料不同、加料不同，炒得　“农家豆腐”　与　“小葱拌豆腐”）

类图如下：

 

源代码如下：

 

package _05_Builder;

public abstract class Tofu {	
	String mName;
	String mMaterial;
	
	public String getmName() {
		return mName;
	}
	public void setmName(String mName) {
		this.mName = mName;
	}
	public String getmMaterial() {
		return mMaterial;
	}
	public void setmMaterial(String mMaterial) {
		this.mMaterial = mMaterial;
	}
}

public class FamilyTofu extends Tofu{

}

public class BeanCurdMixedChoppedOnion extends Tofu{

}

public abstract class Builder {
	public abstract void putOil(String oil);//油
	public abstract void putSalt(String salt);//盐
	public abstract void putTofu(String tofu);//豆腐
	public abstract void putOnion(String onion);//	葱
	
	public abstract Tofu buildTofu(); //一道菜
}

public class FamilyTofuBuilder extends Builder{
	Tofu familyTofu = new FamilyTofu();
	
	public FamilyTofuBuilder(){
		familyTofu.setmName("FamilyTofu");
	}

	@Override
	public void putOil(String oil) {
		familyTofu.setmMaterial(oil);
	}

	@Override
	public void putSalt(String salt) {
		familyTofu.setmMaterial(familyTofu.getmMaterial() + salt);
	}

	@Override
	public void putTofu(String tofu) {
		familyTofu.setmMaterial(familyTofu.getmMaterial() + tofu);
	}

	@Override
	public void putOnion(String onion) {
		familyTofu.setmMaterial(familyTofu.getmMaterial() + onion);
	}

	@Override
	public Tofu buildTofu() {
		return familyTofu;
	}	
}

public class ChoppedOnionBuilder extends Builder{
	Tofu choppedOnion = new BeanCurdMixedChoppedOnion();
	
	public ChoppedOnionBuilder(){
		choppedOnion.setmName("BeanCurdMixedChoppedOnion");
	}

	@Override
	public void putOil(String oil) {
		choppedOnion.setmMaterial(oil);
	}

	@Override
	public void putSalt(String salt) {
		choppedOnion.setmMaterial(choppedOnion.getmMaterial() + salt);
	}

	@Override
	public void putTofu(String tofu) {
		choppedOnion.setmMaterial(choppedOnion.getmMaterial() + tofu);
	}

	@Override
	public void putOnion(String onion) {
		choppedOnion.setmMaterial(choppedOnion.getmMaterial() + onion);
	}

	@Override
	public Tofu buildTofu() {
		return choppedOnion;
	}	
}

public class Director {
	Builder familyTofuBuilder = new FamilyTofuBuilder();
	Builder choppedOnionBuilder = new ChoppedOnionBuilder();
	
	public Tofu ConstructFamilyTofu(){
		familyTofuBuilder.putOil("Oil  ");
		familyTofuBuilder.putTofu("More tofu  ");//农家豆腐先放豆腐，豆腐多葱少
		familyTofuBuilder.putOnion("Less Onion  ");//
		familyTofuBuilder.putSalt("Salt  ");
		return familyTofuBuilder.buildTofu();
	}
	
	public Tofu ConstructBeanCurdMixedChoppedOnion(){
		choppedOnionBuilder.putOil("Oil  ");
		choppedOnionBuilder.putOnion("More Onion  ");//小葱拌豆腐先放葱，豆腐少葱多
		choppedOnionBuilder.putTofu("Less tofu  ");//
		choppedOnionBuilder.putSalt("Salt  ");
		return choppedOnionBuilder.buildTofu();
	}
}

public class Test {
	public static void main(String args[]){
		Director d = new Director();		
		System.out.println("第一道菜：小葱拌豆腐");
		Tofu first = d.ConstructBeanCurdMixedChoppedOnion();
		System.out.println(first.getmName() + "    " + first.getmMaterial());
		
		System.out.println();
		
		System.out.println("第二道菜：农家豆腐");
		Tofu second = d.ConstructFamilyTofu();
		System.out.println(second.getmName() + "    " + second.getmMaterial());	
	}
}

结果如下：

第一道菜：小葱拌豆腐
BeanCurdMixedChoppedOnion    Oil  More Onion  Less tofu  Salt  


第二道菜：农家豆腐
FamilyTofu    Oil  More tofu  Less Onion  Salt