生成器模式是创建型设计模式。
设计意图：将一个复杂的类表示与其构造相分离，使得相同的构建过程能够得出不同的表示。
实例类图：
IVehicleBuilder：抽象建造者，为创建一个Vehicle对象并创建它的相关部件指定的抽象接口，把产品的生产过程分解为不同的步骤，从而使具体的建造者在具体的建造步骤上具有更多弹性，从而创造出不同表示的产品。（这里就是小车和卡车）
CarBuilder、TrunkBuilder：具体建造者，实现IVehicleBuilder接口，构造和装配产品的各个部件定义并明确它所创建的表示，提供一个返回这个产品的接口。
Director：指挥者，构建一个使用IVehicleBuilder接口的对象。
Vehicle：汽车产品，被构建的复杂对象，具体产品建造者，创建该产品的内部表示并定义它的装配过程。
我们先看一下Director都做了什么！
package com.builder;
import com.factory.abstrcatfactory.model.Engine;
import com.factory.abstrcatfactory.model.Tank;
import com.factory.abstrcatfactory.model.Vehicle;
/**构建器的指挥者
* 构建器模式可以构建相同步骤的两个系列商品
* 在构建相同步骤的系列商品上，代码量上要优于抽象工厂模式，但是每个产品的不同步骤产品的增加时抽象工厂更有优势，因为功能类隔离性更好。
* @author gaoxu
* 实践出真知！
*/
public class Director {
private IVehicleBuilder _vehicleBuilder = null;
public Director(IVehicleBuilder vehicleBuilder){
_vehicleBuilder = vehicleBuilder;
}
public Vehicle createVehicle(){
Engine engine = _vehicleBuilder.builderEngine();
Tank tank = _vehicleBuilder.builderTank();
Vehicle vehicle = _vehicleBuilder.builderVehicle(engine,tank);
return vehicle;
}
}
我们看到指挥者负责指挥建造产品，再来看一下client的代码，我们就清楚指挥者有多重要了，生成器模式必须有指挥者。
package com.builder;
import com.factory.abstrcatfactory.model.Vehicle;
/**
* @author gaoxu
* 实践出真知！
*/
public class Client {
public static void main(String[] para){
//小车
IVehicleBuilder carBuilder = new CarBuilder();
Director director = new Director(carBuilder);
Vehicle car = director.createVehicle();
//卡车
IVehicleBuilder trunkBuilder = new TrunkBuilder();
Director directorT = new Director(trunkBuilder);
Vehicle trunk = directorT.createVehicle();
}
}
我们再来看具体构建者的代码，我们就清楚了，每个具体构建器都是一个产品的构建整体过程的具体实现。
小车具体构建者，构建发动机、构建油箱，构建小车。这些都封装在具体的构建器中，这样构建与表示就显示的分离，显示在client端没有任何具体构建者内容的影子，完全封装了起来。
package com.builder;
import com.factory.abstrcatfactory.model.Engine;
import com.factory.abstrcatfactory.model.Tank;
import com.factory.abstrcatfactory.model.Vehicle;
/**小车具体实现类
* @author gaoxu
* 实践出真知！
*/
public class CarBuilder implements IVehicleBuilder {
@Override
public Engine builderEngine() {
// TODO Auto-generated method stub
return null;
}
@Override
public Tank builderTank() {
// TODO Auto-generated method stub
return null;
}
@Override
public Vehicle builderVehicle(Engine engine,Tank tank) {
// TODO Auto-generated method stub
return null;
}
}
package com.builder;
import com.factory.abstrcatfactory.model.Engine;
import com.factory.abstrcatfactory.model.Tank;
import com.factory.abstrcatfactory.model.Vehicle;
/**卡车具体实现类
* @author gaoxu
* 实践出真知！
*/
public class TrunkBuilder implements IVehicleBuilder {
@Override
public Engine builderEngine() {
// TODO Auto-generated method stub
return null;
}
@Override
public Tank builderTank() {
// TODO Auto-generated method stub
return null;
}
@Override
public Vehicle builderVehicle(Engine engine,Tank tank) {
// TODO Auto-generated method stub
return null;
}
}
上边的实例也是创建汽车，我们可以看到同样是创建汽车，生成器模式要比抽象工厂模式的代码量少很多很多，当然在解耦方面还是抽象工厂更好一些，因为生成器中的具体构建器中有所有的产品部件的构建过程，如果这个过程更复杂那么具体构建器将非常庞大，修改起来错误率也会很高，而抽象工厂在这方面还是比较好的，每个部件都是独立的构建接口与类。
版权声明：本文为博主原创文章，未经博主允许不得转载。