Kotlin z JPA: domyślny konstruktor piekło

Zgodnie z wymaganiami JPA @Entityklasy powinny mieć domyślny konstruktor (bez argumentów) do tworzenia instancji obiektów podczas pobierania ich z bazy danych.

W Kotlinie właściwości są bardzo wygodne do zadeklarowania w głównym konstruktorze, jak w poniższym przykładzie:

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

Ale kiedy konstruktor nie-arg jest zadeklarowany jako pomocniczy, wymaga przekazania wartości dla konstruktora głównego, więc potrzebne są dla nich pewne prawidłowe wartości, jak tutaj:

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

W przypadku, gdy właściwości mają bardziej złożony typ niż tylko String i Intnie dopuszczają wartości null, podanie wartości dla nich wygląda zupełnie źle, zwłaszcza gdy jest dużo kodu w głównym konstruktorze i initblokach oraz gdy parametry są aktywnie używane - - kiedy mają zostać ponownie przypisane poprzez odbicie, większość kodu zostanie ponownie wykonana.

Ponadto, val -właściwości nie mogą być ponownie przypisane po wykonaniu konstruktora, więc niezmienność również zostaje utracona.

Pytanie brzmi więc: w jaki sposób można dostosować kod Kotlin do pracy z JPA bez duplikowania kodu, wybierając „magiczne” wartości początkowe i utratę niezmienności?

PS Czy to prawda, że ​​Hibernate poza JPA może konstruować obiekty bez domyślnego konstruktora?

Począwszy od Kotlin 1.0.6 , kotlin-noargwtyczka kompilatora generuje syntetyczne domyślne konstruktory dla klas, które zostały opatrzone adnotacjami wybranymi adnotacjami.

Jeśli używasz gradle, zastosowanie kotlin-jpawtyczki wystarczy do wygenerowania domyślnych konstruktorów dla klas z adnotacjami @Entity:

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

apply plugin: "kotlin-jpa"

Dla Mavena:

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

po prostu podaj domyślne wartości dla wszystkich argumentów, Kotlin zrobi dla ciebie domyślny konstruktor.

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

zobacz NOTEramkę pod następującą sekcją:

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

@ D3xter ma dobrą odpowiedź dla jednego modelu, drugi to nowsza funkcja w Kotlinie o nazwie lateinit:

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

    lateinit var name: String
    lateinit var birthdate: Date
}

Użyjesz tego, gdy jesteś pewien, że coś wypełni wartości w czasie tworzenia lub wkrótce po (i przed pierwszym użyciem instancji).

Zauważysz, że zmieniłem się agena, birthdateponieważ nie możesz używać prymitywnych wartości z lateiniti na razie muszą być var(ograniczenie może zostać zwolnione w przyszłości).

Więc nie jest to doskonała odpowiedź na niezmienność, ten sam problem, co inna odpowiedź w tym względzie. Rozwiązaniem są wtyczki do bibliotek, które mogą obsługiwać rozumienie konstruktora Kotlin i mapowanie właściwości na parametry konstruktora, zamiast wymagać domyślnego konstruktora. Moduł Kotlin dla Jackson robi to, więc jest wyraźnie możliwe.

Zobacz też: https://stackoverflow.com/a/34624907/3679676, aby poznać podobne opcje.

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

Wartości początkowe są wymagane, jeśli chcesz ponownie użyć konstruktora dla różnych pól, kotlin nie dopuszcza wartości null. Jeśli więc planujesz pominąć pole, użyj w konstruktorze tego formularza:var field: Type? = defaultValue

jpa nie wymagał konstruktora argumentów:

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

nie ma powielania kodu. Jeśli potrzebujesz encji konstrukcji i tylko ustawisz wiek, użyj tego formularza:

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

nie ma magii (wystarczy przeczytać dokumentację)

Nie ma sposobu, aby zachować taką niezmienność. Vals MUSI zostać zainicjowany podczas konstruowania instancji.

Jednym ze sposobów na zrobienie tego bez niezmienności jest:

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

Z Kotlin + JPA pracuję już od dłuższego czasu i stworzyłem własny pomysł na pisanie klas Entity.

Tylko nieznacznie przedłużam twój początkowy pomysł. Jak powiedziałeś, możemy stworzyć prywatny konstruktor bez argumentów i podać domyślne wartości dla prymitywów , ale kiedy próbujemy użyć innych klas, robi się trochę bałagan. Moim pomysłem jest utworzenie statycznego obiektu STUB dla klasy encji, którą obecnie zapisujesz, np .:

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

    companion object {
        val STUB = TestEntity()
    }
}

a kiedy mam klasę encji, która jest powiązana z TestEntity , mogę z łatwością użyć kodu źródłowego , który właśnie utworzyłem. Na przykład:

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

    companion object {
        val STUB = RelatedEntity()
    }
}

Oczywiście to rozwiązanie nie jest idealne. Nadal musisz utworzyć standardowy kod, który nie powinien być wymagany. Jest też jeden przypadek, którego nie można ładnie rozwiązać za pomocą stubbing - relacji rodzic-dziecko w ramach jednej klasy encji - na przykład:

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

    companion object {
        val STUB = TestEntity()
    }
}

Ten kod wygeneruje wyjątek NullPointerException z powodu problemu z jajkiem kurzego - do utworzenia STUB potrzebujemy STUB. Niestety, aby kod działał, musimy uczynić to pole dopuszczającym wartość null (lub podobnym rozwiązaniem).

Moim zdaniem również posiadanie Id jako ostatniego pola (i wartości null) jest całkiem optymalne. Nie powinniśmy przypisywać tego ręcznie i pozwolić, aby zrobiła to za nas baza danych.

Nie mówię, że jest to idealne rozwiązanie, ale myślę, że wykorzystuje czytelność kodu encji i funkcje Kotlina (np. Zerowe bezpieczeństwo). Mam tylko nadzieję, że przyszłe wydania JPA i / lub Kotlin uczynią nasz kod jeszcze prostszym i ładniejszym.

Jak wspomniano powyżej, musisz użyć no-argwtyczki no dostarczonej przez Jetbrains.

Jeśli używasz Eclispe , może być konieczna edycja ustawień kompilatora Kotlin.

Okno> Preferencje> Kotlin> Kompilator

Aktywuj no-arg wtyczkę w sekcji Wtyczki kompilatora.

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

Sam jestem nubem, ale wydaje się, że musisz jawnie inicjalizować i powrócić do wartości null w ten sposób

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

Podobnie jak w przypadku @pawelbial, użyłem obiektu towarzyszącego, aby utworzyć domyślną instancję, jednak zamiast definiować konstruktor pomocniczy, wystarczy użyć domyślnych argumentów konstruktora, takich jak @iolo. Dzięki temu nie musisz definiować wielu konstruktorów i kod jest prostszy (chociaż jest to oczywiste, definiowanie obiektów towarzyszących „STUB” nie jest do końca proste)

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

    companion object {
        val STUB = TestEntity()
    }
}

A potem na zajęcia, które dotyczą TestEntity

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

Jak wspomniał @pawelbial, nie zadziała to tam, gdzie TestEntityklasa „ma” TestEntityklasę, ponieważ STUB nie zostanie zainicjowany po uruchomieniu konstruktora.

Pomogły mi te linie budowania Gradle:
https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa/1.1.50 .
Przynajmniej jest zbudowany w IntelliJ. W tej chwili nie działa w linii poleceń.

I mam

class LtreeType : UserType

i

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

var path: LtreeType nie działa.

Jeśli dodałeś wtyczkę gradle https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa ale nie zadziałała, prawdopodobnie wersja jest przestarzała. Byłem na 1.3.30 i mi to nie wyszło. Po uaktualnieniu do 1.3.41 (najpóźniej w momencie pisania), zadziałało.

Uwaga: wersja kotlin powinna być taka sama jak ta wtyczka, np .: tak dodałem oba:

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