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

譯者說(shuō)

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

我最近在網(wǎng)上翻看了很多Kotlin對(duì)Builder模式實(shí)現(xiàn)方式的文章，說(shuō)實(shí)話，個(gè)人感覺(jué)都不是很好，當(dāng)我閱讀到這篇文章時(shí)，我認(rèn)為這是目前我 比較滿意 的實(shí)現(xiàn)方式（可能Google有加分），因此翻譯下來(lái)以供大家參考。

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

當(dāng)然，Kotlin語(yǔ)言中的命名參數(shù)在許多情況下解決了這個(gè)問(wèn)題，因?yàn)樵谡{(diào)用Kotlin的函數(shù)時(shí)，開(kāi)發(fā)者可以指定每個(gè)參數(shù)的名稱，從而減少錯(cuò)誤的發(fā)生。 但是，由于Java并沒(méi)有這樣的特性，因此Builder模式仍然是有必要的。 此外，對(duì)于可選參數(shù)的動(dòng)態(tài)設(shè)置，這種情況下也需要借助于Builder模式。

讓我們思考一下通過(guò)Java實(shí)現(xiàn)的一個(gè)簡(jiǎn)單的Builder模式案例。 我們首先有一個(gè)POJO Company類，它包含幾個(gè)屬性，也許這種情況足以使用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;
        }
    }
}

來(lái)看看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)建一個(gè)包含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中，我們會(huì)這樣去實(shí)現(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中實(shí)現(xiàn)Lambda參數(shù)的方法封裝

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

頂層的封裝（Top Level Wrapper）

這里是Kotlin中的一個(gè)頂層函數(shù)，這個(gè)函數(shù)將會(huì)為Company對(duì)象提供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的額外開(kāi)銷。

因?yàn)榉椒ㄖ械膌ambda參數(shù)類型為 Company.Builder.() -> Unit ，因此，該lambda中所有語(yǔ)句都處于Company.Builder的內(nèi)部?，F(xiàn)在，通過(guò)Kotlin的語(yǔ)法，我們可以通過(guò)調(diào)用build（）以獲得Company.Builder的實(shí)例，而不是直接實(shí)例化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添加更多擴(kuò)展函數(shù)，以避免直接實(shí)例化或?qū)mployee.Builders或Office.Builders添加到父Company.Builder。 這是一個(gè)潛在的解決方案：

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)
}

通過(guò)這些拓展函數(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)完成了對(duì)Builder中API的優(yōu)化，但是我們不得不面對(duì)一個(gè)新問(wèn)題：

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)
            }
        }
    }
}

不幸的是，我們把一個(gè)employee的Builder嵌套進(jìn)入了另外一個(gè)employee的Builder中，但是這樣仍然會(huì)通過(guò)編譯并運(yùn)行！在Kotlin中，類的作用范圍似乎發(fā)生了混亂，這意味著，company { … } 的lambda代碼塊中，這些嵌套的lambda代碼塊中都可以任意訪問(wèn)Employee.Builder和Company.Builder中的內(nèi)容?，F(xiàn)在，代碼將兩名員工（Employee）“Doug”和“Sean”添加到公司（Company），但是這兩名員工實(shí)際上并沒(méi)有直接的關(guān)系。

當(dāng)作用域發(fā)生混亂時(shí)，如何修改擴(kuò)展函數(shù)以避免上例所示的錯(cuò)誤呢？ 換句話說(shuō)，我們?cè)撊绾尾拍苁刮覀兊腄SL類型安全？ 幸運(yùn)的是，Kotlin 1.1引入了DslMarker注釋類來(lái)解決這個(gè)問(wèn)題。

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

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

@DslMarker
annotation class CompanyDsl

現(xiàn)在，如果使用@CompanyDsl注釋了一些類，開(kāi)發(fā)者將無(wú)法對(duì)多個(gè)接收器進(jìn)行隱式地訪問(wèn)，這些接收器的類位于帶注釋的類集中。 相反，調(diào)用者只能使用最近的作用域隱式訪問(wèn)接收器。

DslMarker注解類，位于Kotlin的stdlib包中，因此您需要添加其依賴。 如果沒(méi)有的話，您可以嘗試對(duì)構(gòu)建器進(jìn)行子類化，并在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)在，我們重復(fù)之前錯(cuò)誤的行為，會(huì)得到下面的提示：

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

完美，大功告成！