如何解决java.lang.IllegalStateException：即将执行操作，但存在未解析的实体插入操作

我收到“java.lang.IllegalStateException:即将执行操作，但存在未解析的实体插入操作。”使用hibernate更新实体时出错。 我使用继承将一个表映射到多个对象。实体RecurringEntity与InstanceEntity有一对多关系，RecurringEntity事件和InstanceEntity都是从AbstractEvent派生的。我尝试使用一些数据更新RecurringEntity-此更新可能需要创建与此RecurringEntity相关的新（或删除）InstanceEntity。我想定义级联，以便在更新RecurringEventEntity中的集合，然后保存RecurringEventEntity时，可以保存RecurringEventEntity和所有更改的InstanceEntity。你知道我为什么会在开头提到异常，以及如何解决这个问题吗

以下是简化代码（模型和操作方法）

@实体
@表（name=“event”、schema=“”、catalog=“”）
@继承（策略=InheritanceType.SINGLE_表）
@鉴别器柱(
name=“`type`”，
discriminatorType=discriminatorType.STRING
)
抽象公共类抽象事件{
公共枚举事件类型{
正常,，
再发生，
例如,，
例如,，
实例
}
私人长期投资；
私人约会活动开始；
私人约会结束；
私有事件类型；
私有字符串eventName；
私人日期创建日期；
私人日期修改日期；
公共事件（）{
this.idEvent=null；
this.createdDate=新日期（）；
}
@身份证
@列（name=“id\u event”，nullable=false，insertable=true，updateable=true，length=32，precision=0）
@GeneratedValue（生成器=“序列”）
@SequenceGenerator（name=“sequence”，sequenceName=“cal_sequence”）
公共长getIdEvent（）{
返回idEvent；
}
受保护的void setIdEvent（Long idEvent）{this.idEvent=idEvent；}
@基本的
@列（name=“event_start”，nullable=false，insertable=true，updateable=true，length=19，precision=0）
公共日期getEventStart（）{
返回事件开始；
}
public void setEventStart（日期eventStart）{
this.eventStart=eventStart；
}
@基本的
@列（name=“event_end”，nullable=true，insertable=true，updateable=true，length=19，precision=0）
公共日期getEventEnd（）{
返回事件结束；
}
public void setEventEnd（日期eventEnd）{
this.eventEnd=eventEnd；
}
@基本的
@列（name=“type”，nullable=false，insertable=false，updateable=false，length=20，precision=0）
@枚举（EnumType.STRING）
公共事件类型getType（）{
返回类型；
}
公共void集合类型（EventType类型）{
this.type=type；
}
@基本的
@列（name=“event_name”，nullable=false，insertable=true，updateable=true，length=200，precision=0）
公共字符串getEventName（）{
返回事件名；
}
public void setEventName（字符串eventName）{
this.eventName=eventName；
}
@基本的
@列（name=“created”，nullable=false，insertable=true，updateable=false）
公共日期getCreatedDate（）{
返回createdDate；
}
公共void setCreatedDate（创建日期）{
this.createdDate=created；
}
@基本@版本
@列（name=“modified”，nullable=true，insertable=true，updateable=true）
公共日期getModifiedDate（）{
返回修改数据；
}
公共无效设置修改日期（修改日期）{
this.modifiedDate=已修改；
}
}
@实体
@鉴别器值（“重复”）
公共类复发事件扩展了AbstractEvent{
私有集实例；
@OneToMany（mappedBy=“recurringEventEntity”，fetch=FetchType.LAZY）
@级联（值={org.hibernate.annotations.CascadeType.ALL}）
公共集getInstances（）{
返回此.instances；
}
公共void集合实例（集合实例）{
this.instances=实例；
}
}
@实体
@鉴别器值（“实例”）
公共类InstanceEntity扩展了AbstractEventInstance{
私人复发性复发性；
@manytone（fetch=FetchType.EAGER）
@JoinColumn（name=“`recurtive\u event`”，referencedColumnName=“`id\u event`”，null=false，insertable=false，updateable=false）
公共复发性{
复发性；
}
公共无效设置RecurringVentity（RecurringVentity RecurringVentity）{
this.recurringventity=复发性；
}
}
@交易的
公共作废操作（长事件id、对象数据）
{
Session Session=this.getSession（）；
RecurringEvent rEvent=session.get（AbstractEvent.class，事件id）；
更新事件（rEvent、数据）；
会话。保存或更新（rEvent）；
}
public void updateEvent（RecurringEvent rEvent，对象数据）
{
...
InstanceEntity实例=新InstanceEntity（）；
...
rEvent.getInstances（）.add（实例）；
}

好的，我发现了问题。我的问题中没有提到它，但实例有循环引用（预期）。删除循环引用后，它就可以工作了

@Entity
@Table(name = "event", schema = "", catalog = "")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
        name="`type`",
        discriminatorType=DiscriminatorType.STRING
)
abstract public class AbstractEvent {
    public enum EventType {
        normal,
        recurring,
        new_instance,
        original_instance,
        instance
    }
    private Long idEvent;
    private Date eventStart;
    private Date eventEnd;
    private EventType type;
    private String eventName;
    private Date createdDate;
    private Date modifiedDate;

    public AbstractEvent() {
        this.idEvent = null;
        this.createdDate = new Date();
    }

    @Id
    @Column(name = "id_event", nullable = false, insertable = true, updatable = true, length = 32, precision = 0)
    @GeneratedValue(generator = "sequence")
    @SequenceGenerator(name = "sequence", sequenceName = "cal_sequence")
    public Long getIdEvent() {
        return idEvent;
    }
    protected void setIdEvent(Long idEvent) { this.idEvent = idEvent; }

    @Basic
    @Column(name = "event_start", nullable = false, insertable = true, updatable = true, length = 19, precision = 0)
    public Date getEventStart() {
        return eventStart;
    }
    public void setEventStart(Date eventStart) {
        this.eventStart = eventStart;
    }

    @Basic
    @Column(name = "event_end", nullable = true, insertable = true, updatable = true, length = 19, precision = 0)
    public Date getEventEnd() {
        return eventEnd;
    }
    public void setEventEnd(Date eventEnd) {
        this.eventEnd = eventEnd;
    }

    @Basic
    @Column(name = "type", nullable = false, insertable = false, updatable = false, length = 20, precision = 0)
    @Enumerated(EnumType.STRING)
    public EventType getType() {
        return type;
    }
    public void setType(EventType type) {
        this.type = type;
    }

    @Basic
    @Column(name = "event_name", nullable = false, insertable = true, updatable = true, length = 200, precision = 0)
    public String getEventName() {
        return eventName;
    }
    public void setEventName(String eventName) {
        this.eventName = eventName;
    }

    @Basic
    @Column(name = "created", nullable = false, insertable = true, updatable = false)
    public Date getCreatedDate() {
        return createdDate;
    }
    public void setCreatedDate(Date created) {
        this.createdDate = created;
    }

    @Basic @Version
    @Column(name = "modified", nullable = true, insertable = true, updatable = true)
    public Date getModifiedDate() {
        return modifiedDate;
    }
    public void setModifiedDate(Date modified) {
        this.modifiedDate = modified;
    }
}

@Entity
@DiscriminatorValue("recurring")
public class RecurringEventEntity extends AbstractEvent {

    private Set<AbstractEventInstance> instances;

    @OneToMany(mappedBy = "recurringEventEntity",fetch = FetchType.LAZY)
    @Cascade(value = {org.hibernate.annotations.CascadeType.ALL})
    public Set<EventInstance> getInstances() {
        return this.instances;
    }
    public void setInstances(Set<EventInstance> instances) {
        this.instances = instances;
    }
}

@Entity
@DiscriminatorValue("instance")
public class InstanceEntity extends AbstractEventInstance {
    private RecurringEventEntity recurringEventEntity;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "`recurring_event`", referencedColumnName = "`id_event`", nullable = false, insertable = false, updatable = false)
    public RecurringEventEntity getRecurringEventEntity() {
        return recurringEventEntity;
    }

    public void setRecurringEventEntity(RecurringEventEntity recurringEventEntity) {
        this.recurringEventEntity = recurringEventEntity;
    }
}

@Transactional
public void operation(Long event_id, Object data)
{
    Session session = this.getSession();

    RecurringEvent rEvent = session.get(AbstractEvent.class, event_id);
    updateEvent(rEvent, data);
    session.saveOrUpdate(rEvent);
}

public void updateEvent(RecurringEvent rEvent, Object data)
{
    ...
    InstanceEntity instance = new InstanceEntity();
    ...
    rEvent.getInstances().add(instance);
}