Spring数据支持乐观锁定

Question

注意：我不需要关于乐观锁定的解释。这个问题是关于使用乐观锁定时，什么似乎是特定的Spring数据行为。

从jpa规范来看，只要实体有@version注释字段，就应该自动在该实体上启用乐观锁定。

这是正常的还是我漏掉了什么？我们是否必须注释我们所有的方法（或者创建一个使用锁的基本存储库实现），以便用spring数据启用乐观行为？

我在spring boot项目的上下文中使用spring数据，版本1.4.5。

测试：

public class OptimisticLockExceptionTest {

    static class ReadWithSleepRunnable extends Thread {

        private OptimisticLockExceptionService service;

        private int id;

        UserRepository userRepository;

        public ReadWithSleepRunnable(OptimisticLockExceptionService service, int id, UserRepository userRepository) {
            this.service = service;
            this.id = id;
            this.userRepository = userRepository;
        }

        @Override
        public void run() {
            this.service.readWithSleep(this.userRepository, this.id);
        }

    }

    static class ModifyRunnable extends Thread {

        private OptimisticLockExceptionService service;

        private int id;

        UserRepository userRepository;

        public ModifyRunnable(OptimisticLockExceptionService service, int id, UserRepository userRepository) {
            this.service = service;
            this.id = id;
            this.userRepository = userRepository;
        }

        @Override
        public void run() {
            this.service.modifyUser(this.userRepository, this.id);
        }

    }

    @Inject
    private OptimisticLockExceptionService service;

    @Inject
    private UserRepository userRepository;

    private User u;

    @Test(expected = ObjectOptimisticLockingFailureException.class)
    public void thatOptimisticLockExceptionIsThrown() throws Exception {

        this.u = new User("email", "p");
        this.u = this.userRepository.save(this.u);

        try {
            Thread t1 = new ReadWithSleepRunnable(this.service, this.u.getId(), this.userRepository);
            t1.start();
            Thread.sleep(50);// To be sure the submitted thread starts
            assertTrue(t1.isAlive());
            Thread t2 = new ModifyRunnable(this.service, this.u.getId(), this.userRepository);
            t2.start();
            t2.join();
            assertTrue(t1.isAlive());
            t1.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

测试服务：

@Component
public class OptimisticLockExceptionService {

    @Transactional
    public User readWithSleep(UserRepository userRepo, int id) {

        System.err.println("started read");
        User op = userRepo.findOne(id);
        Thread.currentThread();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.err.println("read end");
        return op;

    }

    @Transactional
    public User modifyUser(UserRepository userRepo, int id) {

        System.err.println("started modify");
        User op = userRepo.findOne(id);

        op.setPassword("p2");

        System.err.println("modify end");
        return userRepo.save(op);

    }
}

存储库：

@Repository
public interface UserRepository extends CrudRepository<User, Integer> {
}

Answer 1

使用Spring Data JPA的乐观锁定由所使用的JPA实现来实现。

您指的是JPA规范第93页上的P2。本节以以下内容开始：

如果事务T1对一个版本化的对象调用lock(entity，lockmodetype.optigence)，实体管理器必须确保不会出现以下两种现象：

但是您的测试没有创建这样的场景。方法lock永远不会被调用。因此不会发生相关的锁定。尤其是加载一个实体并不能调用它的lock。

当一个人修改一个对象时，事情就会改变（第93页，第二段，但也是规范的最后一段）：

注意：您正在使用相同的存储库生成两个线程，这反过来将使它们使用相同的EntityManager。我怀疑EntityManager是否支持这一点，我也不确定您是否真的以这种方式获得了两个事务，但这是另一个问题。