设计模式之建造者模式

1、核心本质：

-分离了对象子组件的单独构造（有Builder来负责）和装配（有Director负责）。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用。
-由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

2、应用场景

-StringBuilder类的append方法
-SQL中的preparedStatement
-JDOM中，DomBuilder、SAXBuilder

3、优点

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

4、代码示例

问题：一个汽车由发动机、车身、底盘组成，如何建造一个汽车呢？

/**
 * 汽车类
 * @author ly1
 *
 */
public class Car {
    private Engine engine;  //引擎
    private Wheel wheel;    //车轮    
    private Chassis chassis;    //底盘
    public Car(Engine engine, Wheel wheel, Chassis chassis) {
        super();
        this.engine = engine;
        this.wheel = wheel;
        this.chassis = chassis;
    }
    public Engine getEngine() {
        return engine;
    }
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    public Wheel getWheel() {
        return wheel;
    }
    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }
    public Chassis getChassis() {
        return chassis;
    }
    public void setChassis(Chassis chassis) {
        this.chassis = chassis;
    }


}

/**
 * 发动机类
 * @author ly1
 *
 */
class Engine{
    private String name;


    public Engine(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 车轮类
 * @author ly1
 *
 */
class Wheel{
    private String name;

    public Wheel(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

/**
 * 底盘类
 * @author ly1
 *
 */
class Chassis{
    private String name;

    public Chassis(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

/**
 * 建造者接口
 * @author ly1
 *
 */
public interface Builder {
    Engine createEngine();
    Wheel createWheel();
    Chassis createChassis();
}

/**
 * 建造者接口实现类：AudiBuilder
 * @author ly1
 *
 */
public class AudiBuilder implements Builder{

    @Override
    public Engine createEngine() {
        System.out.println("发动机建造中...");
        return new Engine("奥迪");
    }

    @Override
    public Wheel createWheel() {
        System.out.println("车轮建造中...");
        return new Wheel("奥迪");
    }

    @Override
    public Chassis createChassis() {
        System.out.println("底盘建造中...");
        return new Chassis("奥迪");
    }

}

/**
 * 组装接口
 * @author ly1
 *
 */
public interface Director {
    Car create();
}

/**
 * 组装接口实现类：AudiDirector
 * @author ly1
 *
 */
public class AudiDirector implements Director{

    private Builder builder;

    public AudiDirector(Builder builder) {
        this.builder = builder;
    }

    @Override
    public Car create() {
        Engine e = builder.createEngine();
        Wheel w = builder.createWheel();
        Chassis c = builder.createChassis();

        return new Car(e,w,c);
    }

}

/**
 * 客户端调用
 * @author ly1
 *
 */
public class Client {
    public static void main(String[] args) {
        Builder builder = new AudiBuilder();
        Director director = new AudiDirector(builder);
        Car car = director.create();

        Engine engine = car.getEngine();
        System.out.println(engine.getName());
    }
}

结果：
发动机建造中...
车轮建造中...
底盘建造中...
奥迪

5、扩展

-如果系统中只需要一个具体的建造者的话，可以省略掉抽象建造者。
-在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略掉指导者角色，让Builder自己扮演指导者和建造者双重角色（在Builder中用一个方法完成组装）。