我们正努力在短时间内拯救许多孩子，冬眠不断给孩子带来乐观。下面是一个简单的例子：

University
id
name
audit_version

Student 
id
name 
university_id
audit_version

其中大学id可以为空。
java对象如下所示：

@Entity
@Table(name = "university")
@DynamicUpdate
@Data
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = true)
public class University {

    @Id
    @SequenceGenerator(name = "university_id_sequence_generator", sequenceName = "university_id_sequence", allocationSize = 1)
    @GeneratedValue(strategy = SEQUENCE, generator = "university_id_sequence_generator")
    @EqualsAndHashCode.Exclude
    private Long id;

    @Column(name = "name")
    private String name;
    @Version
    @Column(name = "audit_version")
    @EqualsAndHashCode.Exclude
    private Long auditVersion;

    @OptimisticLock(excluded = true)
    @OneToMany(mappedBy = "student")
    @ToString.Exclude
    private List<Student> student;
}

@Entity
@Table(name = "student")
@DynamicUpdate
@Data
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = true)
public class Student {

    @Id
    @SequenceGenerator(name = "student_id_sequence_generator", sequenceName = "student_id_sequence", allocationSize = 1)
    @GeneratedValue(strategy = SEQUENCE, generator = "student_id_sequence_generator")
    @EqualsAndHashCode.Exclude
    private Long id;

    @Column(name = "name")
    private String name;

    @Version
    @Column(name = "audit_version")
    @EqualsAndHashCode.Exclude
    private Long auditVersion;

    @OptimisticLock(excluded = true)
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "university_id")
    @ToString.Exclude
    private University university;
}

似乎当我们分配大学然后挽救学生时，如果我们在短时间内完成4个以上的任务，我们就会得到乐观的结果。hibernate似乎正在university表上创建更新版本，尽管university在db级别没有更改。
更新：保存学生的代码

Optional<University> universityInDB = universidyRepository.findById(universtityId);
    universityInDB.ifPresent(university -> student.setUniversity(university);
    Optional<Student> optionalExistingStudent = studentRepository.findById(student);
    if (optionalExistingStudent.isPresent()) {
        Student existingStudent = optionalExistingStudent.get();
        if (!student.equals(existingStudent)) {
            copyContentProperties(student, existingStudent);
            studentToReturn = studentRepository.save(existingStudent);
        } else {
            studentToReturn = existingStudent;
        }
    } else {
        studentToReturn = studentRepository.save(student);
    }

private static final String[] IGNORE_PROPERTIES = {"id", "createdOn", "updatedOn", "auditVersion"};
public void copyContentProperties(Object source, Object target) {
    BeanUtils.copyProperties(source, target, Arrays.asList(IGNORE_PROPERTIES)));
}

我们尝试了以下方法 @OptimisticLock(excluded = true) 不起作用，仍然给出乐观锁例外。 @JoinColumn(name = "university_id", updatable=false) 只处理更新，因为我们不保存更新 @JoinColumn(name = "university_id", insertable=false) 工作但不保存关系，并且大学id始终为空
改变级联行为。唯一有意义的价值是 Cascade.DETACH ，但给出一个org.springframework.dao.invaliddataaccessapiusageexception:org.hibernate.transientpropertyvalueexception:object引用一个未保存的临时示例-在刷新之前保存临时示例。
我们想到了另一个解决办法，但不确定该选什么
给客户端一个409（冲突）错误
在409之后，客户机必须重试他的post。对于通过队列发送的对象，队列稍后将重试该条目。我们不希望我们的客户管理这个错误
出现optimisticlockexception后重试
它并不干净，因为当条目来自队列时，我们已经在做了，但可能是迄今为止最好的解决方案。
使之成为关系的父所有者
如果没有大量的关系，这可能是好的，但是我们有可能在100甚至1000中的情况，这将使对象变大，以便在队列中或通过rest调用发送。
悲观锁
我们的整个数据库目前处于乐观锁定状态，到目前为止，我们设法防止了这种乐观锁定的情况，我们不想仅仅因为这种情况而改变我们的整个锁定策略。可能对模型的子集强制悲观锁定，但我还没有考虑是否可以这样做。