在OneToMany关系中，父实体更新时不会删除Spring Jpa子实体

Question

我的实体更新有问题。如你所见，我有三个实体。

LabelValueEntity包含类LabelSwitchEntity中的列表。
LabelSwitchEntity包含类SwitchCaseEntity中的列表。

从我的SQL语句中可以看到，字段name和LabelValueUId是唯一的。我的表中只允许该组合的一行。

当我用类LabelValueEntity的新列表更新父实体(LabelValueEntity)时，我希望Hibernate删除旧列表本身并创建新实体。一个一个地更新孩子是有点困难的。这就是为什么我要直接删除所有相关的孩子。

当我更新LabelValueUentity并为其提供包含具有唯一名称的LabelSwitchEntity和LabelValueUId（数据库中已存在的实体）组合的列表时，我会出现唯一约束冲突异常。这个错误很明显，因为正如我所说的，组合存在于DB中。在这里，我希望Hibernate足够聪明，可以在插入子文件之前删除它。

我做错了什么？

kotlin prettyprint-override">@Entity
@Table(name = "label_value")
class LabelValueEntity(uuid: UUID? = null,
                       ...
                       @OneToMany(
                               mappedBy = "labelValueUUID",
                               cascade = [CascadeType.ALL],
                               fetch = FetchType.EAGER,
                               orphanRemoval = true)
                       @Fetch(FetchMode.SUBSELECT)
                       val labelSwitchEntities: List<LabelSwitchEntity>? = emptyList()
) : BaseEntity(uuid)


@Entity
@Table(name = "label_switch")
class LabelSwitchEntity(uuid: UUID? = null,
                        @Column(name = "label_value_uuid", nullable = false)
                        val labelValueUUID: UUID,
                        @OneToMany(
                                mappedBy = "labelSwitchUUID",
                                cascade = [CascadeType.ALL],
                                fetch = FetchType.EAGER,
                                orphanRemoval = true
                        )
                        val switchCaseEntities: List<SwitchCaseEntity>,
                        @Column
                        val name: String,
                        ...
) : BaseEntity(uuid)

@Entity
@Table(name = "switch_case")
class SwitchCaseEntity(uuid: UUID? = null,
                       ...
                       @Column(name = "label_switch_uuid", nullable = false)
                       val labelSwitchUUID: UUID
) : BaseEntity(uuid)

CREATE TABLE label_switch
(
    uuid UUID NOT NULL PRIMARY KEY,
    label_value_uuid UUID REFERENCES label_value(uuid) ON DELETE CASCADE,
    name CHARACTER VARYING (255) NOT NULL,
    UNIQUE (label_value_uuid, name)
);

CREATE TABLE switch_case
(
    uuid UUID NOT NULL PRIMARY KEY,
    label_switch_uuid UUID NOT NULL REFERENCES label_switch(uuid) ON DELETE CASCADE
);

基本实体

@MappedSuperclass
abstract class BaseEntity(givenId: UUID? = null) : Persistable<UUID> {

    @Id
    @Column(name = "uuid", length = 16, unique = true, nullable = false)
    private val uuid: UUID = givenId ?: UUID.randomUUID()

    @Transient
    private var persisted: Boolean = givenId != null

    override fun getId(): UUID = uuid

    @JsonIgnore
    override fun isNew(): Boolean = !persisted

    override fun hashCode(): Int = uuid.hashCode()

    override fun equals(other: Any?): Boolean {
        return when {
            this === other -> true
            other == null -> false
            other !is BaseEntity -> false
            else -> getId() == other.getId()
        }
    }

    @PostPersist
    @PostLoad
    private fun setPersisted() {
        persisted = true
    }
}

Answer 1

这就是交易的来源地。如果处理用@transactional注释的方法（无论是Javax还是Spring)中的所有逻辑，那么hibernate将在其范围内进行脏检查，而不是验证。

换句话说--只要存在事务，hibernate就会跟踪对托管实体所做的更改，但它不会对其进行验证--这是数据库的责任。在内存中处理时，不检查实体的一致性。只需确保将一致状态刷新到数据库（事务提交阶段的实体应该是一致的）。

如果数据库允许的话，其他选项也是可能的，例如，在postgres中，您可以将约束标记为deferred。当约束被定义为deferred时，它不会在打开的事务中检查，只会在提交时检查。