Kotlin con JPA: infierno constructor predeterminado

Simplemente proporcione valores predeterminados para todos los argumentos, Kotlin hará constructor predeterminado para usted.

@Entity
data class Person(val name: String="", val age: Int=0)

Véase el recuadro NOTE debajo de la siguiente sección:

Https://kotlinlang.org/docs/reference/classes.html#secondary-constructors

@D3xter tiene una buena respuesta para un modelo, el otro es una característica más nueva en Kotlin llamada lateinit:

class Entity() {
    constructor(name: String, age: Date): this() {
        this.name = name
        this.birthdate = age
    }

    lateinit var name: String
    lateinit var birthdate: Date
}

Usaría esto cuando esté seguro de que algo completará los valores en el tiempo de construcción o muy poco después (y antes del primer uso de la instancia).

Notará que cambié age a birthdate porque no puede usar valores primitivos con lateinit y también por el momento deben ser var (la restricción podría liberarse en el futuro).

Así que no es una respuesta perfecta para la inmutabilidad, el mismo problema que la otra respuesta en ese sentido. La solución para ello son complementos para bibliotecas que pueden entender el constructor de Kotlin y asignar propiedades a los parámetros del constructor, en lugar de requerir un constructor predeterminado. El módulo Kotlin para Jackson hace esto, por lo que es claramente posible.

Véase también: https://stackoverflow.com/a/34624907/3679676 para explorar opciones similares.

@Entity data class Person(/*@Id @GeneratedValue var id: Long? = null,*/
                          var name: String? = null,
                          var age: Int? = null)

Los valores iniciales son obligatorios si desea reutilizar constructor para diferentes campos, kotlin no permite nulls. Así que cada vez que planee omitir el campo, use este formulario en constructor: var field: Type? = defaultValue

Jpa no requiere ningún argumento constructor:

val entity = Person() // Person(name=null, age=null)

No hay duplicación de código. Si necesita construir entidad y solo configurar edad, utilice este formulario:

val entity = Person(age = 33) // Person(name=null, age=33)

No hay magia (solo lea la documentación)

No hay manera de mantener la inmutabilidad como esta. Los Vals DEBEN inicializarse al construir la instancia.

Una forma de hacerlo sin inmutabilidad es:

class Entity() {
    public constructor(name: String, age: Int): this() {        
        this.name = name
        this.age = age
    }

    public var name: String by Delegates.notNull()

    public var age: Int by Delegates.notNull()
}

He estado trabajando con Kotlin + JPA durante bastante tiempo y he creado mi propia idea de cómo escribir clases de Entidad.

Solo extiendo ligeramente tu idea inicial. Como has dicho, podemos crear un constructor privado sin argumentos y proporcionar valores predeterminados para primitivas , pero cuando intentamos usar otras clases se vuelve un poco desordenado. Mi idea es crear un objeto STUB estático para la clase de entidad que escribe actualmente, por ejemplo:

@Entity
data class TestEntity(
    val name: String,
    @Id @GeneratedValue val id: Int? = null
) {
    private constructor() : this("")

    companion object {
        val STUB = TestEntity()
    }
}

Y cuando tengo clase de entidad que es relacionado con TestEntity Puedo usar fácilmente el stub que acabo de crear. Por ejemplo:

@Entity
data class RelatedEntity(
        val testEntity: TestEntity,
        @Id @GeneratedValue val id: Long? = null
) {
    private constructor() : this(TestEntity.STUB)

    companion object {
        val STUB = RelatedEntity()
    }
}

Por supuesto, esta solución no es perfecta. Todavía necesita crear algún código repetitivo que no debería ser necesario. También hay un caso que no se puede resolver bien con la relación stubbing - parent-child dentro de una clase de entidad-como esto:

@Entity
data class TestEntity(
        val testEntity: TestEntity,
        @Id @GeneratedValue val id: Long? = null
) {
    private constructor() : this(STUB)

    companion object {
        val STUB = TestEntity()
    }
}

Este código producirá NullPointerException debido a un problema de huevo de gallina-necesitamos STUB para crear STUB. Desafortunadamente necesitamos para hacer este campo nullable (o alguna solución similar) para hacer que el código funcione.

También en mi opinión tener Id como último campo (y nullable) es bastante óptimo. No deberíamos asignarlo a mano y dejar que Database lo haga por nosotros.

No estoy diciendo que esta sea la solución perfecta, pero creo que aprovecha la legibilidad del código de entidad y las características de Kotlin (por ejemplo, seguridad nula). Solo espero que las futuras versiones de JPA y / o Kotlin hagan que nuestro código sea aún más simple y agradable.

Similar a @pawelbial, he usado el objeto compañero para crear una instancia predeterminada, sin embargo, en lugar de definir un constructor secundario, simplemente use args de constructores predeterminados como @iolo. Esto le ahorra tener que definir varios constructores y mantiene el código más simple (aunque concedido, definir objetos complementarios "STUB" no es exactamente mantenerlo simple)

@Entity
data class TestEntity(
    val name: String = "",
    @Id @GeneratedValue val id: Int? = null
) {

    companion object {
        val STUB = TestEntity()
    }
}

Y luego para las clases que se refieren a TestEntity

@Entity
data class RelatedEntity(
    val testEntity: TestEntity = TestEntity:STUB,
    @Id @GeneratedValue val id: Int? = null
)

Como @ pawelbial ha mencionado, esto no funcionará donde el TestEntity clase "tiene una" TestEntity clase desde el TALÓN no se han inicializado cuando se ejecuta el constructor.

Yo mismo soy un nudo, pero parece que tienes que inicializar explícitamente y recurrir a un valor nulo como este

@Entity
class Person(val name: String? = null, val age: Int? = null)

Estas líneas de construcción de Gradle me ayudaron:
https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa/1.1.50 .
Al menos, se construye en IntelliJ. Está fallando en la línea de comandos en este momento.

Y tengo un

class LtreeType : UserType

Y

    @Column(name = "path", nullable = false, columnDefinition = "ltree")
    @Type(type = "com.tgt.unitplanning.data.LtreeType")
    var path: String

Var path: LtreeType no funcionó.