Kotlin com JPA: inferno do construtor padrão

Conforme a JPA exige, @Entity classes devem ter um construtor padrão (não arg) para instanciar os objetos ao recuperá-los do banco de dados.

No Kotlin, é muito conveniente declarar propriedades no construtor principal, como no exemplo a seguir:

class Person(val name: String, val age: Int) { /* ... */ }

Mas quando o construtor não-arg é declarado como secundário, ele exige que valores sejam passados ​​para o construtor primário, portanto, alguns valores válidos são necessários para eles, como aqui:

@Entity
class Person(val name: String, val age: Int) {
    private constructor(): this("", 0)
}

Caso as propriedades tenham um tipo mais complexo do que apenas Stringe Intnão sejam anuláveis, será totalmente ruim fornecer os valores para elas, especialmente quando houver muito código no construtor primário einit blocos principais e quando os parâmetros forem usados ​​ativamente - - quando eles serão reatribuídos por reflexão, a maior parte do código será executada novamente.

Além disso, val-properties não pode ser reatribuído após a execução do construtor, portanto a imutabilidade também é perdida.

Portanto, a pergunta é: como o código Kotlin pode ser adaptado para funcionar com o JPA sem duplicação de código, escolhendo valores iniciais "mágicos" e perda de imutabilidade?

PS É verdade que o Hibernate, além do JPA, pode construir objetos sem construtor padrão?

A partir do Kotlin 1.0.6 , o kotlin-noargplug-in do compilador gera construtores sintéticos padrão para classes que foram anotadas com anotações selecionadas.

Se você usa gradle, aplicar o kotlin-jpaplug-in é suficiente para gerar construtores padrão para as classes anotadas com @Entity:

buildscript {
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
    }
}

apply plugin: "kotlin-jpa"

Para Maven:

<plugin>
    <artifactId>kotlin-maven-plugin</artifactId>
    <groupId>org.jetbrains.kotlin</groupId>
    <version>${kotlin.version}</version>

    <configuration>
        <compilerPlugins>
            <plugin>jpa</plugin>
        </compilerPlugins>
    </configuration>

    <dependencies>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-maven-noarg</artifactId>
            <version>${kotlin.version}</version>
        </dependency>
    </dependencies>
</plugin>

Apenas forneça valores padrão para todos os argumentos, o Kotlin fará o construtor padrão para você.

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

Veja o NOTE caixa abaixo da seguinte seção:

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

O @ D3xter tem uma boa resposta para um modelo, o outro é um recurso mais recente do Kotlin chamado lateinit:

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

    lateinit var name: String
    lateinit var birthdate: Date
}

Você usaria isso quando tiver certeza de que algo preencherá os valores no momento da construção ou logo após (e antes do primeiro uso da instância).

Você notará que eu mudei agepara birthdateporque você não pode usar valores primitivos com lateinite eles também no momento devem servar (a restrição poderá ser liberada no futuro).

Portanto, não é uma resposta perfeita para a imutabilidade, o mesmo problema que a outra resposta a esse respeito. A solução é plugins para bibliotecas que podem lidar com a compreensão do construtor Kotlin e mapear propriedades para parâmetros do construtor, em vez de exigir um construtor padrão. O módulo Kotlin para Jackson faz isso, portanto é claramente possível.

Consulte também: https://stackoverflow.com/a/34624907/3679676 para explorar opções semelhantes.

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

Os valores iniciais são requeridos se você deseja reutilizar o construtor para campos diferentes, o kotlin não permite nulos. Portanto, sempre que você planeja omitir o campo, use este formulário no construtor:var field: Type? = defaultValue

O jpa não exigiu construtor de argumentos:

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

não há duplicação de código. Se você precisa construir uma entidade e configurar apenas a idade, use este formulário:

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

não há mágica (basta ler a documentação)

Não há como manter a imutabilidade assim. Vals DEVE ser inicializado ao construir a instância.

Uma maneira de fazer isso sem imutabilidade é:

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

Trabalho com o Kotlin + JPA há um bom tempo e criei minha própria idéia de como escrever classes de entidade.

Eu apenas estendo um pouco sua ideia inicial. Como você disse, podemos criar um construtor privado sem argumentos e fornecer valores padrão para primitivas , mas quando tentamos usar outras classes, fica um pouco confuso. Minha ideia é criar um objeto STUB estático para a classe de entidade que você escreve atualmente, por exemplo:

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

    companion object {
        val STUB = TestEntity()
    }
}

e quando tenho uma classe de entidade relacionada ao TestEntity , posso usar facilmente o stub que acabei de criar. Por exemplo:

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

    companion object {
        val STUB = RelatedEntity()
    }
}

Claro que esta solução não é perfeita. Você ainda precisa criar um código padrão que não deve ser necessário. Além disso, há um caso que não pode ser resolvido bem com stubbing - relação pai-filho dentro de uma classe de entidade - assim:

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

    companion object {
        val STUB = TestEntity()
    }
}

Esse código produzirá NullPointerException devido a um problema de ovo de galinha - precisamos do STUB para criar o STUB. Infelizmente, precisamos tornar esse campo anulável (ou alguma solução semelhante) para que o código funcione.

Também na minha opinião, ter o ID como último campo (e anulável) é bastante ideal. Não devemos atribuí-lo manualmente e deixar o banco de dados fazer isso por nós.

Não estou dizendo que essa é uma solução perfeita, mas acho que ela aproveita a legibilidade do código da entidade e os recursos do Kotlin (por exemplo, segurança nula). Só espero que os lançamentos futuros do JPA e / ou Kotlin tornem nosso código ainda mais simples e agradável.

Como mencionado acima, você deve usar o no no-argplugin fornecido pelo Jetbrains.

Se você estiver usando Eclispe poderá ser necessário editar as configurações do compilador Kotlin.

Janela> Preferências> Kotlin> Compilador

Ative o no-arg plug in na seção Plug-ins do compilador.

Veja: https://discuss.kotlinlang.org/t/kotlin-allopen-plugin-doesnt-work-with-sts/13277/10

Eu sou um nub mim, mas parece que você precisa explicitar inicializador e fallback para um valor nulo como este

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

Semelhante a @pawelbial, usei o objeto complementar para criar uma instância padrão; no entanto, em vez de definir um construtor secundário, use apenas argumentos do construtor padrão como @iolo. Isso poupa a necessidade de definir vários construtores e mantém o código mais simples (embora concedido, a definição de objetos complementares "STUB" não é exatamente simples)

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

    companion object {
        val STUB = TestEntity()
    }
}

E então para as classes que se relacionam com TestEntity

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

Como o @pawelbial mencionou, isso não funcionará onde o TestEntity classe "possui uma", uma TestEntityvez que o STUB não terá sido inicializado quando o construtor for executado.

Essas linhas de construção da Gradle me ajudaram:
https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa/1.1.50 .
Pelo menos, ele cria no IntelliJ. Está falhando na linha de comando no momento.

E eu tenho um

class LtreeType : UserType

e

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

caminho var: LtreeType não funcionou.

Se você incluiu o plug-in gradle https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa mas não funcionou, é provável que a versão esteja desatualizada. Eu estava em 1.3.30 e não funcionou para mim. Depois que eu atualizei para 1.3.41 (o mais recente no momento da redação), funcionou.

Nota: a versão do kotlin deve ser igual a este plugin, por exemplo: foi assim que adicionei os dois:

buildscript {
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
    }
}