Wie implementiere ich ein Builder-Muster in Kotlin?

Hallo, ich bin ein Neuling in der Kotlin-Welt. Mir gefällt, was ich bisher gesehen habe, und ich habe darüber nachgedacht, einige unserer Bibliotheken, die wir in unserer Anwendung verwenden, von Java nach Kotlin zu konvertieren.

Diese Bibliotheken sind voll von Pojos mit Setter-, Getter- und Builder-Klassen. Jetzt habe ich gegoogelt, um herauszufinden, wie Builder in Kotlin am besten implementiert werden können, aber ohne Erfolg.

2. Update: Die Frage ist, wie man ein Builder-Entwurfsmuster für ein einfaches Pojo mit einigen Parametern in Kotlin schreibt. Der folgende Code ist mein Versuch, Java-Code zu schreiben und dann das Eclipse-Kotlin-Plugin zu verwenden, um nach Kotlin zu konvertieren.

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

In erster Linie müssen Sie in Kotlin in den meisten Fällen keine Builder verwenden, da wir Standardargumente und benannte Argumente haben. Dadurch können Sie schreiben

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

und benutze es so:

val car = Car(model = "X")

Wenn Sie unbedingt Builder verwenden möchten, gehen Sie wie folgt vor:

Den Builder zu einem zu machen, companion objectmacht keinen Sinn, weil objects Singletons sind. Deklarieren Sie es stattdessen als verschachtelte Klasse (die in Kotlin standardmäßig statisch ist).

Verschieben Sie die Eigenschaften in den Konstruktor, damit das Objekt auch auf normale Weise instanziiert werden kann (machen Sie den Konstruktor privat, falls dies nicht der Fall sein sollte), und verwenden Sie einen sekundären Konstruktor, der einen Builder übernimmt und an den primären Konstruktor delegiert. Der Code sieht wie folgt aus:

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

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

Dieser Code kann mithilfe eines Builder-DSL zusätzlich gekürzt werden :

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

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

Wenn einige Werte erforderlich sind und keine Standardwerte haben, müssen Sie sie in den Konstruktor des Builders und auch in die buildgerade definierte Methode einfügen:

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

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

Ein Ansatz besteht darin, Folgendes zu tun:

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

Anwendungsbeispiel:

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

Da ich die Jackson-Bibliothek zum Parsen von Objekten aus JSON verwende, benötige ich einen leeren Konstruktor und kann keine optionalen Felder haben. Auch müssen alle Felder veränderbar sein. Dann kann ich diese nette Syntax verwenden, die dasselbe tut wie das Builder-Muster:

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

Ich persönlich habe noch nie einen Baumeister in Kotlin gesehen, aber vielleicht bin es nur ich.

Alle Validierungen, die benötigt werden, erfolgen im initBlock:

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

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

Hier habe ich mir erlaubt zu erraten, dass du nicht wirklich wolltest modelund yearveränderlich sein willst . Auch diese Standardwerte scheinen keinen Sinn zu haben (besonders nullfür name), aber ich habe einen zu Demonstrationszwecken hinterlassen.

Eine Meinung: Das Builder-Muster, das in Java verwendet wird, um ohne benannte Parameter zu leben. In Sprachen mit benannten Parametern (wie Kotlin oder Python) empfiehlt es sich, Konstruktoren mit langen Listen von (möglicherweise optionalen) Parametern zu haben.

Ich habe viele Beispiele gesehen, die als Bauherren zusätzlichen Spaß erklären. Ich persönlich mag diesen Ansatz. Sparen Sie Aufwand beim Schreiben von Buildern.

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

    }
}

Ich habe noch keinen Weg gefunden, der die Initialisierung einiger Felder in DSL erzwingen kann, z. B. das Anzeigen von Fehlern, anstatt Ausnahmen auszulösen. Lassen Sie mich wissen, wenn jemand weiß.

Für eine einfache Klasse benötigen Sie keinen separaten Builder. Sie können optionale Konstruktorargumente verwenden, wie von Kirill Rakhman beschrieben.

Wenn Sie eine komplexere Klasse haben, bietet Kotlin eine Möglichkeit, Builder / DSL im Groovy-Stil zu erstellen:

Typensichere Builder

Hier ist ein Beispiel:

Github-Beispiel - Builder / Assembler

Menschen nowdays sollte Kotlin Check Typ-Safe - Builders .

Die Verwendung dieser Art der Objekterstellung sieht ungefähr so ​​aus:

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

Ein schönes Anwendungsbeispiel in Aktion ist das Vaadin-on-Kotlin- Framework, das typsichere Builder zum Zusammenstellen von Ansichten und Komponenten verwendet .

Ich bin zu spät zur Party. Das gleiche Dilemma hatte ich auch, wenn ich im Projekt das Builder-Muster verwenden musste. Später, nach Recherchen, habe ich festgestellt, dass dies absolut unnötig ist, da Kotlin bereits die genannten Argumente und Standardargumente bereitstellt.

Wenn Sie wirklich implementieren müssen, ist Kirill Rakhmans Antwort eine solide Antwort darauf, wie Sie am effektivsten implementieren können. Eine andere Sache, die Sie vielleicht nützlich finden, ist https://www.baeldung.com/kotlin-builder-pattern, die Sie bei ihrer Implementierung mit Java und Kotlin vergleichen und gegenüberstellen können

Ich würde sagen, dass das Muster und die Implementierung in Kotlin ziemlich gleich bleiben. Sie können es manchmal dank Standardwerten überspringen, aber für eine kompliziertere Objekterstellung sind Builder immer noch ein nützliches Werkzeug, das nicht weggelassen werden kann.

Sie können optionale Parameter im Kotlin-Beispiel verwenden:

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

dann

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

    }

}

Ich habe ein grundlegendes Builder-Muster in Kotlin mit dem folgenden Code implementiert:

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

Und schlussendlich

Java:

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

Kotlin:

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

Ich habe an einem Kotlin-Projekt gearbeitet, das eine von Java-Clients verwendete API verfügbar gemacht hat (die die Kotlin-Sprachkonstrukte nicht nutzen kann). Wir mussten Builder hinzufügen, um sie in Java verwendbar zu machen. Deshalb habe ich eine @ Builder-Annotation erstellt: https://github.com/ThinkingLogic/kotlin-builder-annotation - sie ist im Grunde ein Ersatz für die Lombok @ Builder-Annotation für Kotlin.