Comment implémenter le modèle Builder dans Kotlin?

Salut, je suis un débutant dans le monde Kotlin. J'aime ce que je vois jusqu'à présent et j'ai commencé à penser à convertir certaines de nos bibliothèques que nous utilisons dans notre application de Java à Kotlin.

Ces bibliothèques regorgent de Pojos avec des setters, des getters et des classes Builder. Maintenant, j'ai cherché sur Google quel est le meilleur moyen d'implémenter Builders dans Kotlin, mais sans succès.

2ème mise à jour: La question est de savoir comment écrire un design-pattern Builder pour un simple pojo avec quelques paramètres dans Kotlin? Le code ci-dessous est ma tentative en écrivant du code java, puis en utilisant le plugin eclipse-kotlin-plugin pour convertir en 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
        }
    }
}

Tout d'abord, dans la plupart des cas, vous n'avez pas besoin d'utiliser des générateurs dans Kotlin car nous avons des arguments par défaut et nommés. Cela vous permet d'écrire

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

et utilisez-le comme ceci:

val car = Car(model = "X")

Si vous voulez absolument utiliser des builders, voici comment vous pouvez le faire:

Faire du Builder un companion objectn'a pas de sens car les objects sont des singletons. Déclarez-la plutôt comme une classe imbriquée (qui est statique par défaut dans Kotlin).

Déplacez les propriétés vers le constructeur afin que l'objet puisse également être instancié de la manière habituelle (rendez le constructeur privé s'il ne le devrait pas) et utilisez un constructeur secondaire qui prend un générateur et délègue au constructeur principal. Le code ressemblera à ceci:

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

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

Ce code peut être raccourci en outre en utilisant un DSL de constructeur :

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

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

Si certaines valeurs sont requises et n'ont pas de valeurs par défaut, vous devez les mettre dans le constructeur du constructeur et également dans la buildméthode que nous venons de définir:

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

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

Une approche consiste à faire quelque chose comme ce qui suit:

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

Exemple d'utilisation:

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

Comme j'utilise la bibliothèque Jackson pour analyser des objets à partir de JSON, j'ai besoin d'un constructeur vide et je ne peux pas avoir de champs facultatifs. Tous les champs doivent également être modifiables. Ensuite, je peux utiliser cette belle syntaxe qui fait la même chose que le modèle Builder:

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

Personnellement, je n'ai jamais vu de constructeur à Kotlin, mais c'est peut-être juste moi.

Toutes les validations dont on a besoin se produisent dans le initbloc:

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

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

Ici, je me suis permis de deviner que vous ne vouliez pas vraiment modelet yeard'être changeant. De plus, ces valeurs par défaut semblent n'avoir aucun sens, (surtout nullpour name) mais j'en ai laissé une à des fins de démonstration.

Une opinion: Le modèle de constructeur utilisé en Java pour vivre sans paramètres nommés. Dans les langages avec des paramètres nommés (comme Kotlin ou Python), il est recommandé d'avoir des constructeurs avec de longues listes de paramètres (peut-être facultatifs).

J'ai vu de nombreux exemples qui déclarent des amusements supplémentaires en tant que constructeurs. J'aime personnellement cette approche. Économisez des efforts pour écrire des générateurs.

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

    }
}

Je n'ai pas encore trouvé de moyen de forcer l'initialisation de certains champs dans DSL, comme afficher des erreurs au lieu de lancer des exceptions. Faites-moi savoir si quelqu'un sait.

Pour une classe simple, vous n'avez pas besoin d'un générateur distinct. Vous pouvez utiliser des arguments de constructeur optionnels comme l'a décrit Kirill Rakhman.

Si vous avez une classe plus complexe, Kotlin fournit un moyen de créer des Builders / DSL de style Groovy:

Constructeurs de type sécurisé

Voici un exemple:

Exemple Github - Générateur / Assembleur

Les gens de nos jours devraient vérifier les constructeurs de type Safe de Kotlin .

L'utilisation de cette méthode de création d'objet ressemblera à ceci:

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

Un bon exemple d'utilisation «en action» est le framework vaadin-on-kotlin , qui utilise des constructeurs sécurisés pour assembler des vues et des composants .

Je suis en retard à la fête. J'ai également rencontré le même dilemme si je devais utiliser le modèle Builder dans le projet. Plus tard, après des recherches, j'ai réalisé que c'était absolument inutile puisque Kotlin fournit déjà les arguments nommés et les arguments par défaut.

Si vous avez vraiment besoin de mettre en œuvre, la réponse de Kirill Rakhman est une réponse solide sur la façon de mettre en œuvre de la manière la plus efficace. Une autre chose que vous pouvez trouver utile est https://www.baeldung.com/kotlin-builder-pattern que vous pouvez comparer et contraster avec Java et Kotlin sur leur implémentation

Je dirais que le modèle et la mise en œuvre restent à peu près les mêmes dans Kotlin. Vous pouvez parfois l'ignorer grâce aux valeurs par défaut, mais pour la création d'objets plus compliqués, les constructeurs sont toujours un outil utile qui ne peut pas être omis.

vous pouvez utiliser le paramètre facultatif dans l'exemple kotlin:

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

puis

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

    }

}

J'ai implémenté un modèle Builder de base dans Kotlin avec le code suivant:

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

et enfin

Java:

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

Kotlin:

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

Je travaillais sur un projet Kotlin qui exposait une API consommée par les clients Java (qui ne peuvent pas tirer parti des constructions du langage Kotlin). Nous avons dû ajouter des générateurs pour les rendre utilisables en Java, j'ai donc créé une annotation @Builder: https://github.com/ThinkingLogic/kotlin-builder-annotation - c'est essentiellement un remplacement de l'annotation Lombok @Builder pour Kotlin.