Bagaimana cara menerapkan pola Builder di Kotlin?

Hai, saya seorang pemula di dunia Kotlin. Saya suka apa yang saya lihat sejauh ini dan mulai berpikir untuk mengubah beberapa perpustakaan kami yang kami gunakan dalam aplikasi kami dari Jawa ke Kotlin.

Perpustakaan ini penuh dengan Pojo dengan setter, getter dan kelas Builder. Sekarang saya telah mencari di Google apa cara terbaik untuk mengimplementasikan Builder di Kotlin tetapi tidak berhasil.

Pembaruan ke-2: Pertanyaannya adalah bagaimana menulis pola desain Builder untuk pojo sederhana dengan beberapa parameter di Kotlin? Kode di bawah ini adalah usaha saya dengan menulis kode java dan kemudian menggunakan eclipse-kotlin-plugin untuk mengkonversi ke Kotlin.

class Car private constructor(builder:Car.Builder) {
    var model:String? = null
    var year:Int = 0
    init {
        this.model = builder.model
        this.year = builder.year
    }
    companion object Builder {
        var model:String? = null
        private set

        var year:Int = 0
        private set

        fun model(model:String):Builder {
            this.model = model
            return this
        }
        fun year(year:Int):Builder {
            this.year = year
            return this
        }
        fun build():Car {
            val car = Car(this)
            return car
        }
    }
}

Pertama dan terutama, dalam banyak kasus Anda tidak perlu menggunakan pembangun di Kotlin karena kami memiliki argumen default dan bernama. Ini memungkinkan Anda untuk menulis

class Car(val model: String? = null, val year: Int = 0)

dan gunakan seperti ini:

val car = Car(model = "X")

Jika Anda benar-benar ingin menggunakan pembuat, berikut ini cara melakukannya:

Membuat Builder menjadi companion objecttidak masuk akal karena objects adalah lajang. Alih-alih mendeklarasikannya sebagai kelas bersarang (yang statis secara default di Kotlin).

Pindahkan properti ke konstruktor sehingga objek juga dapat dipakai dengan cara biasa (jadikan konstruktor sebagai pribadi jika tidak seharusnya) dan gunakan konstruktor sekunder yang mengambil pembangun dan mendelegasikannya ke konstruktor utama. Kode akan terlihat sebagai berikut:

class Car( //add private constructor if necessary
        val model: String?,
        val year: Int
) {

    private constructor(builder: Builder) : this(builder.model, builder.year)

    class Builder {
        var model: String? = null
            private set

        var year: Int = 0
            private set

        fun model(model: String) = apply { this.model = model }

        fun year(year: Int) = apply { this.year = year }

        fun build() = Car(this)
    }
}

Pemakaian: val car = Car.Builder().model("X").build()

Kode ini juga dapat dipersingkat dengan menggunakan DSL pembangun :

class Car (
        val model: String?,
        val year: Int
) {

    private constructor(builder: Builder) : this(builder.model, builder.year)

    companion object {
        inline fun build(block: Builder.() -> Unit) = Builder().apply(block).build()
    }

    class Builder {
        var model: String? = null
        var year: Int = 0

        fun build() = Car(this)
    }
}

Pemakaian: val car = Car.build { model = "X" }

Jika beberapa nilai diperlukan dan tidak memiliki nilai default, Anda harus meletakkannya di konstruktor pembangun dan juga dalam buildmetode yang baru saja kita tetapkan:

class Car (
        val model: String?,
        val year: Int,
        val required: String
) {

    private constructor(builder: Builder) : this(builder.model, builder.year, builder.required)

    companion object {
        inline fun build(required: String, block: Builder.() -> Unit) = Builder(required).apply(block).build()
    }

    class Builder(
            val required: String
    ) {
        var model: String? = null
        var year: Int = 0

        fun build() = Car(this)
    }
}

Pemakaian: val car = Car.build(required = "requiredValue") { model = "X" }

Salah satu pendekatan adalah melakukan sesuatu seperti berikut:

class Car(
  val model: String?,
  val color: String?,
  val type: String?) {

    data class Builder(
      var model: String? = null,
      var color: String? = null,
      var type: String? = null) {

        fun model(model: String) = apply { this.model = model }
        fun color(color: String) = apply { this.color = color }
        fun type(type: String) = apply { this.type = type }
        fun build() = Car(model, color, type)
    }
}

Sampel penggunaan:

val car = Car.Builder()
  .model("Ford Focus")
  .color("Black")
  .type("Type")
  .build()

Karena saya menggunakan perpustakaan Jackson untuk mem-parsing objek dari JSON, saya harus memiliki konstruktor kosong dan saya tidak bisa memiliki bidang opsional. Juga semua bidang harus bisa berubah. Maka saya bisa menggunakan sintaks yang bagus ini yang melakukan hal yang sama dengan pola Builder:

val car = Car().apply{ model = "Ford"; year = 2000 }

Saya pribadi belum pernah melihat tukang bangunan di Kotlin, tapi mungkin hanya saya.

Semua validasi yang dibutuhkan terjadi di initblok:

class Car(val model: String,
          val year: Int = 2000) {

    init {
        if(year < 1900) throw Exception("...")
    }
}

Di sini saya mengambil kebebasan untuk menebak bahwa Anda tidak benar-benar ingin modeldan yeardapat berubah. Juga nilai-nilai default itu tampaknya tidak masuk akal, (terutama nulluntuk name) tetapi saya meninggalkannya untuk tujuan demonstrasi.

Opini: Pola pembangun yang digunakan di Jawa sebagai sarana untuk hidup tanpa parameter bernama. Dalam bahasa dengan parameter bernama (seperti Kotlin atau Python) adalah praktik yang baik untuk memiliki konstruktor dengan daftar panjang (mungkin opsional) parameter.

Saya telah melihat banyak contoh yang menyatakan kesenangan ekstra sebagai pembangun. Saya pribadi menyukai pendekatan ini. Simpan upaya untuk menulis pembangun.

package android.zeroarst.lab.koltinlab

import kotlin.properties.Delegates

class Lab {
    companion object {
        @JvmStatic fun main(args: Array<String>) {

            val roy = Person {
                name = "Roy"
                age = 33
                height = 173
                single = true
                car {
                    brand = "Tesla"
                    model = "Model X"
                    year = 2017
                }
                car {
                    brand = "Tesla"
                    model = "Model S"
                    year = 2018
                }
            }

            println(roy)
        }

        class Person() {
            constructor(init: Person.() -> Unit) : this() {
                this.init()
            }

            var name: String by Delegates.notNull()
            var age: Int by Delegates.notNull()
            var height: Int by Delegates.notNull()
            var single: Boolean by Delegates.notNull()
            val cars: MutableList<Car> by lazy { arrayListOf<Car>() }

            override fun toString(): String {
                return "name=$name, age=$age, " +
                        "height=$height, " +
                        "single=${when (single) {
                            true -> "looking for a girl friend T___T"
                            false -> "Happy!!"
                        }}\nCars: $cars"
            }
        }

        class Car() {

            var brand: String by Delegates.notNull()
            var model: String by Delegates.notNull()
            var year: Int by Delegates.notNull()

            override fun toString(): String {
                return "(brand=$brand, model=$model, year=$year)"
            }
        }

        fun Person.car(init: Car.() -> Unit): Unit {
            cars.add(Car().apply(init))
        }

    }
}

Saya belum menemukan cara yang dapat memaksa beberapa bidang diinisialisasi dalam DSL seperti menunjukkan kesalahan alih-alih melempar pengecualian. Beri tahu saya jika ada yang tahu.

Untuk kelas sederhana Anda tidak perlu pembangun yang terpisah. Anda dapat menggunakan argumen konstruktor opsional seperti yang dijelaskan Kirill Rakhman.

Jika Anda memiliki kelas yang lebih kompleks maka Kotlin menyediakan cara untuk membuat Builder / DSL gaya Groovy:

Pembangun Tipe-Aman

Berikut ini sebuah contoh:

Contoh Github - Builder / Assembler

Orang saat ini harus memeriksa Pembangun Jenis-Aman Kotlin .

Menggunakan cara pembuatan objek tersebut akan terlihat seperti ini:

html {
    head {
        title {+"XML encoding with Kotlin"}
    }
    // ...
}

Contoh penggunaan 'dalam aksi' yang bagus adalah kerangka kerja vaadin-on-kotlin , yang menggunakan pembangun typesafe untuk mengumpulkan pandangan dan komponen .

Saya terlambat ke pesta. Saya juga mengalami dilema yang sama jika saya harus menggunakan pola Builder dalam proyek tersebut. Kemudian, setelah penelitian saya menyadari itu sama sekali tidak perlu karena Kotlin sudah memberikan argumen bernama dan argumen default.

Jika Anda benar-benar perlu menerapkan, jawaban Kirill Rakhman adalah jawaban yang solid tentang cara menerapkan dengan cara yang paling efektif. Hal lain yang mungkin bermanfaat bagi Anda adalah https://www.baeldung.com/kotlin-builder-pattern yang dapat Anda bandingkan dan kontras dengan Java dan Kotlin dalam penerapannya

Saya akan mengatakan pola dan implementasinya tetap sama di Kotlin. Anda kadang-kadang dapat melewatinya berkat nilai default, tetapi untuk pembuatan objek yang lebih rumit, pembangun masih merupakan alat yang berguna yang tidak dapat dihilangkan.

Anda dapat menggunakan parameter opsional di kotlin contoh:

fun myFunc(p1: String, p2: Int = -1, p3: Long = -1, p4: String = "default") {
    System.out.printf("parameter %s %d %d %s\n", p1, p2, p3, p4)
}

kemudian

myFunc("a")
myFunc("a", 1)
myFunc("a", 1, 2)
myFunc("a", 1, 2, "b")

class Foo private constructor(@DrawableRes requiredImageRes: Int, optionalTitle: String?) {

    @DrawableRes
    @get:DrawableRes
    val requiredImageRes: Int

    val optionalTitle: String?

    init {
        this.requiredImageRes = requiredImageRes
        this.requiredImageRes = optionalTitle
    }

    class Builder {

        @DrawableRes
        private var requiredImageRes: Int = -1

        private var optionalTitle: String? = null

        fun requiredImageRes(@DrawableRes imageRes: Int): Builder {
            this.intent = intent
            return this
        } 

        fun optionalTitle(title: String): Builder {
            this.optionalTitle = title
            return this
        }

        fun build(): Foo {
            if(requiredImageRes == -1) {
                throw IllegalStateException("No image res provided")
            }
            return Foo(this.requiredImageRes, this.optionalTitle)
        }

    }

}

Saya menerapkan pola dasar Builder di Kotlin dengan kode berikut:

data class DialogMessage(
        var title: String = "",
        var message: String = ""
) {


    class Builder( context: Context){


        private var context: Context = context
        private var title: String = ""
        private var message: String = ""

        fun title( title : String) = apply { this.title = title }

        fun message( message : String ) = apply { this.message = message  }    

        fun build() = KeyoDialogMessage(
                title,
                message
        )

    }

    private lateinit var  dialog : Dialog

    fun show(){
        this.dialog= Dialog(context)
        .
        .
        .
        dialog.show()

    }

    fun hide(){
        if( this.dialog != null){
            this.dialog.dismiss()
        }
    }
}

Dan akhirnya

Jawa:

new DialogMessage.Builder( context )
       .title("Title")
       .message("Message")
       .build()
       .show();

Kotlin:

DialogMessage.Builder( context )
       .title("Title")
       .message("")
       .build()
       .show()

Saya sedang mengerjakan proyek Kotlin yang mengekspos API yang dikonsumsi oleh klien Java (yang tidak bisa mengambil keuntungan dari konstruksi bahasa Kotlin). Kami harus menambahkan pembangun agar dapat digunakan di Jawa, jadi saya membuat anotasi @Builder: https://github.com/ThinkingLogic/kotlin-builder-annotation - ini pada dasarnya merupakan pengganti anotasi Lombok @Builder untuk Kotlin.