设计模式——建造者模式

建造者模式

建造者模式（Builder Pattern）也叫生成器模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

如上面类图，在建造者模式中，共有4个角色：

• Product产品类：通常是实现了模板方法模式，也就是有模板方法和基本方法。
• Builder抽象建造者：规范产品的组建，一般是由子类实现。
• ConcreteBuilder具体建造者：实现抽象类定义的所有方法，并且返回一个组建好的对象。
• Director导演类：负责安排已有模块的顺序，然后告诉Builder开始建造。

（1）产品类Product

public class Product { 
    public void doSomething(){ 
        //独立业务处理 
    } 
}

（2）抽象建造者Builder

public abstract class Builder { 
    //设置产品的不同部分，以获得不同的产品 
    public abstract void setPart(); 
    //建造产品 
    public abstract Product buildProduct(); 
}

（3）具体建造者ConcreteProduct

public class ConcreteProduct extends Builder { 
    private Product product = new Product(); 
    //设置产品零件
    public void setPart(){ 
        /*
        * 产品类内的逻辑处理 
        */ 
    }
    //组建一个产品 
    public Product buildProduct() { 
        return product; 
    } 
}

需要注意的是，如果有多个产品类就有几个具体的建造者，而且这多个产品类具有相同接口或抽象类。

（4）导演类Director

public class Director { 
    private Builder builder = new ConcreteProduct(); 
    //构建不同的产品 
    public Product getAProduct(){ 
        builder.setPart(); 
        /*
        * 设置不同的零件，产生不同的产品 
        */ 
        return builder.buildProduct(); 
    } 
}

导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。当然，在建造者模式比较庞大时，导演类可以有多个。

---

建造者模式的优点

• 封装性：使用建造者模式可以使客户端不必知道产品内部组成的细节。
• 建造者独立，容易扩展。
• 便于控制细节风险：由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

---

建造者模式的使用场景

• 相同的方法，不同的执行顺序，产生不同的事件结果时。
• 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
• 产品类非常复杂，或者产品类中的调用顺序不同产生不同的效能。
• 在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建 过程，本身已经违反设计的最初目标。

---

注意事项

• 建造者模式关注的是零件类型和装配工艺（顺序），这是它与工厂方法模式最大的不同，虽然同为创建类模式，但是注重点不同。
• 建造者通过零件的组装去建造一个对象。组装顺序不同对象效能也不同，这才是建造者模式要表达的核心意义，而怎么才能更好地达到这种效果呢？引入模板方法模式是一个非常简单而有效的办法。
• 建造者模式最主要的功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了，通俗地说就是零件的装配，顺序不同产生的对象也不同；而工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。

---

建造者模式实例

制作奔驰、宝马的车辆模型，汽车的启动、停止、喇叭声音、引擎声音都由客户自己控制，他想什么顺序就什么顺序。类图如下：

• CarModel中我们定义了一个setSequence()方法，通过ArrayList中定义的动作和排布顺序确定车辆模型。然后run()方法根据sequence定义的顺序完成指定的顺序动作。
• CarBuilder抽象类，用来组装各个车模，要什么类型什么顺序的车辆模型，都由相关的子类完成。
• Director类，负责按照指定的顺序生产模型。其中共定义了4种顺序模型。

（1）CarModel抽象类，及其实现

import java.util.ArrayList;
public abstract class CarModel { 
    //这个参数是各个基本方法执行的顺序 
    private ArrayList<String> sequence = new ArrayList<String>(); 
    protected abstract void start(); 
    protected abstract void stop(); 
    protected abstract void alarm(); 
    protected abstract void engineBoom(); 
    final public void run() {
        for(int i=0;i<this.sequence.size();i++){ 
            String actionName = this.sequence.get(i);
            if(actionName.equalsIgnoreCase("start")){ 
                this.start(); 
            }else if(actionName.equalsIgnoreCase("stop")){ 
                this.stop(); 
            }else if(actionName.equalsIgnoreCase("alarm")){ 
                this.alarm(); 
            }else if(actionName.equalsIgnoreCase("engine boom")){ 
                this.engineBoom(); 
            } 
        } 
    }
    //把传递过来的值传递到类内 
    final public void setSequence(ArrayList sequence){ 
        this.sequence = sequence; 
    } 
}

import com.sfq.impl.CarModel;
public class BenzModel extends CarModel {
	@Override
	protected void start() {
		System.out.println("奔驰车跑起来是这个样子的..."); 
	}
	@Override
	protected void stop() {
		System.out.println("奔驰车应该这样停车..."); 
	}
	@Override
	protected void alarm() {
		System.out.println("奔驰车的喇叭声音是这个样子的..."); 
	}
	@Override
	protected void engineBoom() {
		System.out.println("奔驰车的引擎是这个声音的..."); 
	}
}

import com.sfq.impl.CarModel;
public class BMWModel extends CarModel {
	@Override
	protected void start() {
		System.out.println("宝马车跑起来是这个样子的..."); 
	}
	@Override
	protected void stop() {
		System.out.println("宝马车应该这样停车..."); 
	}
	@Override
	protected void alarm() {
		System.out.println("宝马车的喇叭声音是这个样子的..."); 
	}
	@Override
	protected void engineBoom() {
		System.out.println("宝马车的引擎是这个声音的..."); 
	}
}

当然，我们仅凭上述类也能实现该用户自定义顺序的功能，场景类如下：

import java.util.ArrayList;
import com.sfq.action.BenzModel;
public class Client {
	public static void main(String[] args) {
        BenzModel benz = new BenzModel(); 
        //存放奔驰车的run的顺序:轰鸣->启动->停车
        ArrayList<String> sequence = new ArrayList<String>(); 
        sequence.add("engine boom"); 
        sequence.add("start"); 
        sequence.add("stop"); 
        benz.setSequence(sequence); 
        benz.run();         
	}
}

结果
奔驰车的引擎是这个声音的...
奔驰车跑起来是这个样子的...
奔驰车应该这样停车...

这里要求的是奔驰车的run的顺序:轰鸣->启动->停车，如果我们需要各种顺序的奔驰车或其他型号的车，那么我们都需要在场景中重新定义，这非常麻烦。我们可以为每种模型产品模型定义一个建造者，你要啥顺序直接告诉建造者，由建造者来建造。

（2）CarBuilder汽车组装者抽象类，及其相应模型组装者实现

import java.util.ArrayList;
public abstract class CarBuilder {
	//建造一个模型，你要给我一个顺序要求，就是组装顺序 
	public abstract void setSequence(ArrayList<String> sequence); 
	//设置完毕顺序后，就可以直接拿到这个车辆模型 
	public abstract CarModel getCarModel();
}

import java.util.ArrayList;
import com.sfq.impl.CarBuilder;
import com.sfq.impl.CarModel;

public class BenzBuilder extends CarBuilder {
	private BenzModel benz = new BenzModel();
	@Override
	public void setSequence(ArrayList<String> sequence) {
		this.benz.setSequence(sequence);
	}
	@Override
	public CarModel getCarModel() {
		return this.benz;
	}
}

import com.sfq.impl.CarBuilder;
import com.sfq.impl.CarModel;
public class BMWBuilder extends CarBuilder {
	private BMWModel bmw = new BMWModel();
	@Override
	public void setSequence(ArrayList<String> sequence) {
		this.bmw.setSequence(sequence);
	}
	@Override
	public CarModel getCarModel() {
		return this.bmw;
	}
}

同样，我们编码到这里，可以通过CarBuilder和CarModel来实现该用户自定义顺序的功能，场景类如下：

import java.util.ArrayList;
import com.sfq.action.BenzBuilder;
import com.sfq.action.BenzModel;
public class Client {
	public static void main(String[] args) {
        //存放run的顺序:轰鸣->启动->停车
        ArrayList<String> sequence = new ArrayList<String>(); 
        sequence.add("engine boom"); 
        sequence.add("start"); 
        sequence.add("stop"); 

        //要一个奔驰车： 
        BenzBuilder benzBuilder = new BenzBuilder();
        //把顺序给这个builder类，制造出这样一个车出来 
        benzBuilder.setSequence(sequence); 
        //制造出一个奔驰车 
        BenzModel benz = (BenzModel)benzBuilder.getCarModel(); 
        benz.run();        
	}
}

结果
奔驰车的引擎是这个声音的...
奔驰车跑起来是这个样子的...
奔驰车应该这样停车...

同样，我们不能对每一种顺序面面俱到，我们可以将这些顺序封装一下，找一个导演，指挥各个事件的先后顺序，然后为每种顺序指定一个代码，你说一种我们立刻就给你生产处理。每个顺序都可以放在导演类中存在，以便重复利用。

（3）Director导演类设置及实现

根据客户对事件的顺序要求，将相应的顺序要求放在导演类中，共有四种要求，如要多种要求可继续扩展导演类。实际上就是对（2）中的场景类进行了封装。

import java.util.ArrayList;
public class Director {
	private ArrayList<String> sequence = new ArrayList(); 
	private BenzBuilder benzBuilder = new BenzBuilder(); 
	private BMWBuilder bmwBuilder = new BMWBuilder(); 
	/** A类型的奔驰车模型，先start，然后stop，其他什么引擎、喇叭一概没有 */ 
	public BenzModel getABenzModel(){ 
		this.sequence.clear(); 
		this.sequence.add("start"); 
		this.sequence.add("stop"); 
		this.benzBuilder.setSequence(this.sequence); 
		return (BenzModel)this.benzBuilder.getCarModel(); 
	}
	/** B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭 */ 
	public BenzModel getBBenzModel() {
		this.sequence.clear(); 
		this.sequence.add("engine boom"); 
		this.sequence.add("start"); 
		this.sequence.add("stop");
		this.benzBuilder.setSequence(this.sequence); 
		return (BenzModel)this.benzBuilder.getCarModel(); 
	}
	/** C型号的宝马车是先按下喇叭，然后启动，然后停止 */ 
	public BMWModel getCBMWModel(){ 
		this.sequence.clear(); 
		this.sequence.add("alarm"); 
		this.sequence.add("start"); 
		this.sequence.add("stop"); 
		this.bmwBuilder.setSequence(this.sequence); 
		return (BMWModel)this.bmwBuilder.getCarModel(); 
	}
	/** D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止 */ 
	public BMWModel getDBMWModel(){ 
		this.sequence.clear(); 
		this.sequence.add("start"); 
		this.bmwBuilder.setSequence(this.sequence); 
		return (BMWModel)this.benzBuilder.getCarModel(); 
	}
}

import com.sfq.action.Director;
public class Client {
	public static void main(String[] args) {
		Director director = new Director(); 
		//1万辆A类型的奔驰车
		for(int i=0;i<10000;i++){ 
			director.getABenzModel().run(); 
		}
		//100万辆B类型的奔驰车 
		for(int i=0;i<1000000;i++){ 
			director.getBBenzModel().run(); 
		}
		//1000万辆C类型的宝马车 
		for(int i=0;i<10000000;i++){ 
			director.getCBMWModel().run(); 
		}       
	}
}

结果
奔驰车跑起来是这个样子的...
奔驰车应该这样停车...
奔驰车的引擎是这个声音的...
奔驰车跑起来是这个样子的...
奔驰车应该这样停车...
奔驰车的引擎是这个声音的...
......

建造者模式最主要的功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了，通俗地说就是零件的装配，顺序不同产生的对象也不同；而工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。