Kotlin mit JPA: Standardkonstruktor Hölle

Gemäß JPA @Entitysollten Klassen über einen Standardkonstruktor (ohne Argumente) verfügen, um die Objekte beim Abrufen aus der Datenbank zu instanziieren.

In Kotlin lassen sich Eigenschaften sehr bequem im primären Konstruktor deklarieren, wie im folgenden Beispiel:

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

Wenn der Nicht-Arg-Konstruktor jedoch als sekundärer deklariert wird, müssen Werte für den primären Konstruktor übergeben werden, sodass einige gültige Werte für sie erforderlich sind, wie hier:

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

Für den Fall, dass die Eigenschaften einen komplexeren Typ als nur haben Stringund Intnicht nullwertfähig sind, sieht es völlig schlecht aus, die Werte für sie anzugeben, insbesondere wenn der primäre Konstruktor und die initBlöcke viel Code enthalten und die Parameter aktiv verwendet werden. - Wenn sie durch Reflexion neu zugewiesen werden sollen, wird der größte Teil des Codes erneut ausgeführt.

Darüber hinaus können valEigenschaften nach der Ausführung des Konstruktors nicht neu zugewiesen werden, sodass auch die Unveränderlichkeit verloren geht.

Die Frage ist also: Wie kann Kotlin-Code für die Arbeit mit JPA ohne Codeduplizierung angepasst werden, indem "magische" Anfangswerte ausgewählt werden und die Unveränderlichkeit verloren geht?

PS Stimmt es, dass der Ruhezustand neben JPA Objekte ohne Standardkonstruktor erstellen kann?

Ab Kotlin 1.0.6kotlin-noarg generiert das Compiler-Plugin synthetische Standardkonstrutoren für Klassen, die mit ausgewählten Annotationen versehen wurden.

Wenn Sie gradle verwenden, reicht das Anwenden des kotlin-jpaPlugins aus, um Standardkonstruktoren für Klassen zu generieren, die mit @Entityfolgenden Anmerkungen versehen sind :

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

apply plugin: "kotlin-jpa"

Für 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>

Geben Sie einfach Standardwerte für alle Argumente an. Kotlin erstellt einen Standardkonstruktor für Sie.

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

Siehe das NOTEFeld unter dem folgenden Abschnitt:

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

@ D3xter hat eine gute Antwort für ein Modell, das andere ist eine neuere Funktion in Kotlin mit dem Namen lateinit:

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

    lateinit var name: String
    lateinit var birthdate: Date
}

Sie würden dies verwenden, wenn Sie sicher sind, dass etwas die Werte zum Zeitpunkt der Erstellung oder sehr bald danach (und vor der ersten Verwendung der Instanz) ausfüllt.

Sie werden feststellen, dass ich zu geändert habe age, birthdateweil Sie keine primitiven Werte mit verwenden können lateinitund dies auch im Moment sein muss var(die Einschränkung wird möglicherweise in Zukunft aufgehoben).

Also keine perfekte Antwort für Unveränderlichkeit, das gleiche Problem wie die andere Antwort in dieser Hinsicht. Die Lösung hierfür sind Plugins für Bibliotheken, die das Verständnis des Kotlin-Konstruktors und die Zuordnung von Eigenschaften zu Konstruktorparametern übernehmen können, anstatt einen Standardkonstruktor zu benötigen. Das Kotlin-Modul für Jackson macht das, also ist es eindeutig möglich.

Weitere Informationen zu ähnlichen Optionen finden Sie unter: https://stackoverflow.com/a/34624907/3679676 .

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

Anfangswerte sind erforderlich, wenn Sie den Konstruktor für verschiedene Felder wiederverwenden möchten. Kotlin erlaubt keine Nullen. Wenn Sie also ein Feld weglassen möchten, verwenden Sie dieses Formular im Konstruktor:var field: Type? = defaultValue

jpa benötigt keinen Argumentkonstruktor:

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

Es gibt keine Codeduplizierung. Wenn Sie eine Konstruktionsentität und nur ein Einrichtungsalter benötigen, verwenden Sie dieses Formular:

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

Es gibt keine Magie (lesen Sie einfach die Dokumentation)

Es gibt keine Möglichkeit, diese Unveränderlichkeit so zu halten. Vals MUSS beim Erstellen der Instanz initialisiert werden.

Ein Weg, dies ohne Unveränderlichkeit zu tun, ist:

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

Ich arbeite seit einiger Zeit mit Kotlin + JPA und habe meine eigene Idee entwickelt, wie man Entitätsklassen schreibt.

Ich möchte Ihre ursprüngliche Idee nur geringfügig erweitern. Wie Sie sagten, können wir einen privaten argumentlosen Konstruktor erstellen und Standardwerte für Grundelemente bereitstellen. Wenn wir jedoch versuchen, andere Klassen zu verwenden, wird dies etwas chaotisch. Meine Idee ist es, ein statisches STUB-Objekt für eine Entitätsklasse zu erstellen, die Sie derzeit schreiben, z.

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

    companion object {
        val STUB = TestEntity()
    }
}

und wenn ich eine Entitätsklasse habe, die mit TestEntity zusammenhängt, kann ich einfach den gerade erstellten Stub verwenden. Beispielsweise:

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

    companion object {
        val STUB = RelatedEntity()
    }
}

Natürlich ist diese Lösung nicht perfekt. Sie müssen noch einen Code für das Boilerplate erstellen, der nicht erforderlich sein sollte. Es gibt auch einen Fall, der mit Stubbing - Eltern-Kind-Beziehung innerhalb einer Entitätsklasse - nicht gut gelöst werden kann:

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

    companion object {
        val STUB = TestEntity()
    }
}

Dieser Code wird produzieren Nullpointer aufgrund Henne-Ei - Problem - wir STUB brauchen STUB zu erstellen. Leider müssen wir dieses Feld nullbar machen (oder eine ähnliche Lösung), damit Code funktioniert.

Auch meiner Meinung nach ist es ziemlich optimal , Id als letztes Feld (und nullbar) zu haben. Wir sollten es nicht von Hand zuweisen und die Datenbank es für uns tun lassen.

Ich sage nicht, dass dies eine perfekte Lösung ist, aber ich denke, dass sie die Lesbarkeit von Entitätscode und Kotlin-Funktionen (z. B. Null-Sicherheit) nutzt. Ich hoffe nur, dass zukünftige Versionen von JPA und / oder Kotlin unseren Code noch einfacher und schöner machen.

Wie oben erwähnt, müssen Sie no-argdas von Jetbrains bereitgestellte No- Plugin verwenden.

Wenn Sie Eclispe verwenden, müssen Sie möglicherweise die Kotlin Compiler-Einstellungen bearbeiten.

Fenster> Einstellungen> Kotlin> Compiler

Aktivieren Sie das no-argPlugin im Abschnitt Compiler Plugins.

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

Ich bin selbst ein Nub, aber anscheinend müssen Sie den Initialisierer explizit initialisieren und auf einen solchen Nullwert zurückgreifen

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

Ähnlich wie bei @pawelbial habe ich ein Begleitobjekt verwendet, um eine Standardinstanz zu erstellen. Anstatt jedoch einen sekundären Konstruktor zu definieren, verwenden Sie einfach Standardkonstruktorargumente wie @iolo. Dies erspart Ihnen die Definition mehrerer Konstruktoren und vereinfacht den Code (obwohl dies selbstverständlich ist, ist die Definition von "STUB" -Begleitobjekten nicht gerade einfach).

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

    companion object {
        val STUB = TestEntity()
    }
}

Und dann für Klassen, die sich beziehen TestEntity

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

Wie @pawelbial erwähnt hat, funktioniert dies nicht, wenn die TestEntityKlasse eine Klasse "hat" TestEntity, da STUB beim Ausführen des Konstruktors nicht initialisiert wurde.

Diese Gradle-Build-Linien haben mir geholfen:
https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa/1.1.50 .
Zumindest baut es in IntelliJ. Es schlägt momentan in der Kommandozeile fehl.

Und ich habe eine

class LtreeType : UserType

und

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

var path: LtreeType hat nicht funktioniert.

Wenn Sie das Gradle-Plugin https://plugins.gradle.org/plugin/org.jetbrains.kotlin.plugin.jpa hinzugefügt haben , aber nicht funktioniert haben, ist die Version wahrscheinlich veraltet. Ich war am 1.3.30 und es hat bei mir nicht funktioniert. Nachdem ich auf 1.3.41 (spätestens zum Zeitpunkt des Schreibens) aktualisiert hatte, funktionierte es.

Hinweis: Die Kotlin-Version sollte mit diesem Plugin identisch sein, z. B.: So habe ich beide hinzugefügt:

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