问题1.持久化双向关系Band=Link

在双向关系的情况下，Hibernate（或JPA实现）只关心关联的拥有方。拥有方是不具有mappedBy属性的那一方！
因此，如果我们只调用band.links = LinkUtils.createListOfLinks()，则Band将不会链接到新的Link实体，因为这不是关系的拥有/跟踪方。
您需要显式地将Band设置为Link，调用link.band = band，因为这是关系的拥有方。
当使用mappedBy时，开发人员有责任知道什么是拥有方，并更新关系的正确方，以便触发新关系在数据库中的持久性。
Java和Kotlin没有什么区别，都是JPA规范。

解决方案1：从双方设置关系

更正实用程序以从两侧设置关系

object BandUtils {
    fun createBandWithLinks(): Band {
         val band = Band(
            name = "MEA with links",
            description = "merch em all"
            )
        band.links = LinkUtils.createListOfLinks(band)
        return band
    }
}

object LinkUtils {
    fun createListOfLinks(band: Band): MutableSet<Link> {
        val link1 = Link()
        link1.url = "https://fb.com/joergi"
        link1.band = band

        val link2 = Link()
        link2.url = "https://twitter.com/joergi"
        link2.band = band

        var linkSets = mutableSetOf<Link>()
        linkSets.add(link1)
        linkSets.add(link2)
        return linkSets
    }
}

解决方案2：更改关系的拥有方（不推荐）

不需要改变你的效用。
删除OneToMany的mappedBy，添加JoinColumn

@OneToMany(
        fetch = FetchType.EAGER,
       // mappedBy = "band",
        cascade = [CascadeType.ALL]
    )
    @JoinColumn(name = "band_id")
    var links: MutableSet<Link> = mutableSetOf()

将JoinColumn(insertable = false, updatable = false)与ManyToOne相加

@ManyToOne(fetch = FetchType.EAGER, cascade = [CascadeType.ALL])
    @JoinColumn(name = "band_id", insertable = false, updatable = false)
    var band: Band? = null

实体定义

@Entity
data class Band(

    @Id
    @Setter(AccessLevel.NONE)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Schema(hidden = true)
    val id: Int? = null,

    var name: @NotEmpty(message = "name must not be empty") String? = null,

    var description: String? = null,

    @JsonBackReference(value = "links")
    @OneToMany(
        fetch = FetchType.EAGER,
        cascade = [CascadeType.ALL]
    )
    @JoinColumn(name = "band_id")
    var links: MutableSet<Link> = mutableSetOf()
}

@Entity
data class Link(

    @Id
    @Setter(AccessLevel.NONE)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Schema(hidden = true)
    val id: Int? = null,

    var url: String? = null

) {
    @ManyToOne(fetch = FetchType.EAGER, cascade = [CascadeType.ALL])
    @JoinColumn(name = "band_id", insertable = false, updatable = false)
    var band: Band? = null
}

在你的Baeldung文章中，这个问题在第6项中描述。

问题2. toString和hashCode的双向关系数据类循环依赖

当您正确创建实体时，在持久化过程中会收到StackOverflow错误，因为您有双向关系和定义为data class的实体。Kotling将生成不正确的hashCode实现，该实现在执行双向实体时会进入无限循环。

解决方案1：Lombok岛

使用Lombok代替data class并忽略一个关系边
第一个

解决方案2：将导致循环依赖关系的属性移动到数据类主体

请参阅详细信息Kotlin - Data class entity throws StackOverflowError

@Entity
data class Link(

    @Id
    @Setter(AccessLevel.NONE)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Schema(hidden = true)
    val id: Int? = null,

    var url: String? = null

) {
    @ManyToOne(fetch = FetchType.EAGER, cascade = [CascadeType.ALL])
    @JoinColumn(name = "band_id", nullable = true)
    var band: Band? = null
}

更新
为什么更改拥有方不是一个好的解决方案？

它对生成的查询计数的影响以及因此对性能的影响。

3个查询在拥有方为ManyToOne的情况下生成：

Hibernate:
    insert 
    into
        band
        (id, description, name) 
    values
        (default, ?, ?)
Hibernate: 
    insert 
    into
        link
        (id, band_id, url) 
    values
        (default, ?, ?)
Hibernate: 
    insert 
    into
        link
        (id, band_id, url) 
    values
        (default, ?, ?)

5个查询在拥有方为OneToMany的情况下生成：

Hibernate:
  insert 
    into
        band
        (id, description, name) 
    values
        (default, ?, ?)
Hibernate: 
    insert 
    into
        link
        (id, url) 
    values
        (default, ?)
Hibernate: 
    insert 
    into
        link
        (id, url) 
    values
        (default, ?)
Hibernate: 
    update
        link 
    set
        band_id=? 
    where
        id=?
Hibernate: 
    update
        link 
    set
        band_id=? 
    where
        id=?