Come implementare il modello Builder in Kotlin?

Ciao, sono un principiante nel mondo Kotlin. Mi piace quello che vedo finora e ho iniziato a pensare di convertire alcune delle nostre librerie che utilizziamo nella nostra applicazione da Java a Kotlin.

Queste librerie sono piene di Pojo con setter, getter e classi Builder. Ora ho cercato su Google di trovare qual è il modo migliore per implementare i costruttori a Kotlin, ma senza successo.

2 ° aggiornamento: la domanda è come scrivere un modello di progettazione Builder per un semplice pojo con alcuni parametri in Kotlin? Il codice qui sotto è il mio tentativo scrivendo codice java e quindi usando il plugin eclipse-kotlin per convertire in 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
        }
    }
}

Innanzitutto, nella maggior parte dei casi non è necessario utilizzare i costruttori in Kotlin perché abbiamo argomenti predefiniti e denominati. Questo ti permette di scrivere

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

e usalo così:

val car = Car(model = "X")

Se vuoi assolutamente usare i costruttori, ecco come puoi farlo:

Rendere il Builder a companion objectnon ha senso perché objects sono dei singoli. Dichiaralo invece come una classe nidificata (che è statica per impostazione predefinita in Kotlin).

Spostare le proprietà sul costruttore in modo che l'oggetto possa anche essere istanziato in modo regolare (rendere privato il costruttore se non dovrebbe) e utilizzare un costruttore secondario che porta un costruttore e delega al costruttore principale. Il codice apparirà come segue:

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

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

Questo codice può essere abbreviato ulteriormente utilizzando un DSL builder :

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

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

Se alcuni valori sono richiesti e non hanno valori predefiniti, è necessario inserirli nel costruttore del builder e anche nel buildmetodo che abbiamo appena definito:

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

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

Un approccio consiste nel fare qualcosa di simile al seguente:

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

Esempio di utilizzo:

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

Poiché sto usando la libreria Jackson per analizzare oggetti da JSON, ho bisogno di un costruttore vuoto e non posso avere campi opzionali. Inoltre, tutti i campi devono essere modificabili. Quindi posso usare questa bella sintassi che fa la stessa cosa del modello Builder:

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

Personalmente non ho mai visto un costruttore a Kotlin, ma forse sono solo io.

Tutta la convalida di cui si ha bisogno avviene nel initblocco:

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

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

Qui mi sono preso la libertà di indovinare che non volevi davvero modele yeardi essere mutevole. Anche quei valori predefiniti sembrano non avere senso, (specialmente nullper name) ma ne ho lasciato uno a scopo dimostrativo.

Un'opinione: il modello di generatore utilizzato in Java come mezzo per vivere senza parametri nominati. Nei linguaggi con parametri nominati (come Kotlin o Python) è buona norma avere costruttori con lunghe liste di parametri (forse facoltativi).

Ho visto molti esempi che dichiarano divertimenti extra come costruttori. Personalmente mi piace questo approccio. Risparmia lo sforzo di scrivere costruttori.

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

    }
}

Non ho ancora trovato un modo per forzare l'inizializzazione di alcuni campi in DSL come mostrare errori invece di generare eccezioni. Fammi sapere se qualcuno lo sa.

Per una classe semplice non è necessario un costruttore separato. Puoi usare argomenti del costruttore opzionali come descritto da Kirill Rakhman.

Se hai una classe più complessa, Kotlin offre un modo per creare Builders / DSL in stile Groovy:

Costruttori sicuri

Ecco un esempio:

Esempio di Github - Costruttore / Assemblatore

Le persone al giorno d'oggi dovrebbero controllare i costruttori sicuri di Kotlin .

L'uso di detto modo di creare oggetti sarà simile a questo:

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

Un bell'esempio di utilizzo "in azione" è il framework vaadin-on-kotlin , che utilizza i costruttori typesafe per assemblare viste e componenti .

Sono in ritardo alla festa. Ho anche incontrato lo stesso dilemma se dovessi usare il modello Builder nel progetto. Più tardi, dopo la ricerca, mi sono reso conto che non è assolutamente necessario poiché Kotlin fornisce già gli argomenti nominati e gli argomenti predefiniti.

Se hai davvero bisogno di implementare, la risposta di Kirill Rakhman è una risposta solida su come implementare nel modo più efficace. Un'altra cosa che potresti trovare utile è https://www.baeldung.com/kotlin-builder-pattern che puoi confrontare e confrontare con Java e Kotlin sulla loro implementazione

Direi che il modello e l'implementazione rimangono praticamente gli stessi in Kotlin. A volte puoi saltarlo grazie ai valori predefiniti, ma per la creazione di oggetti più complicati, i costruttori sono ancora uno strumento utile che non può essere omesso.

puoi usare un parametro opzionale nell'esempio di 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)
}

poi

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

    }

}

Ho implementato un modello Builder di base in Kotlin con il seguente codice:

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

E infine

Giava:

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

Kotlin:

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

Stavo lavorando a un progetto Kotlin che esponeva un'API consumata dai client Java (che non può sfruttare i costrutti del linguaggio Kotlin). Abbiamo dovuto aggiungere costruttori per renderli utilizzabili in Java, quindi ho creato un'annotazione @Builder: https://github.com/ThinkingLogic/kotlin-builder-annotation - è sostanzialmente un sostituto dell'annotazione Lombok @Builder per Kotlin.