设计模式 建造者模式

建造者模式定义

Separate the construction of a complex object from its representation so that the same construction process can create different representations.（将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。）

建造者模式成员

抽象产品类 & 产品类

public abstract class AbstractProduct {
    private List<String> sequence = Lists.newArrayList();

    protected abstract void doSomething1();

    protected abstract void doSomething2();

    protected abstract void doSomething3();

	// 这里结合了模板方法模式
    final void run() {
        if (sequence.size() > 0) {
            for (String sequenceStr : sequence) {
                switch (sequenceStr) {
                    case "doSomething1":
                        this.doSomething1();
                        break;
                    case "doSomething2":
                        this.doSomething2();
                        break;
                    case "doSomething3":
                        this.doSomething3();
                        break;
                }
            }
        }
    }

    final void setSequence(List<String> sequence) {
        this.sequence = sequence;
    }
}

public class Product1 extends AbstractProduct {
    @Override
    protected void doSomething1() {
        System.out.println("Product1.doSomething1");
    }

    @Override
    protected void doSomething2() {
        System.out.println("Product1.doSomething2");
    }

    @Override
    protected void doSomething3() {
        System.out.println("Product1.doSomething3");
    }
}

public class Product2 extends AbstractProduct {
    @Override
    protected void doSomething1() {
        System.out.println("Product2.doSomething1");
    }

    @Override
    protected void doSomething2() {
        System.out.println("Product2.doSomething2");
    }

    @Override
    protected void doSomething3() {
        System.out.println("Product2.doSomething3");
    }
}

抽象建造者类 & 建造者类

public abstract class AbstractBuilder {
    public abstract void setSequence(List<String> sequence);

    public abstract AbstractProduct buildProduct();
}

public class Builder1 extends AbstractBuilder {
    private AbstractProduct product = new Product1();

    @Override
    public void setSequence(List<String> sequence) {
        this.product.setSequence(sequence);
    }

    @Override
    public AbstractProduct buildProduct() {
        return this.product;
    }
}

public class Builder2 extends AbstractBuilder {
    private AbstractProduct product = new Product2();

    @Override
    public void setSequence(List<String> sequence) {
        this.product.setSequence(sequence);
    }

    @Override
    public AbstractProduct buildProduct() {
        return this.product;
    }
}

导演类

public class Director {
    private AbstractBuilder abstractBuilder1 = new Builder1();
    private AbstractBuilder abstractBuilder2 = new Builder2();

    public AbstractProduct getProduct1() {
        List<String> sequence = Lists.newArrayList();
        sequence.add("doSomething1");
        sequence.add("doSomething2");
        sequence.add("doSomething3");
        abstractBuilder1.setSequence(sequence);
        return abstractBuilder1.buildProduct();
    }

    public AbstractProduct getProduct2() {
        List<String> sequence = Lists.newArrayList();
        sequence.add("doSomething3");
        sequence.add("doSomething2");
        sequence.add("doSomething1");
        abstractBuilder2.setSequence(sequence);
        return abstractBuilder2.buildProduct();
    }
}

调用者

public class Client {
    public static void main(String[] args) {
        Director director = new Director();
        director.getProduct1().run();
        director.getProduct2().run();
    }
}

建造者模式优点

• 封装性强，客户端无需知道产品内部组成的细节
• 建造者独立，容易扩展
• 便于控制细节风险

建造者模式缺点

• 导演类不是独立的，如果扩展产品类，需要对导演类进行修改，违背开闭原则