Java设计模式（建造者模式）通俗易懂

建造者模式

对于有多个成员属性，且不是每个成员属性都需要的类进行实例化，如果用构造函数，或set方法赋值，代码就显得冗余。

例如有一个网络请求的类，有以下这些成员属性构成，但是发起一个网络请求，用不到这么多的参数，显然构建这个对象就有点复杂。

使用建造者模式

角色

• 产品角色 （Request类）
• 建造者角色 （Request.Builder类）

import java.util.LinkedHashMap;
import java.util.Map;

public class Request {

    /* 请求地址 */
    private String                  url;
    /* 请求方法 */
    private String                  month;
    /* 请求类型 */
    private String                  contentType;
    /* 请求头 */
    private Map<String, String>     header;
    /* post请求入参 */
    private Map<String, String>     body;
    /* post json类型请求json字符串 */
    private String                  jsonBody;

    /**
     * 创建一个 Builder 对象
     * @return
     */
    public static Builder builder() {
        return new Builder();
    }
    
	/**
     * 发起请求
     * @return
     */
    public String execute() {
        if ("GET".equals(month)) {
            System.out.println("发生 get 请求");
        } else if ("POST".equals(month)) {
            System.out.println("发生 post 请求");
        }
        return "";
    }

    /**
     * 私有化构造函数
     */
    private Request() {}

    /**
     * 创建 Request 实例，参数是 Builder
     * @param builder
     */
    private Request(Builder builder) {
        this.url = builder.url;
        this.month = builder.month;
        this.contentType = builder.contentType;
        this.header = builder.header;
        this.body = builder.body;
        this.jsonBody = builder.jsonBody;
    }

    /**
     * 创建 Request 的Builder类
     */
    public static class Builder {
        /* 请求地址 */
        private String                  url;
        /* 请求方法 */
        private String                  month;
        /* 请求类型 */
        private String                  contentType;
        /* 请求头 */
        private Map<String, String>     header;
        /* post请求入参 */
        private Map<String, String>     body;
        /* post json类型请求json字符串 */
        private String                  jsonBody;

        public Builder url(String url) {
            this.url = url;
            return this;
        }
        public Builder month(String month) {
            this.month = month;
            return this;
        }
        public Builder contentType(String contentType) {
            this.contentType = contentType;
            return this;
        }
        public Builder header(String headKey, String headValue) {
            if (this.header == null) {
                this.header = new LinkedHashMap<>();
            }
            this.header.put(headKey, headValue);
            return this;
        }
        public Builder body(String name, String value) {
            if (this.body == null) {
                this.body = new LinkedHashMap<>();
            }
            this.body.put(name, value);
            return this;
        }
        public Builder jsonBody(String jsonBody) {
            this.jsonBody = jsonBody;
            return this;
        }

        /**
         * 创建 Request 对象
         * @return
         */
        public Request build() {
            return new Request(this);
        }
    }

建造者模式使用

public class Test {

    public static void main(String[] args) {
        Request request = Request.builder()
                .url("http://www.baidu.com")        // 设计 url
                .month("POST")                      // 请求方法
                .contentType("application/json")    // 请求类型
                .header("token", "token") // 添加 header
                .header("user", "user")   // 添加 header
                .jsonBody("{\"user\": \"123\"}")            // post json入参
                .build();                                   // 创建 Request对象

        request.execute();
    }

}

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

觉得对您有帮助，就点个赞呗。😀