原文：Kotlin-ifying a Builder Pattern
原文地址：https://medium.com/google-developers/kotlin-ifying-a-builder-pattern-e5540c91bdbe
原文作者：Doug Sigelbaum
翻譯：卻把清梅嗅

譯者說

Doug Sigelbaum是Google的Android工程師，在這篇文章中级乍，作者講述了如何用Kotlin中Builder模式的實現(xiàn)方式况褪，并且針對會出現(xiàn)的問題提出了對應(yīng)的解決方案强胰。

我最近在網(wǎng)上翻看了很多Kotlin對Builder模式實現(xiàn)方式的文章颁股，說實話齿兔，個人感覺都不是很好丙曙，當我閱讀到這篇文章時拯杠，我認為這是目前我 比較滿意 的實現(xiàn)方式（可能Google有加分）善涨，因此翻譯下來以供大家參考窒盐。

在Java語言中，當一個對象的實例化需要多個參數(shù)時钢拧，建造者模式（Builder）已被認可為非常好的實現(xiàn)方式之一蟹漓。 正如《Effective Java》指出的，當一個構(gòu)造器擁有太多的參數(shù)時源内，對于構(gòu)造器中所需參數(shù)的修改很容易影響到實際的代碼葡粒。

當然，Kotlin語言中的命名參數(shù)在許多情況下解決了這個問題膜钓，因為在調(diào)用Kotlin的函數(shù)時嗽交，開發(fā)者可以指定每個參數(shù)的名稱，從而減少錯誤的發(fā)生颂斜。 但是轮纫，由于Java并沒有這樣的特性，因此Builder模式仍然是有必要的焚鲜。 此外掌唾，對于可選參數(shù)的動態(tài)設(shè)置，這種情況下也需要借助于Builder模式忿磅。

讓我們思考一下通過Java實現(xiàn)的一個簡單的Builder模式案例糯彬。 我們首先有一個POJO Company類，它包含幾個屬性葱她，也許這種情況足以使用Builder模式：

public final class Company {
    public final String name;
    public final double marketCap;
    public final double annualCosts;
    public final double annualRevenue;
    public final List<Employee> employees;
    public final List<Office> offices;

    private Company(Builder builder) {
        List<Employee> builtEmployees = new ArrayList<>();
        for (Employee.Builder employee : builder.employees) {
            builtEmployees.add(employee.build());
        }
        List<Office> builtOffices = new ArrayList<>();
        for (Office.Builder office : builder.offices) {
            builtOffices.add(office.build());
        }
        employees = Collections.unmodifiableList(builtEmployees);
        offices = Collections.unmodifiableList(builtOffices);
        name = builder.name;
        marketCap = builder.marketCap;
        annualCosts = builder.annualCosts;
        annualRevenue = builder.annualRevenue;
    }

    public static class Builder {
        private String name;
        private double marketCap;
        private double annualCosts;
        private double annualRevenue;
        private List<Employee.Builder> employees = new ArrayList<>();
        private List<Office.Builder> offices = new ArrayList<>();

        public Company build() {
            return new Company(this);
        }

        public Builder addEmployee(Employee.Builder employee) {
            employees.add(employee);
            return this;
        }

        public Builder addOffice(Office.Builder office) {
            offices.add(office);
            return this;
        }

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

        public Builder setMarketCap(double marketCap) {
            this.marketCap = marketCap;
            return this;
        }

        public Builder setAnnualCosts(double annualCosts) {
            this.annualCosts = annualCosts;
            return this;
        }

        public Builder setAnnualRevenue(double annualRevenue) {
            this.annualRevenue = annualRevenue;
            return this;
        }
    }
}

此外撩扒，公司有List<Employees>和List<Offices>。 這些類也使用構(gòu)建器模式：

public final class Employee {
    public final String firstName;
    public final String lastName;
    public final String id;
    public final boolean isManager;
    public final String managerId;

    private Employee(Builder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.id = builder.id;
        this.isManager = builder.isManager;
        this.managerId = builder.managerId;
    }

    public static class Builder {
        private String firstName;
        private String lastName;
        private String id;
        private boolean isManager;
        private String managerId;

        Employee build() {
            return new Employee(this);
        }

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

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

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

        public Builder setIsManager(boolean manager) {
            isManager = manager;
            return this;
        }

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

來看看Office.java：

public final class Office {
    public final String address;
    public final int capacity;
    public final int occupancy;
    public final int sqft;

    private Office(Builder builder) {
        address = builder.address;
        capacity = builder.capacity;
        occupancy = builder.occupancy;
        sqft = builder.sqft;
    }

    public static class Builder {
        private String address;
        private int capacity;
        private int occupancy;
        private int sqft;

        Office build() {
            return new Office(this);
        }

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

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

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

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

現(xiàn)在吨些，如果我們想構(gòu)建一個包含Employee和Office的Company搓谆，我們可以這樣：

public class JavaClient {
    public Company buildCompany() {
        Company.Builder company = new Company.Builder();
        Employee.Builder employee = new Employee.Builder()
                .setFirstName("Doug")
                .setLastName("Sigelbaum")
                .setIsManager(false)
                .setManagerId("XXX");
        Office.Builder office = new Office.Builder()
                .setAddress("San Francisco")
                .setCapacity(2500)
                .setOccupancy(2400);
        company.setAnnualCosts(0)
                .setAnnualRevenue(0)
                .addEmployee(employee)
                .addOffice(office);
        return company.build();
    }
}

在Kotlin中，我們會這樣去實現(xiàn)：

class KotlinClient {
    fun buildCompany(): Company {
        val company = Company.Builder()
        val employee = Employee.Builder()
            .setFirstName("Doug")
            .setLastName("Sigelbaum")
            .setIsManager(false)
            .setManagerId("XXX")
        val office = Office.Builder()
            .setAddress("San Francisco")
            .setCapacity(2500)
            .setOccupancy(2400)
        company.setAnnualCosts(0.0)
            .setAnnualRevenue(0.0)
            .addEmployee(employee)
            .addOffice(office)
        return company.build()
    }
}

Kotlin中實現(xiàn)Lambda參數(shù)的方法封裝

在Dokka（譯者注:這應(yīng)該是作者之前所在的一個公司）豪墅，我們使用kotlinx.html泉手，它可以通過一個漂亮的DSL來實例化HTML的對象。 在Android中偶器，它和通過Anko Layouts構(gòu)建布局類似斩萌。 正如我在上一篇文章中所討論的缝裤，slice-builders-ktx還在Builder模式之外提供了DSL包裝器。 所有這些庫都使用lambda參數(shù)提供了DSL的實現(xiàn)方式颊郎。 Lambda參數(shù)在Kotlin和Java 8+中可用憋飞，它們的使用方式略有不同。 有很多同行朋友姆吭，特別是Android開發(fā)者榛做，都在使用Java 7，我們只會在這篇文章中簡單使用一下Kotlin lambda參數(shù)内狸。 現(xiàn)在讓我們嘗試為Company類提供DSL的支持瘤睹！

頂層的封裝（Top Level Wrapper）

這里是Kotlin中的一個頂層函數(shù)，這個函數(shù)將會為Company對象提供DSL的唯一支持：

inline fun company(buildCompany: Company.Builder.() -> Unit): Company {
    val builder = Company.Builder()
    // Since `buildCompany` is an extension function for Company.Builder,
    // buildCompany() is called on the Company.Builder object.
    builder.buildCompany()
    return builder.build()
}

注意：這里我們使用了 內(nèi)聯(lián)函數(shù)（inline） 以避免lambda的額外開銷答倡。

因為方法中的lambda參數(shù)類型為 Company.Builder.() -> Unit 轰传，因此，該lambda中所有語句都處于Company.Builder的內(nèi)部”衿玻現(xiàn)在获茬，通過Kotlin的語法，我們可以通過調(diào)用build（）以獲得Company.Builder的實例倔既，而不是直接實例化Builder:

class KtxClient1 {
    fun buildCompany(): Company {
        return company {
            // `this` scope is the Company.Builder being built.
            addEmployee(
                Employee.Builder()
                    .setFirstName("Doug")
                    .setLastName("Sigelbaum")
                    .setIsManager(false)
                    .setManagerId("XXX")
            )
            addOffice(
                Office.Builder()
                    .setAddress("San Francisco")
                    .setCapacity(2500)
                    .setOccupancy(2400)
            )
        }
    }
}

封裝嵌套的Builder

我們現(xiàn)在可以為Company.Builder添加更多擴展函數(shù)恕曲，以避免直接實例化或?qū)mployee.Builders或Office.Builders添加到父Company.Builder。 這是一個潛在的解決方案：

inline fun Company.Builder.employee(
    buildEmployee: Employee.Builder.() -> Unit
) {
    val builder = Employee.Builder()
    builder.buildEmployee()
    addEmployee(builder)
}

inline fun Company.Builder.office(buildOffice: Office.Builder.() -> Unit) {
    val builder = Office.Builder()
    builder.buildOffice()
    addOffice(builder)
}

通過這些拓展函數(shù)渤涌，在Kotlin中的使用方式等效變成了：

class KtxClient2 {    
    fun buildCompany(): Company {
        return company {
            employee {
                setFirstName("Doug")
                setLastName("Sigelbaum")
                setIsManager(false)
                setManagerId("XXX")
            }
            office {
                setAddress("San Francisco")
                setCapacity(2500)
                setOccupancy(2400)
            }
        }
    }
}

幾乎大功告成了佩谣！ 我們已經(jīng)完成了對Builder中API的優(yōu)化，但是我們不得不面對一個新問題：

class KtxBadClient {  
    fun buildBadCompany(): Company {
        return company {
            employee {
                setFirstName("Doug")
                setLastName("Sigelbaum")
                setIsManager(false)
                setManagerId("XXX")
                employee {
                    setFirstName("Sean")
                    setLastName("Mcq")
                    setIsManager(false)
                    setManagerId("XXX")
                }
            }
            office {
                setAddress("San Francisco")
                setCapacity(2500)
                setOccupancy(2400)
            }
        }
    }
}

不幸的是实蓬，我們把一個employee的Builder嵌套進入了另外一個employee的Builder中茸俭，但是這樣仍然會通過編譯并運行！在Kotlin中安皱，類的作用范圍似乎發(fā)生了混亂调鬓，這意味著，company { … } 的lambda代碼塊中酌伊，這些嵌套的lambda代碼塊中都可以任意訪問Employee.Builder和Company.Builder中的內(nèi)容√谖眩現(xiàn)在，代碼將兩名員工（Employee）“Doug”和“Sean”添加到公司（Company）居砖，但是這兩名員工實際上并沒有直接的關(guān)系虹脯。

當作用域發(fā)生混亂時，如何修改擴展函數(shù)以避免上例所示的錯誤呢奏候？ 換句話說循集，我們該如何才能使我們的DSL類型安全？ 幸運的是鼻由，Kotlin 1.1引入了DslMarker注釋類來解決這個問題暇榴。

使用DslMarker注解保證DSL的類型安全

讓我們首先創(chuàng)建一個使用了DslMarker注解的注解類：

@DslMarker
annotation class CompanyDsl

現(xiàn)在厚棵，如果使用@CompanyDsl注釋了一些類蕉世，開發(fā)者將無法對多個接收器進行隱式地訪問蔼紧，這些接收器的類位于帶注釋的類集中。 相反狠轻，調(diào)用者只能使用最近的作用域隱式訪問接收器奸例。

DslMarker注解類，位于Kotlin的stdlib包中向楼，因此您需要添加其依賴查吊。 如果沒有的話，您可以嘗試對構(gòu)建器進行子類化湖蜕，并在Kotlin封裝好的函數(shù)中使用這些子類：

@CompanyDsl
class CompanyBuilderDsl : Company.Builder()

@CompanyDsl
class EmployeeBuilderDsl : Employee.Builder()

@CompanyDsl
class OfficeBuilderDsl : Office.Builder()

inline fun company(buildCompany: CompanyBuilderDsl.() -> Unit): Company {
    val builder = CompanyBuilderDsl()
    // Since `buildCompany` is an extension function for Company.Builder,
    // buildCompany() is called on the Company.Builder object.
    builder.buildCompany()
    return builder.build()
}

inline fun CompanyBuilderDsl.employee(
    buildEmployee: EmployeeBuilderDsl.() -> Unit
) {
    val builder = EmployeeBuilderDsl()
    builder.buildEmployee()
    addEmployee(builder)
}

inline fun CompanyBuilderDsl.office(
    buildOffice: OfficeBuilderDsl.() -> Unit
) {
    val builder = OfficeBuilderDsl()
    builder.buildOffice()
    addOffice(builder)
}

現(xiàn)在逻卖，我們重復之前錯誤的行為，會得到下面的提示：

…can’t be called in this context by implicit receiver. Use the explicit one if necessary.

完美昭抒，大功告成评也！