Java Builder 模式,你搞明白了么？

Builder 模式定義

Builder 模式中文叫作建造者模式，又叫生成器模式，它屬於對象創建型模式，是將一個復雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。建造者模式是一步一步創建一個復雜的對象，它允許用戶只通過指定復雜對象的類型和內容就可以構建它們，用戶不需要知道內部的具體構建細節。下圖是建造者模式的通用類圖：

在建造者模式中，有如下４種角色：

• Product：產品角色
• Builder：抽象建造者，定義產品接口
• ConcreteBuilder：具體建造者，實現Builder定義的接口，並且返回組裝好的產品
• Director：指揮者，屬於這里面的老大，你需要生產什么產品都直接找它。

建造者模式應用舉例

家裝

家裝不管是精裝還是簡裝，它的流程都相對固定，所以它適用於建造者模式。我們就以家裝為例，一起來學習了解一下建造者模式。下圖是家裝建造者模式簡單的 UML 圖。

1、家裝對象類

/**
 * 家裝對象類
 */
public class House {
    // 買家電
    private String jiadian;

    // 買地板
    private String diban;
    // 買油漆
    private String youqi;

    public String getJiadian() {
        return jiadian;
    }

    public void setJiadian(String jiadian) {
        this.jiadian = jiadian;
    }

    public String getDiban() {
        return diban;
    }

    public void setDiban(String diban) {
        this.diban = diban;
    }

    public String getYouqi() {
        return youqi;
    }

    public void setYouqi(String youqi) {
        this.youqi = youqi;
    }

    @Override
    public String toString() {
        return "House{" +
                "jiadian='" + jiadian + '\'' +
                ", diban='" + diban + '\'' +
                ", youqi='" + youqi + '\'' +
                '}';
    }
}

2、抽象建造者 Builder 類

/**
 * 抽象建造者
 */
public interface HouseBuilder {
    // 買家電
    void doJiadian();
    // 買地板
    void doDiBan();
    // 買油漆
    void doYouqi();

    House getHouse();
}

3、具體建造者－簡裝建造者類

/**
 * 簡裝創建者
 */
public class JianzhuangBuilder implements HouseBuilder {

    private House house = new House();

    @Override
    public void doJiadian() {
        house.setJiadian("簡單家電就好");
    }

    @Override
    public void doDiBan() {
        house.setDiban("普通地板");
    }

    @Override
    public void doYouqi() {
        house.setYouqi("污染較小的油漆就行");
    }

    @Override
    public House getHouse() {
        return house;
    }
}

4、具體建造者－精裝建造者類

/**
 * 精裝創建者
 */
public class jingzhuangBuilder implements HouseBuilder {

    private House house = new House();

    @Override
    public void doJiadian() {
        house.setJiadian("二話不說，最好的");
    }

    @Override
    public void doDiBan() {
        house.setDiban("二話不說，實木地板");
    }

    @Override
    public void doYouqi() {
        house.setYouqi("二話不說，給我來0污染的");
    }

    @Override
    public House getHouse() {
        return house;
    }
}

5、指揮官－家裝公司類

/**
 * 家裝公司，值需要告訴他精裝還是簡裝
 */
public class HouseDirector {

    public House builder(HouseBuilder houseBuilder){
        houseBuilder.doDiBan();
        houseBuilder.doJiadian();
        houseBuilder.doYouqi();
        return houseBuilder.getHouse();
    }
}

6、測試

public class App {
    public static void main(String[] args) {
        house();
    }

    public static void house(){
        HouseDirector houseDirector = new HouseDirector();
        // 簡裝
        JianzhuangBuilder jianzhuangBuilder = new JianzhuangBuilder();
        System.out.println("我要簡裝");
        System.out.println(houseDirector.builder(jianzhuangBuilder));

        // 精裝
        jingzhuangBuilder jingzhuangBuilder = new jingzhuangBuilder();
        System.out.println("我要精裝");
        System.out.println(houseDirector.builder(jingzhuangBuilder));

    }
}

輸出結果

我們以家裝為例，實現了兩個具體的建造者，一個簡裝建造者、一個精裝建造者。我們只需要告訴家裝公司，我是需要簡裝還是精裝，他會去幫我們安排，我不需要知道里面具體的細節。怎么樣，建造者模式學回了嗎？

對象構建

在日常開發中，你是不是會經常看到下面這種代碼:

return new Docket(DocumentationType.SWAGGER_2)
        .apiInfo(apiInfo())
        .select()
        .apis(RequestHandlerSelectors.basePackage("com.curry.springbootswagger.controller"))
        .paths(PathSelectors.any())
        .build();

是不是很優美？學會了 Builder 模式之后，你也可以通過這種方式進行對象構建。它是通過變種的 Builder 模式實現的。先不解釋了，我們先用 Builder 模式來實現跟上述的對象構建，使用學生類為例。

學生對象代碼：

public class Student {

    private String name;

    private int age;

    private int num;

    private String email;

    // 提供一個靜態builder方法
    public static Student.Builder builder() {
        return new Student.Builder();
    }
    // 外部調用builder類的屬性接口進行設值。
    public static class Builder{
        private String name;

        private int age;

        private int num;

        private String email;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder num(int num) {
            this.num = num;
            return this;
        }

        public Builder email(String email) {
            this.email = email;
            return this;
        }

        public Student build() {
            // 將builder對象傳入到學生構造函數
            return new Student(this);
        }
    }
    // 私有化構造器
    private Student(Builder builder) {
        name = builder.name;
        age = builder.age;
        num = builder.num;
        email = builder.email;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", num=" + num +
                ", email='" + email + '\'' +
                '}';
    }
}

調用代碼：

    public static void student(){
        Student student = Student.builder().name("平頭哥").num(1).age(18).email("平頭哥@163.com").build();
        System.out.println(student);
    }

可以看到，變種 Builder 模式包括以下內容：

• 在要構建的類內部創建一個靜態內部類 Builder
• 靜態內部類的參數與構建類一致
• 構建類的構造參數是 靜態內部類，使用靜態內部類的變量一一賦值給構建類
• 靜態內部類提供參數的 setter 方法，並且返回值是當前 Builder 對象
• 最終提供一個 build 方法構建一個構建類的對象，參數是當前 Builder 對象

可能你會說，這種寫法實現太麻煩了，確實需要我們寫很多額外的代碼，好在前輩們已經開發出了lombok來拯救我們，我們只需要引入lombok插件，然后在實體類上添加@Builder注解，你就可以實用 Builder 模式構建對象了。

建造者模式的優缺點

優點

• 在建造者模式中， 客戶端不必知道產品內部組成的細節，將產品本身與產品的創建過程解耦，使得相同的創建過程可以創建不同的產品對象
• 每一個具體建造者都相對獨立，而與其他的具體建造者無關，因此可以很方便地替換具體建造者或增加新的具體建造者， 用戶使用不同的具體建造者即可得到不同的產品對象
• 可以更加精細地控制產品的創建過程 。將復雜產品的創建步驟分解在不同的方法中，使得創建過程更加清晰，也更方便使用程序來控制創建過程
• 增加新的具體建造者無須修改原有類庫的代碼，指揮者類針對抽象建造者類編程，系統擴展方便，符合“開閉原則”

缺點

• 建造者模式所創建的產品一般具有較多的共同點，其組成部分相似，如果產品之間的差異性很大，則不適合使用建造者模式，因此其使用范圍受到一定的限制。
• 如果產品的內部變化復雜，可能會導致需要定義很多具體建造者類來實現這種變化，導致系統變得很龐大。

文章不足之處，望大家多多指點，共同學習，共同進步

最后

打個小廣告，歡迎掃碼關注微信公眾號：「平頭哥的技術博文」，一起進步吧。