如何在Kotlin中定义JPA实体？JPA实体的各项规则介绍

作为适合多平台应用的静态编程语言，Kotlin比Java更简洁、更有表现力、也更具有代码的安全性。同时，Kotlin提供了与Java的无缝互操作性。也就是说，Java允许开发人员将他们的项目迁移到Kotlin处，而无需重写整个代码库。当然，针对此类迁移，我们可能需要在Kotlin应用中使用JPA(Java Persistence API)。虽然许多开发者普遍认为：没有JPA，就不存在实体。但是他们在Kotlin中定义JPA时，往往会遇到各种警告。下面，我们来一起讨论：作为JPA的经典实现—Hibernate，是如何避免各种常见的错误，并充分利用Kotlin的。

JPA实体的各项规则

注意，此处的实体并非常规的数据传输对象(Data Transfer Object，DTO)。为了能够顺畅运行，实体需要得到正确地定义。链接中详细阐述了针对JPA的一系列规范和限制。其中最重要的是如下两项：

实体类虽然可以拥有其他构造函数，但是必须具有一个无参数(no-arg)的构造函数。而且这个无参数构造函数必须是公共的(public)或受保护的(protected)。

实体类的任何方法、或持久性实例变量，都不能为final类型。

上述规范足以让实体类运行起来。不过为了使之更流畅地运行，我们需要附加如下两条规则：

只有在明确的请求时，所有Lasy关联才能被加载。否则，我们可能会遇到LazyInitializationException、或各种意外的性能问题。

equals()和hashCode()的实现，必须考虑到实体的可变特性。

无参数的构造函数

主构造函数(Primary constructors)是Kotlin最受欢迎的特性之一。然而，主构造函数在被加入的同时，替换了原有的默认函数。因此，如果您在Hibernate中使用它，则可能会碰到诸如：org.hibernate.InstantiationException: No default constructor for entity的异常。

那么为了解决此问题，您可以在所有实体中，手动定义无参数的构造函数。同时，您最好使用kotlin-jpa编译器插件，来确保在字节码中，为每个JPA定义相关的类，如：@Entity、@MappedSuperclass或@Embeddable，生成无参数的构造函数。

若想启用该插件，您只需将其添加到kotlin-maven-plugin和compilerPlugins的依赖关系中即可，请参见如下代码段：

org.jetbrains.kotlin

kotlin-maven-plugin

...

  jpa  

...

...

org.jetbrains.kotlin

kotlin-maven-noarg

${kotlin.version}

...

与之对应的在Gradle(译者注：一个基于Apache Ant和Apache Maven概念的项目自动化构建开源工具)中的代码段为：

buildscript {

dependencies {

classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"

}

}

apply plugin: "kotlin-jpa"

打开各种类和属性

根据JPA规范，所有与JPA相关的类和属性都必须是open的。不过，某些JPA提供程序可能不会强制执行该规范。例如，Hibernate在遇到最终实体类时，是不会抛出异常的。然而，由于final类无法被子类化(subclassed)，因此Hibernate的代理机制会就此关闭。而没有了代理，又何谈lazy加载呢?而且，由于程序急需获取所有的ToOne关联，因此它很可能会导致严重的性能问题。

不过，对于使用静态编织(static weaving)的EclipseLink而言，情况则不同，毕竟它的lazy加载机制并不会用到子类化。

如下代码段所示，与Java不同的是，在Kotlin中，所有的类、属性、以及方法，默认都是final类型的。您必须将它们明确地标记为open：

@Table(name = "project")

@Entity

open class Project {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

@Column(name = "id", nullable = false)

open var id: Long? = null

@Column(name = "name", nullable = false)

open var name: String? = null

...

}

或者如下面的代码段所示，您最好使用全开放(all-open)式的编译器插件(https://kotlinlang.org/docs/all-open-plugin.html)，来默认开启所有与JPA相关的类和属性。通过正确的配置，它能够适用于所有被注释为@Entity、 @MappedSuperclass、以及@Embeddable的类：

org.jetbrains.kotlin

kotlin-maven-plugin

...

  all-open  

 all-open:annotation=javax.persistence.Entity 

 all-open:annotation=javax.persistence.MappedSuperclass 

 all-open:annotation=javax.persistence.Embeddable 

org.jetbrains.kotlin

kotlin-maven-allopen

${kotlin.version}

与之对应的在Gradle中的代码段为：

buildscript {

dependencies {

classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlin_version"

}

}

apply plugin: "kotlin-allopen"

allOpen {

annotations("javax.persistence.Entity", "javax.persistence.MappedSuperclass", "javax.persistence.Embedabble")

}

针对JPA实体使用各种数据类

数据类(Data classes)是专为DTO设计的一项超棒的Kotlin功能。它被默认设计、并配备了各种非常实用的针对equals()、hashCode()、以及toString()的实现。不过，此类实现并不太适合JPA实体。其原因在于，虽然数据类被设计为final类，但是它不能够像Kotlin那样被标记为open。因此，为了适用于实体，而将它们标记为open的唯一方法便是，启用全开放式的编译器插件。

如下代码段所示，我们将使用以下实体，来进一步检查数据类。它带有一个已生成的id、一个name属性、以及两个lazy的OneToMany关联：

@Table(name = "client")

@Entity

data class Client(

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

@Column(name = "id", nullable = false)

var id: Long? = null,

@Column(name = "name", nullable = false)

var name: String? = null,

@OneToMany(mappedBy = "client", orphanRemoval = true)

var projects: MutableSet   = mutableSetOf(),  

@JoinColumn(name = "client_id")

@OneToMany

var contacts: MutableSet  = mutableSetOf(),

)

意外获取LAZY关联

默认情况下，所有ToMany关联都是lazy的，其原因在于：非必要地加载它们，往往很容易会影响到程序性能。例如，equals()、hashCode()、以及toString()在实现的过程中，通常会用到包括lazy在内的所有属性。因此，调用它们会导致向数据库产生不需要的请求、以及出现LazyInitializationException。而且，数据类的默认行为是：在其方法中，使用来自主构造函数的所有字段。

在此，我们可以使用IDE来生成toString()，以通过简单的覆盖方式，排除所有的LAZY字段。如下代码段所示，由于JPA Buddy有着自己的toString()产生机制，因此它完全不会提供LAZY字段。

@Override

override fun toString(): String {

return this::class.simpleName + "(id = $id , name = $name )"

}

当然，仅从equals()和hashCode()中排除LAZY字段是远远不够的，毕竟它们可能仍然包含着可变的属性。

Equals()和HashCode()的问题

由于JPA实体在本质上是可变的，因此为其实现equals()和hashCode()，并不像常规的DTO那么简单。某些实体的id甚至都是由数据库所生成的，因此id会在实体首次被持久化后发生变化。这就意味着我们将没有可依赖的字段，去计算hashCode。

下面，让我们对Client实体进行一个简单的测试。

val awesomeClient = Client(name = "Awesome client")

val hashSet = hashSetOf(awesomeClient)

clientRepository.save(awesomeClient)

assertTrue(awesomeClient in hashSet)

如上面的代码段所说，即便该实体被添加到前面几行的集合中，它的最后一行断言也会出现错误。毕竟，id在被首次生成时，hashCode就会发生改变。这就导致了HashSet在不同的存储桶中是无法查找到该实体的。可见，如果id是在实体对象的创建期间被设置的(例如，是由应用程序设置的UUID)，那么就不会出现问题;而如果是由数据库生成的id(其实更为常见)，就会出现上述问题。

对此，我们可以在使用实体的数据类时，持续性地覆盖equals()和hashCode()。如果您想详细地了解具体使用方法，请参见--https://vladmihalcea.com/the-best-way-to-implement-equals-hashcode-and-tostring-with-jpa-and-hibernate/。其中，对于Client实体而言，其对应的代码段为：

override fun equals(other: Any?): Boolean {

if (this === other) return true

if (other == null ||Hibernate.getClass(this) !=Hibernate.getClass(other)) return false

other as Client

return id != null && id == other.id

}

override fun hashCode(): Int = 1756406093

使用由应用程序设置的ID

其实，数据类的各种方法主要是由主构造函数中那些指定的字段所生成的。如果只包含了eager immutable字段，那么数据类就不会存在上述问题。如下代码段展示了由应用程序设置的不可变id的字段：

@Table(name = "contact")

@Entity

data class Contact(

@Id

@Column(name = "id", nullable = false)

val id: UUID,

) {

@Column(name = "email", nullable = false)

val email: String? = null

// other properties omitted

}

如果您更喜欢使用由数据库来生成id的话，则可以参照如下代码段，以实现在构造函数中使用不可变的自然id：

@Table(name = "contact")

@Entity

data class Contact(

@NaturalId

@Column(name = "email", nullable = false, updatable = false)

val email: String

) {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

@Column(name = "id", nullable = false)

var id: Long? = null

// other properties omitted

}

虽然您可以放心地使用上述方法，但是它几乎违背了使用数据类的初衷。毕竟，该用法不但让分解(decomposition)变得无效，而且让toString()对于实体而言，还不如直接使用普通的旧类。

空指针安全性(null-safety)

Kotlin相对于Java的一项优势便是，内置有空指针安全性的功能。我们可以通过非空约束(non-null constraints)在数据库端确保空指针的安全性。其最简单的实现方法为，在主构造函数中使用非空类型，来定义各种非空的属性(请参考如下代码段)：

@Table(name= "contact")

@Entity

class Contact(

@NaturalId

@Column(name = "email", nullable = false, updatable = false)

val email: String,

@Column(name = "name", nullable = false)

var name: String

@ManyToOne(fetch = FetchType.LAZY, optional = false)

@JoinColumn(name = "client_id", nullable = false)

var client: Client

) {

// id and other properties omitted

}

当然，如果您需要从构造函数中(例如：在数据类中)排除它们，则可以提供默认值，或将lateinit的修饰符添加到其属性之中(请参考如下代码段)：

@Entity

data class Contact(

@NaturalId

@Column(name = "email", nullable = false, updatable = false)

val email: String,

) {

@Column(name = "name", nullable = false)

var name: String = ""

@ManyToOne(fetch = FetchType.LAZY, optional = false)

@JoinColumn(name = "client_id", nullable = false)

lateinit var client: Client

// id and other properties omitted

}

据此，如果该属性在数据库中被确认为非空，那么我们便可以省略在Kotlin代码中，对于所有空值的检查。

小结

让我们通过如下列表，一起来总结一下如何在Kotlin中定义JPA实体：

请将所有与JPA相关的类、及其属性标记为open，以避免出现显著的性能问题。

为ManytoOne和OnetoOne关联开启lazy加载，或者将全开放式的编译器插件，应用到所有被注释为@Entity、@MappedSuperclass、以及@Embeddable的类。

为了避免出现InstantiationException，请在所有与JPA相关的类中，定义无参数的构造函数，或使用kotlin-jpa编译器插件。

通过启用全开放式的插件，在已编译的字节码中创建数据类，并使之具有open属性。

覆盖equals()、hashCode()、以及toString()。

让JPA Buddy生成诸如：equals()、hashCode()、以及toString()等有效的实体。

此外，如果您想深入研究此类实践，请通过链接，参考我们在GitHub存储库中为您准备的带有测试的示例。