跨 2 个不同Hibernate会话的乐观锁定

Question

我在服务层内部编写了一个更新方法，就像这样，我对所有的CRUD操作都使用Spring-data JpaRepository。

    public Note updateNote(Note note, Long id) {
        Note current = repository.getOne(id);

        current.setTitle(note.getTitle());
        current.setDetail(note.getDetail());

        return repository.save(current);
    }

我想对此操作进行乐观锁定，因此我在 Note 实体中添加了一个版本字段。

Answer 1

2：不，乐观锁定不需要任何@Lock，使用@Version我们实现了乐观锁定。

1：现在您可以使用线程测试乐观锁定方案，下面我写了一些示例测试代码，您可以根据需要进行更新。

假设我有Note实体：

@Entity
@Data
@ToString
public class Note {
    @Id
    @GeneratedValue
    private Long id;

    @Version
    private int version;

    private String name;
}

此外，我还有用于执行DB操作的Note Repostory

@存储库

public interface NoteRepo extends JpaRepository<Note, Long> {
}

现在我有一个笔记服务

@Service
@AllArgsConstructor
public class NoteService {

    private final NoteRepo noteRepo;

    @Transactional
    public Note create() {
        Note note = new Note();
        note.setName("Test Sample");
        note = noteRepo.save(note);
        System.out.println(note);
        return note;
    }

    @Transactional
    public void update(Long id, String name) {
       Note note =  noteRepo.getById(id);
       note.setName(name );
       note = noteRepo.save(note);
    }
}

现在是时候用集成测试来测试乐观锁定了。

@ExtendWith(SpringExtension.class)
@SpringBootTest(classes =Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class TestServiceTest {
 @Autowired
    private NoteService noteService;

    @Test
    void assertObjectOptimisticLockingFailure() throws InterruptedException {
        // Create a note, so after this we can perform updation
        Note note = noteService.create();

        //CountDownLatch required for wait test to complete
        CountDownLatch countDownLatch = new CountDownLatch(2);

       // Create 2 NoteThread to perform updation for exising note entity
        NoteThread xNote = new NoteThread("X", note.getId(), countDownLatch);
        NoteThread yNote = new NoteThread("Y", note.getId(), countDownLatch);

        xNote.start();
        yNote.start();

        countDownLatch.await();

        // Validate one of thread have ObjectOptimisticLockingFailureException

        assertTrue(xNote.hasObjectOptimisticLockingFailure() || yNote.hasObjectOptimisticLockingFailure());

    }

    class NoteThread extends Thread {
        private final String name;
        private final Long id;
        private final CountDownLatch countDownLatch;
        private Class exceptionClass;
        
        // verify exception
        boolean hasObjectOptimisticLockingFailure() {
            return this.exceptionClass == ObjectOptimisticLockingFailureException.class;
        }

       // Custome Thread class for performing note update and verify lock exception
        public NoteThread(String name, Long id, CountDownLatch countDownLatch) {
            this.name = name;
            this.id = id;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                noteService.update(id, name);
            } catch (Exception e) {
                exceptionClass = e.getClass();
            }finally {
                countDownLatch.countDown();
            }
        }
    }
}