java建造者模式

建造者模式的本质

分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)，从而可以构造出复杂的对象，这个模式适用于：某个对象的构建过程十分复杂的时候。

建造者模式是实现了依赖倒转原则，抽象不应该依赖于细节，细节应该依赖于抽象。建造者的的定义是：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

在建造者模式中存在4个角色

1.Builder : 为创建一个产品对象的各个部件指定的抽象接口

2.ConcreteBuilder : 实现builder接口以构造和装配该产品的各个部件，定义并明确他所创建的表示，并提供一个检索产品的接口。

3.Director :  构建一个使用Builder接口的对象。

4.Product : 表示被构建的复杂对象，ConcreteBuiler创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包含将这些部件装配成最终产品的接口。

 

从上图可以看出，Builder是为了创建一个productor对象各个部件指定的的抽象接口，Product是被构建的具体产品，Director是一个构建者，由它来指挥Builder，ConcreteBuilder是具体的构建，实现Builder接口的所有方法。

具体的实现代码如下：

显示product

/**
 * 轨道舱
 * @author lvdefu
 *
 */
public class OrbitalModule {
    private String name;

    
    public OrbitalModule(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

 

/**
 * 发动机类
 * @author lvdefu
 *
 */
public class Engine {
    private String name;
    
    
    public Engine(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

 

/**
 * 逃逸塔类
 * @author lvdefu
 *
 */
public class EscapeTower {
    private String name;

    
    public EscapeTower(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

 

/**
 * 宇宙飞船
 * @author lvdefu
 *
 */
public class AirShip {
    //轨道舱
    private OrbitalModule orbitalModule;
    //发动机
    private Engine engine;
    //逃逸塔
    private EscapeTower escapeTower;
    
    
    public OrbitalModule getOrbitalModule() {
        return orbitalModule;
    }
    public void setOrbitalModule(OrbitalModule orbitalModule) {
        this.orbitalModule = orbitalModule;
    }
    public Engine getEngine() {
        return engine;
    }
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    public EscapeTower getEscapeTower() {
        return escapeTower;
    }
    public void setEscapeTower(EscapeTower escapeTower) {
        this.escapeTower = escapeTower;
    }
    
}    

接下来是Builder

public interface Builder {
    /**
     * 创建轨道舱
     * @return
     */
    OrbitalModule createOrbitalModule();
    /**
     * 创建发动机
     * @return
     */
    Engine createEngine();
    /**
     * 创建逃逸塔
     * @return
     */
    EscapeTower createEscapeTower();
}
 

public class AirShipBuilder implements Builder{

    @Override
    public OrbitalModule createOrbitalModule() {
        System.out.println("创建轨道舱");
        return new OrbitalModule("轨道舱");
    }

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

    @Override
    public EscapeTower createEscapeTower() {
        System.out.println("创建逃逸塔");
        return new EscapeTower("逃逸塔");
    }

}

最后是Director

public interface Director {
    AirShip directorAirShip();
}

public class ConcreteDirector implements Director{
    
    private Builder builder;
    
    private AirShip airShip;

    public ConcreteDirector(Builder builder, AirShip airShip) {
        this.builder = builder;
        this.airShip = airShip;
    }

    @Override
    public AirShip directorAirShip() {
        OrbitalModule orbitalModule = builder.createOrbitalModule();
        Engine engine = builder.createEngine();
        EscapeTower escapeTower = builder.createEscapeTower();
        airShip.setOrbitalModule(orbitalModule);
        airShip.setEngine(engine);
        airShip.setEscapeTower(escapeTower);
        return airShip;
    }

}

最后是客户端测试类：

public class Client {
    
    public static void main(String[] args) {
        Builder builder = new AirShipBuilder();
        AirShip airShip = new AirShip();
        ConcreteDirector concreteDirector = new ConcreteDirector(builder, airShip);
        AirShip airship = concreteDirector.directorAirShip();
        
    }
}

建造者模式适用场景

　　建造者模式是在当创建复杂对象的复杂算法一个独立与该对象的组成部分以及它们的装配方式时适用的模式。