Kotlin'de Builder kalıbı nasıl uygulanır?

Merhaba ben Kotlin dünyasında bir acemi. Şimdiye kadar gördüklerimi beğendim ve uygulamamızda kullandığımız bazı kütüphanelerimizi Java'dan Kotlin'e dönüştürmeyi düşünmeye başladım.

Bu kütüphaneler, setterler, alıcılar ve Builder sınıflarıyla Pojos ile doludur. Şimdi Kotlin'de Builders'ı uygulamanın en iyi yolunu bulmaya çalıştım, ancak başarı elde etmedim.

2. Güncelleme: Soru, Kotlin'de bazı parametrelerle basit bir pojo için bir Builder tasarım deseni nasıl yazılır? Aşağıdaki kod, java kodu yazıp Kotlin'e dönüştürmek için eclipse-kotlin-eklentisini kullanarak denemem.

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

Her şeyden önce, çoğu durumda Kotlin'de inşaatçılar kullanmanıza gerek yoktur, çünkü varsayılan ve adlandırılmış argümanlarımız var. Bu yazmanıza olanak tanır

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

ve şu şekilde kullanın:

val car = Car(model = "X")

Kesinlikle inşaatçıları kullanmak istiyorsanız, bunu nasıl yapabileceğiniz aşağıda açıklanmıştır:

Builder'ı companion objectyapmak mantıklı değil çünkü objects tekton. Bunun yerine bunu iç içe bir sınıf olarak bildirir (Kotlin'de varsayılan olarak statiktir).

Nesnenin normal şekilde somutlaştırılabilmesi için yapıcıya özellikleri taşıyın (yapmaması gerekiyorsa yapıcıyı özel yapın) ve bir yapıcı ve delegeleri birincil kurucuya götüren ikincil bir kurucu kullanın. Kod aşağıdaki gibi görünecektir:

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

Kullanımı: val car = Car.Builder().model("X").build()

Bu kod, bir oluşturucu DSL kullanılarak ek olarak kısaltılabilir :

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

Kullanımı: val car = Car.build { model = "X" }

Bazı değerler gerekliyse ve varsayılan değerlere sahip değilseniz, bunları oluşturucunun yapıcısına ve ayrıca buildaz önce tanımladığımız yönteme koymanız gerekir :

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

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

Bir yaklaşım aşağıdaki gibi bir şey yapmaktır:

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

Kullanım örneği:

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

JSON'dan nesneleri ayrıştırmak için Jackson kütüphanesini kullandığım için boş bir yapıcıya ihtiyacım var ve isteğe bağlı alanlara sahip olamam. Ayrıca tüm alanlar değiştirilebilir olmalıdır. Sonra Builder desen ile aynı şeyi yapan bu güzel sözdizimini kullanabilirsiniz:

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

Şahsen Kotlin'de hiç bir inşaatçı görmedim, ama belki sadece benim.

İhtiyaç duyulan tüm doğrulama initblokta gerçekleşir:

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

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

Burada gerçekten istemediğini tahmin etmek için bir özgürlük aldım model ve yeardeğiştirilebilir olmak . Ayrıca bu varsayılan değerlerin hiçbir anlamı yok gibi görünüyor (özellikle nulliçin name) ama gösteri amaçlı bir tane bıraktım.

Bir Fikir: Java'da adlandırılmış parametreler olmadan yaşamak için kullanılan oluşturucu deseni. İsimlendirilmiş parametrelere sahip dillerde (Kotlin veya Python gibi), uzun (belki isteğe bağlı) parametre listelerine sahip yapıcılara sahip olmak iyi bir uygulamadır.

Yapımcı olarak ekstra eğlenceler ilan eden birçok örnek gördüm. Ben şahsen bu yaklaşımı seviyorum. İnşaatçılar yazmak için çabadan tasarruf edin.

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

    }
}

İstisnalar atmak yerine hataları göstermek gibi bazı alanları DSL'de başlatılmaya zorlayabilecek bir yol bulamadım. Kimse biliyorsa bana bildirin.

Basit bir sınıf için ayrı bir kurucuya ihtiyacınız yoktur. Kirill Rakhman'ın açıkladığı gibi isteğe bağlı yapıcı argümanlarından yararlanabilirsiniz.

Daha karmaşık bir sınıfınız varsa Kotlin, Groovy tarzı Builders / DSL oluşturmanın bir yolunu sunar:

Güvenli Tip Oluşturucular

İşte bir örnek:

Github Örneği - Yapıcı / Birleştirici

Günümüzde insanlar Kotlin'in Tip-Güvenli İnşaatçılarını kontrol etmelidir .

Bahsedilen nesne oluşturma yöntemini kullanmak şöyle görünecektir:

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

Güzel bir 'eylem halinde' kullanım örneği, görünümleri ve bileşenleri birleştirmek için tipik güvenlik oluşturucuları kullanan vaadin-on-kotlin çerçevesi .

Partiye geç kaldım. Projede Builder desenini kullanmak zorunda kalsaydım aynı ikilemle de karşılaştım. Daha sonra, araştırmadan sonra Kotlin'in adlandırılmış argümanları ve varsayılan argümanları sağladığından kesinlikle gereksiz olduğunu fark ettim.

Gerçekten uygulamanız gerekiyorsa, Kirill Rakhman'ın cevabı en etkili şekilde nasıl uygulanacağına dair sağlam bir cevaptır. Yararlı bulabileceğiniz başka bir şey , uygulamalarında Java ve Kotlin ile karşılaştırabileceğiniz ve tezat oluşturabileceğiniz https://www.baeldung.com/kotlin-builder-pattern.

Desen ve uygulamanın Kotlin'de hemen hemen aynı kaldığını söyleyebilirim. Varsayılan değerler sayesinde bazen atlayabilirsiniz, ancak daha karmaşık nesne oluşturmak için oluşturucular hala atlanamayan kullanışlı bir araçtır.

kotlin örneğinde isteğe bağlı parametre kullanabilirsiniz:

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

sonra

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

    }

}

Kotlin'de aşağıdaki kodla temel bir Builder kalıbı uyguladım:

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

Ve sonunda

Java:

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

Kotlin:

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

Java istemcileri tarafından tüketilen bir API'yi (Kotlin dil yapılarından yararlanamayan) ortaya çıkaran bir Kotlin projesi üzerinde çalışıyordum. Bir @Builder ek açıklama yarattı yüzden onları Java kullanılabilir hale getirmek inşaatçılar eklemek zorunda: https://github.com/ThinkingLogic/kotlin-builder-annotation - temelde KOTLIN için Lombok @Builder açıklama için bir yedek var.