使用带有Kotlin的JPA(Hibernate)的优秀实践

[[413599]]

【51CTO.com快译】作为适合多平台应用的静态编程语言，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的依赖关系中即可，请参见如下代码段：

<plugin> 
   <groupId>org.jetbrains.kotlin</groupId> 
   <artifactId>kotlin-maven-plugin</artifactId> 
   <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> 

与之对应的在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的类：

<plugin> 
   <groupId>org.jetbrains.kotlin</groupId> 
   <artifactId>kotlin-maven-plugin</artifactId> 
   <configuration> 
       <compilerPlugins> 
           ... 
           <plugin>all-open</plugin> 
       </compilerPlugins> 
       <pluginOptions> 
           <option>all-open:annotation=javax.persistence.Entity</option> 
           <option>all-open:annotation=javax.persistence.MappedSuperclass</option> 
           <option>all-open:annotation=javax.persistence.Embeddable</option> 
       </pluginOptions> 
   </configuration> 
   <dependencies> 
       <dependency> 
           <groupId>org.jetbrains.kotlin</groupId> 
           <artifactId>kotlin-maven-allopen</artifactId> 
           <version>${kotlin.version}</version> 
       </dependency> 
   </dependencies> 
</plugin> 

与之对应的在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<Project> = mutableSetOf(), 
   @JoinColumn(name = "client_id") 
   @OneToMany 
   var contacts: MutableSet<Contact> = 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存储库中为您准备的带有测试的示例。

原文标题：Best Practices of Using JPA(Hibernate) With Kotlin，作者：Andrey Oganesyan

【51CTO译稿，合作站点转载请注明原文译者和出处为51CTO.com】