Java设计模式之建造者模式

概论

 什么是建造者模式呢？将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式示例

我们先来回忆一下在模板模式中的 示例，[内外部系统交互]中的四个步骤：

第一步：参数校验

第二步：封装对外的请求参数

第三步：对外提交请求

第四步：后置处理，例如记录操作日志

最后核心的算法设计在run方法中。如下代码所示：

public void run (ExampleContext context) {

        validate(context);

        prepare(context);

        proccess(context);

        after(context);
    }

客户端只要取调用run方法就可以。一切看来都很美好，但是如果我们想要把第一步和第二步交换执行顺序。或者把第二步舍弃。或者第三步和第四步交换执行顺序等等。

简单的描述一下问题：我们想要在一个算法中若干个步骤，客户端需要自定义步骤的顺序以及确定是否采用或者舍弃一些步骤。

此时需要用到建造者模式。首先我们需要有抽象产品类：

public abstract class AbstractProccessor {

    private List<String> sequence = new ArrayList<String>();



    public boolean validate(ExampleContext context) {
        if (context == null) {
            return false;
        }

        return true;
    }

    public abstract void prepare(ExampleContext context);

    public abstract void proccess(ExampleContext context);

    public abstract void after(ExampleContext context);

    protected boolean needAfterProccessing () {
        return true;
    }


    public List<String> getSequence() {
        return sequence;
    }

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

    public void run (ExampleContext context) {

        for(String methodName : sequence) {
            if(StringUtils.isEmpty(methodName)) {
                continue;
            }

            Method method = null;

            try {
                 method = this.getClass().getMethod(methodName, ExampleContext.class);
            } catch (Exception e) {

            }

            if(method == null) {
                continue;
            }

            try {
                method.invoke(this, context);
            } catch (Exception e) {

            }


        }
    }

}

第3行：声明一个表示顺序的集合，集合中存储的是算法中每个步骤的方法名。类型为String类型。

第31行-61行：run方法通过遍历顺序集合的方式依次执行。通过反射的方式来调用。

接下来，和模板方法中的两个具体产品类完全一样，一个是HttpProccessor，另外一个是OtherProccessor。代码如下所示：

public class HttpProccessor extends AbstractProccessor {

    protected boolean needAfterProccessing = false;

    @Override
    public void prepare(ExampleContext context) {

        System.out.println("http 前置处理");

    }

    @Override
    public void proccess(ExampleContext context) {

        System.out.println("http 提交请求");

    }

    @Override
    public void after(ExampleContext context) {

        System.out.println("http 后置处理");

    }
    
}

public class OtherProccessor extends AbstractProccessor {

    @Override
    public void prepare(ExampleContext context) {

        System.out.println("other 前置处理");

    }

    @Override
    public void proccess(ExampleContext context) {

        System.out.println("other 提交请求");

    }

    @Override
    public void after(ExampleContext context) {

        System.out.println("other 后置处理");

    }
}

最后我们需要修改一下我们的场景类Client:

public class Client {

    public static void main(String[] args) {

        AbstractProccessor proccessor = new HttpProccessor();

        List<String> list = new ArrayList<String>();
        list.add("prepare");
        list.add("proccess");
        proccessor.setSequence(list);

        proccessor.run(new ExampleContext());


    }
}

第7行-10行：设置要执行的步骤以及顺序。

运行结果如下所示：

http 前置处理
http 提交请求

 当我们需要很多种场景，是不是需要去写很多种负责的场景类？在建造者设计模式中引入一个很重要的角色--建造者。场景类需要什么顺序，只需要告诉建造者就行。

我们新增一个建造者抽象类AbtractorBuilder。

public abstract class AbstractBuilder {

    public abstract void setSequence(List<String> list);

    public abstract AbstractProccessor  getProccessor();
}

再新增一个HttpBuilder和OtherBuilder

public class HttpBuilder extends AbstractBuilder {

    private AbstractProccessor proccessor = new HttpProccessor();

    @Override
    public void setSequence(List<String> list) {
        proccessor.setSequence(list);
    }

    @Override
    public AbstractProccessor getProccessor() {
        return proccessor;
    }


}

public class OtherBuilder extends AbstractBuilder {

    private AbstractProccessor proccessor = new OtherProccessor();

    @Override
    public void setSequence(List<String> list) {
          proccessor.setSequence(list);
    }

    @Override
    public AbstractProccessor getProccessor() {
        return proccessor;
    }


}

继续修改一下场景类：

public class Client {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("prepare");
        list.add("proccess");

        HttpBuilder httpBuilder = new HttpBuilder();
        httpBuilder.setSequence(list);

        AbstractProccessor proccessor = httpBuilder.getProccessor();
        proccessor.run(new ExampleContext());

    }
}

但是我们的HttpBuilder还是在场景类中调用时，顺序还是不够灵活。 这时需要产生一个导演类，将所有预知的情况 组合的情况一一列出来。如下代码所示：

public class Director {

    private List<String> sequence = new ArrayList<String>();
    private AbstractBuilder httpBuilder = new HttpBuilder();
    private AbstractBuilder otherBuilder = new OtherBuilder();

    public AbstractProccessor getHttpProccessorFirst() {

        this.sequence.clear();
        sequence.add("prepare");

        httpBuilder.setSequence(sequence);

        AbstractProccessor proccessor = httpBuilder.getProccessor();

        return proccessor;
    }

    public AbstractProccessor getHttpProccessorSecond() {

        this.sequence.clear();
        sequence.add("prepare");
        sequence.add("after");

        httpBuilder.setSequence(sequence);

        AbstractProccessor proccessor = httpBuilder.getProccessor();

        return proccessor;
    }

    public AbstractProccessor getOtherProccessorFirst() {

        this.sequence.clear();
        sequence.add("prepare");

        otherBuilder.setSequence(sequence);

        AbstractProccessor proccessor = otherBuilder.getProccessor();

        return proccessor;
    }

    public AbstractProccessor getOtherProccessorSecond() {

        this.sequence.clear();
        sequence.add("prepare");
        sequence.add("after");

        otherBuilder.setSequence(sequence);

        AbstractProccessor proccessor = otherBuilder.getProccessor();

        return proccessor;
    }
}

最后我们在修改一下场景类：

public class Client {

    public static void main(String[] args) {

        AbstractProccessor proccessor = null;

        Director director = new Director();
        proccessor = director.getHttpProccessorFirst();
        proccessor.run(new ExampleContext());

        proccessor = director.getHttpProccessorSecond();
        proccessor.run(new ExampleContext());


        proccessor = director.getOtherProccessorFirst();
        proccessor.run(new ExampleContext());

        proccessor = director.getOtherProccessorSecond();
        proccessor.run(new ExampleContext());



    }
}

简单而明了，笔者在开发的过程中，遇到很多的开发者不注意代码质量，甚至连资深的技术专家都没有意识到这一点。写下一行代码需要10秒钟，而看懂一行代码确实需要很大的力气。因此设计模式是用简单的方式将复杂的业务需求清晰的表达出来。

最后总结一下。建造者模式是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

在建造者模式中有4个角色，分别是产品类，抽象建造者，具体建造者，导演。

建造者模式的优点

1.良好的封装：场景类不必知道产品内部的细节。

2.建造者的独立，良好的扩展：存在不同的具体建造者，每个建造者之间独立。

3.良好的控制风险：因为具体的建造者是相互独立的，因此建造过程也是独立的，不会某一个建造者的变动对其他造成影响。