Kotlin dengan JPA: default constructor hell

Seperti yang dibutuhkan JPA, @Entitykelas harus memiliki konstruktor default (non-arg) untuk instantiate objek ketika mengambilnya dari database.

Di Kotlin, properti sangat mudah untuk menyatakan dalam konstruktor utama, seperti dalam contoh berikut:

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

Tetapi ketika konstruktor non-arg dideklarasikan sebagai konstruktor sekunder, ia membutuhkan nilai untuk konstruktor primer untuk dilewati, sehingga beberapa nilai valid diperlukan untuk mereka, seperti di sini:

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

Dalam kasus ketika properti memiliki beberapa tipe yang lebih kompleks daripada hanya Stringdan Intdan mereka tidak dapat dibatalkan, terlihat sangat buruk untuk memberikan nilai untuk mereka, terutama ketika ada banyak kode dalam konstruktor dan initblok primer dan ketika parameter digunakan secara aktif - - ketika mereka akan dipindahkan melalui refleksi sebagian besar kode akan dieksekusi lagi.

Selain itu, val-properti tidak dapat dipindahkan setelah konstruktor dijalankan, sehingga ketidakmampuan juga hilang.

Jadi pertanyaannya adalah: bagaimana kode Kotlin dapat diadaptasi untuk bekerja dengan JPA tanpa duplikasi kode, memilih nilai awal "ajaib" dan kehilangan keabadian?

PS Benarkah Hibernate selain dari JPA dapat membangun objek tanpa konstruktor default?

Pada Kotlin 1.0.6 , kotlin-noargplugin kompiler menghasilkan konstruktor default default untuk kelas yang telah dijelaskan dengan anotasi yang dipilih.

Jika Anda menggunakan gradle, menerapkan kotlin-jpaplugin sudah cukup untuk menghasilkan konstruktor default untuk kelas yang dijelaskan dengan @Entity:

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

apply plugin: "kotlin-jpa"

Untuk 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>

cukup berikan nilai default untuk semua argumen, Kotlin akan membuat konstruktor default untuk Anda.

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

lihat NOTEkotak di bawah bagian berikut:

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

@ D3xter memiliki jawaban yang bagus untuk satu model, yang lain adalah fitur yang lebih baru di Kotlin yang disebut lateinit:

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

    lateinit var name: String
    lateinit var birthdate: Date
}

Anda akan menggunakan ini ketika Anda yakin sesuatu akan mengisi nilai pada waktu konstruksi atau segera setelahnya (dan sebelum penggunaan pertama instance).

Anda akan catatan saya berubah ageke birthdatekarena Anda tidak dapat menggunakan nilai-nilai primitif dengan lateinitdan mereka juga untuk saat ini harus var(pembatasan mungkin akan dirilis di masa depan).

Jadi bukan jawaban sempurna untuk kekekalan, masalah yang sama dengan jawaban lain dalam hal itu. Solusi untuk itu adalah plugin ke perpustakaan yang dapat menangani pemahaman konstruktor Kotlin dan memetakan properti ke parameter konstruktor, alih-alih membutuhkan konstruktor default. The Kotlin modul untuk Jackson melakukan hal ini, sehingga sangat jelas mungkin.

Lihat juga: https://stackoverflow.com/a/34624907/3679676 untuk eksplorasi opsi serupa.

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

Nilai awal diperlukan jika Anda ingin menggunakan kembali konstruktor untuk bidang yang berbeda, kotlin tidak diizinkan nol. Jadi, setiap kali Anda berencana menghilangkan bidang, gunakan formulir ini di konstruktor:var field: Type? = defaultValue

jpa tidak memerlukan konstruktor argumen:

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

tidak ada duplikasi kode. Jika Anda memerlukan entitas konstruk dan hanya usia setup, gunakan formulir ini:

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

tidak ada keajaiban (baca dokumentasi saja)

Tidak ada cara untuk menjaga kekekalan seperti ini. Vals HARUS diinisialisasi ketika membangun instance.

Salah satu cara untuk melakukannya tanpa kekekalan adalah:

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

Saya telah bekerja dengan Kotlin + JPA cukup lama dan saya telah membuat ide saya sendiri bagaimana menulis kelas Entity.

Saya hanya sedikit memperluas ide awal Anda. Seperti yang Anda katakan kami dapat membuat konstruktor tanpa argumen pribadi dan memberikan nilai default untuk primitif , tetapi ketika kami mencoba perlu menggunakan kelas lain itu menjadi sedikit berantakan. Ide saya adalah membuat objek STUB statis untuk kelas entitas yang saat ini Anda tulis misalnya:

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

    companion object {
        val STUB = TestEntity()
    }
}

dan ketika saya memiliki kelas entitas yang terkait dengan TestEntity saya dapat dengan mudah menggunakan rintisan yang baru saja saya buat. Sebagai contoh:

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

    companion object {
        val STUB = RelatedEntity()
    }
}

Tentu saja solusi ini tidak sempurna. Anda masih perlu membuat beberapa kode boilerplate yang seharusnya tidak diperlukan. Juga ada satu kasus yang tidak dapat diselesaikan dengan baik dengan stubbing - hubungan orangtua-anak dalam satu kelas entitas - seperti ini:

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

    companion object {
        val STUB = TestEntity()
    }
}

Kode ini akan menghasilkan NullPointerException karena masalah ayam-telur - kita perlu STUB untuk membuat STUB. Sayangnya kita perlu membuat bidang ini nullable (atau beberapa solusi serupa) untuk membuat kode berfungsi.

Juga menurut saya memiliki Id sebagai bidang terakhir (dan nullable) cukup optimal. Kita seharusnya tidak menetapkannya dengan tangan dan membiarkan database melakukannya untuk kita.

Saya tidak mengatakan bahwa ini adalah solusi yang sempurna, tapi saya pikir itu memanfaatkan pembacaan kode entitas dan fitur Kotlin (mis. Null safety). Saya hanya berharap rilis JPA dan / atau Kotlin di masa depan akan membuat kode kita lebih sederhana dan lebih baik.

Seperti yang dinyatakan di atas Anda harus menggunakan no-argplugin no yang disediakan oleh Jetbrains.

Jika Anda menggunakan Eclispe, Anda mungkin harus mengedit Pengaturan Kompilator Kotlin.

Window> Preferences> Kotlin> Compiler

Aktifkan no-argPlugin di bagian Compiler Plugins.

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

Saya seorang nub sendiri tetapi tampaknya Anda harus menginisialisasi eksplisit dan mundur ke nilai nol seperti ini

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

Mirip dengan @pawelbial Saya telah menggunakan objek pengiring untuk membuat instance default, namun alih-alih mendefinisikan konstruktor sekunder, cukup gunakan arg konstruktor default seperti @iolo. Ini menghemat Anda harus mendefinisikan banyak konstruktor dan membuat kode lebih sederhana (meskipun diberikan, mendefinisikan objek pendamping "STUB" tidak persis membuatnya sederhana)

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

    companion object {
        val STUB = TestEntity()
    }
}

Dan kemudian untuk kelas yang berhubungan dengan TestEntity

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

Seperti @pawelbial telah menyebutkan, ini tidak akan bekerja di mana TestEntitykelas "memiliki" TestEntitykelas karena STUB tidak akan diinisialisasi ketika konstruktor dijalankan.

Baris build Gradle ini membantu saya:
https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa/1.1.50 .
Setidaknya, itu dibangun di IntelliJ. Gagal pada baris perintah saat ini.

Dan saya punya

class LtreeType : UserType

dan

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

var path: LtreeType tidak berfungsi.

Jika Anda menambahkan plugin gradle https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa tetapi tidak berfungsi, kemungkinan versinya sudah keluar. Saya berada di 1.3.30 dan tidak berhasil untuk saya. Setelah saya memutakhirkan ke 1.3.41 (terbaru saat penulisan), itu berhasil.

Catatan: versi kotlin harus sama dengan plugin ini, mis: ini adalah cara saya menambahkan keduanya:

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