构建者模式——封装返回对象

一、概述

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

三个角色：建造者、具体的建造者、监工、使用者（严格来说不算）

• 建造者角色：定义生成实例所需要的所有方法；
• 具体的建造者角色：实现生成实例所需要的所有方法，并且定义获取最终生成实例的方法；
• 监工角色：定义使用建造者角色中的方法来生成实例的方法；
• 使用者：使用建造者模式。

二、案例

建造者角色：

public abstract class Builder {
    public abstract void buildPart1();
    public abstract void buildPart2();
    public abstract void buildPart3();
}

监工角色：

public class Director {    // 将一个复杂的构建过程与其表示相分离
    private Builder builder;    // 针对接口编程，而不是针对实现编程
    public Director(Builder builder) {
        this.builder = builder;
    }
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    public void construct() {   // 控制（定义）一个复杂的构建过程
        builder.buildPart1();
        builder.buildPart2();
        builder.buildPart3();
    }
}

具体的建造者角色：

public class ConcreteBuilder extends Builder {
  private StringBuffer buffer = new StringBuffer();//假设 buffer.toString() 就是最终生成的产品

    @Override
    public void buildPart1() {//实现构建最终实例需要的所有方法
        buffer.append("Builder1 : Part1\n");
    }

    @Override
    public void buildPart2() {
        buffer.append("Builder1 : Part2\n");
    }

    @Override
    public void buildPart3() {
        buffer.append("Builder1 : Part3\n");
    }
    
    public String getResult() {//定义获取最终生成实例的方法
        return buffer.toString();
    }
}

客户角色：

public class Client {
    public void testBuilderPattern() {
        ConcreteBuilder1 b1 = new ConcreteBuilder1();//建造者
        Director director = new Director(b1);//监工
        director.construct();//建造实例(监工负责监督，建造者实际建造)
        String result = b1.getResult();//获取最终生成结果
        System.out.printf("the result is :%n%s", result);
    }
}

三、使用构建者模式封装数据传输中的返回对象

参考Spring中的ResponseEnity,我们自定义一个。

定义的接口，我们需要构建出来的对象

建造者角色

public interface ResponseBuilder<T> {

    ResponseBuilder buildPage(int page);
    ResponseBuilder buildData(T data);
    ResponseBuilder buildError(String error);

    ResponseBuilder OK();
    ResponseBuilder OK(int page);
    ResponseBuilder OK(int page, T data);

    ResponseBuilder Error();
    ResponseBuilder Error(String message);
}

构建者

public class ResponseBuilderImpl<T> implements ResponseBuilder<T>{

    private ResponseVo<T> responseVo = new ResponseVo<>();

    public ResponseBuilderImpl(int code){
        responseVo.setCode(code);
    }

    public ResponseBuilderImpl(){}

    @Override
    public ResponseBuilder buildPage(int page) {
        responseVo.setCode(page);
        return this;
    }

    @Override
    public ResponseBuilder buildData(T data) {
        responseVo.setData(data);
        return this;
    }

    @Override
    public ResponseBuilder buildError(String error) {
        responseVo.setError(error);
        return null;
    }

    @Override
    public ResponseBuilder OK() {
        responseVo.setCode(200);
        return this;
    }

    @Override
    public ResponseBuilder OK(int page) {
        responseVo.setPage(page);
        return this.OK();
    }

    @Override
    public ResponseBuilder OK(int page, T data) {
        responseVo.setData(data);
        return this.OK(page);
    }

    @Override
    public ResponseBuilder Error() {
        responseVo.setCode(500);
        return this;
    }

    @Override
    public ResponseBuilder Error(String message) {
        responseVo.setError(message);
        return this.Error();
    }
}

实体类

public class ResponseVo<T> {

    int code;
    int page;
    T data;
    String error;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public int getPage() {
        return page;
    }

    public void setPage(int page) {
        this.page = page;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getError() {
        return error;
    }

    public void setError(String error) {
        this.error = error;
    }

    // 下面是我们需要构建的实现对象，类似监工角色
    private static ResponseBuilderImpl<Object> builder = new ResponseBuilderImpl<>();

    public static void OK() {
        builder.OK();
    }

    public static void OK(int page) {
        builder.OK(page);
    }

    public static <T> void OK(int page, T data) {
        builder.OK(page, data);
    }

    public static void Error() {
        builder.Error();
    }

    public static void Error(String message) {
        builder.Error(message);
    }

    public static ResponseBuilder buildCode(int code) {
        return new ResponseBuilderImpl(code);
    }

}

使用者，调用：

可以看到一个类似ResponseEntity的类就实现了，我们可以通过链式操作构建我们想要的结果对象。