Como implementar o padrão Builder no Kotlin?

Oi eu sou um novato no mundo Kotlin. Gosto do que vejo até agora e comecei a pensar em converter algumas de nossas bibliotecas que usamos em nosso aplicativo de Java para Kotlin.

Essas bibliotecas estão cheias de Pojos com setters, getters e classes Builder. Agora, pesquisei no Google qual a melhor maneira de implementar os Builders no Kotlin, mas sem sucesso.

2ª Atualização: A questão é como escrever um padrão de design do Builder para um simples pojo com alguns parâmetros no Kotlin? O código abaixo é minha tentativa de escrever código java e, em seguida, usar o eclipse-kotlin-plugin para converter em 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
        }
    }
}

Em primeiro lugar, na maioria dos casos, você não precisa usar construtores no Kotlin porque temos argumentos padrão e nomeados. Isso permite que você escreva

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

e use-o assim:

val car = Car(model = "X")

Se você absolutamente deseja usar construtores, veja como você pode fazê-lo:

Tornar o Builder um companion objectnão faz sentido porque objects são singletons. Em vez disso, declare-a como uma classe aninhada (que é estática por padrão no Kotlin).

Mova as propriedades para o construtor para que o objeto também possa ser instanciado da maneira regular (torne o construtor privado, se não for o caso) e use um construtor secundário que leve um construtor e delegue para o construtor principal. O código terá a seguinte aparência:

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

Esse código pode ser reduzido adicionalmente usando uma DSL do construtor :

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 alguns valores forem necessários e não tiverem valores padrão, você precisará colocá-los no construtor do construtor e também no buildmétodo que acabamos de definir:

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

Uma abordagem é fazer algo como o seguinte:

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

Amostra de uso:

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

Como estou usando a biblioteca Jackson para analisar objetos do JSON, preciso ter um construtor vazio e não posso ter campos opcionais. Todos os campos também precisam ser mutáveis. Então eu posso usar essa sintaxe agradável, que faz a mesma coisa que o padrão Builder:

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

Eu pessoalmente nunca vi um construtor em Kotlin, mas talvez seja apenas eu.

Toda a validação necessária é realizada no initbloco:

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

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

Aqui, tomei a liberdade de adivinhar que você realmente não queria modele yearser mutável. Além disso, esses valores padrão parecem não ter sentido (principalmente nullpara name), mas deixei um para fins de demonstração.

Uma Opinião: O padrão do construtor usado em Java como um meio de viver sem parâmetros nomeados. Em linguagens com parâmetros nomeados (como Kotlin ou Python), é uma boa prática ter construtores com longas listas de parâmetros (talvez opcionais).

Eu já vi muitos exemplos que declaram divertimentos extras como construtores. Eu pessoalmente gosto dessa abordagem. Economize esforço para escrever construtores.

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

    }
}

Ainda não encontrei uma maneira que possa forçar a inicialização de alguns campos no DSL, como mostrar erros em vez de gerar exceções. Deixe-me saber se alguém souber.

Para uma classe simples, você não precisa de um construtor separado. Você pode usar argumentos opcionais do construtor, como Kirill Rakhman descreveu.

Se você possui uma classe mais complexa, o Kotlin fornece uma maneira de criar Builders / DSL no estilo Groovy:

Construtores com segurança de tipo

Aqui está um exemplo:

Exemplo do Github - Construtor / Montador

Hoje em dia, as pessoas devem verificar os construtores seguros para tipos da Kotlin .

O uso dessa maneira de criação de objetos será algo como isto:

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

Um bom exemplo de uso em ação é a estrutura vaadin-on-kotlin , que utiliza construtores typesafe para montar visões e componentes .

Estou atrasado para a festa. Eu também encontrei o mesmo dilema se tivesse que usar o padrão Builder no projeto. Mais tarde, depois da pesquisa, percebi que é absolutamente desnecessário, pois o Kotlin já fornece os argumentos nomeados e os argumentos padrão.

Se você realmente precisa implementar, a resposta de Kirill Rakhman é uma resposta sólida sobre como implementar da maneira mais eficaz. Outra coisa que você pode achar útil é que, em https://www.baeldung.com/kotlin-builder-pattern, você pode comparar e contrastar com Java e Kotlin em sua implementação

Eu diria que o padrão e a implementação permanecem praticamente os mesmos no Kotlin. Às vezes, você pode ignorá-lo graças aos valores padrão, mas, para criar objetos mais complicados, os construtores ainda são uma ferramenta útil que não pode ser omitida.

você pode usar o parâmetro opcional no exemplo do 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)
}

então

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

    }

}

Implementei um padrão básico do Builder no Kotlin com o seguinte código:

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 finalmente

Java:

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

Kotlin:

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

Eu estava trabalhando em um projeto Kotlin que expôs uma API consumida por clientes Java (que não pode tirar proveito das construções da linguagem Kotlin). Tivemos que adicionar construtores para torná-los utilizáveis ​​em Java, então criei uma anotação do @Builder: https://github.com/ThinkingLogic/kotlin-builder-annotation - é basicamente um substituto para a anotação do Lombok @Builder para o Kotlin.