使用 @Lock 注解实现Spring JAP锁

http://blog.youkuaiyun.com/terry_long/article/details/54291455

JPA 2.0增加了6种新的锁模式，其中两个是乐观锁。JPA 2.0也允许悲观锁，并增加了3种悲观锁，第6种锁模式是无锁。 

下面是新增的两个乐观锁模式： 

1、OPTIMISTIC：它和READ锁模式相同，JPA 2.0仍然支持READ锁模式，但明确指出在新应用程序中推荐使用OPTIMISTIC。 

2、OPTIMISTIC_FORCE_INCREMENT：它和WRITE锁模式相同，JPA 2.0仍然支持WRITE锁模式，但明确指出在新应用程序中推荐使用OPTIMISTIC_FORCE_INCREMENT。 

下面是新增的三个悲观锁模式： 

1、PESSIMISTIC_READ：只要事务读实体，实体管理器就锁定实体，直到事务完成锁才会解开，当你想使用重复读语义查询数据时使用这种锁模式，换句话说就是，当你想确保数据在连续读期间不被修改，这种锁模式不会阻碍其它事务读取数据。 

2、PESSIMISTIC_WRITE：只要事务更新实体，实体管理器就会锁定实体，这种锁模式强制尝试修改实体数据的事务串行化，当多个并发更新事务出现更新失败几率较高时使用这种锁模式。 

3、PESSIMISTIC_FORCE_INCREMENT：当事务读实体时，实体管理器就锁定实体，当事务结束时会增加实体的版本属性，即使实体没有修改。 

最后一种是NONE,也就是无锁。

可以通过@Lock注解来进行锁模式的指定，我们来看一下@Lock 注解源码：

[java] view plain copy

1. @Target({ ElementType.METHOD, ElementType.ANNOTATION_TYPE })  
2. @Retention(RetentionPolicy.RUNTIME)  
3. @Documented  
4. public @interface Lock {  
5.   
6.     /** 
7.      * The {@link LockModeType} to be used when executing the annotated query or CRUD method. 
8.      *  
9.      * @return 
10.      */  
11.     LockModeType value();  
12. }  

LockModeType就是指定所模式的枚举了，看一下它的 的源码：

[java] view plain copy

1. public enum LockModeType {  
2.     /** 
3.      *  Synonymous with <code>OPTIMISTIC</code>. 
4.      *  <code>OPTIMISTIC</code> is to be preferred for new 
5.      *  applications. 
6.      * 
7.      */  
8.     READ,  
9.   
10.     /** 
11.      *  Synonymous with <code>OPTIMISTIC_FORCE_INCREMENT</code>. 
12.      *  <code>OPTIMISTIC_FORCE_IMCREMENT</code> is to be preferred for new 
13.      *  applications. 
14.      * 
15.      */  
16.     WRITE,  
17.   
18.     /** 
19.      * Optimistic lock. 
20.      * 
21.      * @since Java Persistence 2.0 
22.      */  
23.     OPTIMISTIC,  
24.   
25.     /** 
26.      * Optimistic lock, with version update. 
27.      * 
28.      * @since Java Persistence 2.0 
29.      */  
30.     OPTIMISTIC_FORCE_INCREMENT,  
31.   
32.     /** 
33.      * 
34.      * Pessimistic read lock. 
35.      * 
36.      * @since Java Persistence 2.0 
37.      */  
38.     PESSIMISTIC_READ,  
39.   
40.     /** 
41.      * Pessimistic write lock. 
42.      * 
43.      * @since Java Persistence 2.0 
44.      */  
45.     PESSIMISTIC_WRITE,  
46.   
47.     /** 
48.      * Pessimistic write lock, with version update. 
49.      * 
50.      * @since Java Persistence 2.0 
51.      */  
52.     PESSIMISTIC_FORCE_INCREMENT,  
53.   
54.     /** 
55.      * No lock. 
56.      * 
57.      * @since Java Persistence 2.0 
58.      */  
59.     NONE  
60. }  

来写一个简单的例子（不完全代码）：

@Lock注解需要添加在Repository 层，也就是Hibernate的DAO层，如下：

[java] view plain copy

1. public interface TestRepository extends  
2.         JpaRepository<TestObject, String>,  
3.         JpaSpecificationExecutor<TestObject> {  
4.   
5.     @Lock(value = LockModeType.PESSIMISTIC_READ)  
6.     @Query(value = "select o from TestObject where o.id= :id ")  
7.     public TestObject getByIdForUpdate(@Param("id") long id);  
8.   
9. }  

这里用到了@Query 注解，只需要定义接口就可以了，spring会根据注解里的HQL语句自动生成实现。

对Repository的调用一般放在service层，调用方法必须被事务包裹，不然启动会报错。

[java] view plain copy

1. public interface MyTestService{  
2. /** 
3. * 定义接口 
4. */  
5. public TestObject updateObjStatus(long id,String status);  
6. }  
7.   
8. public class MyTestServiceImpl{  
9. @Autowired  
10. private TestRepository repos;  
11.   
12. /** 
13. * 实现一个带锁的更新方法 
14. */  
15. @Transactional  
16. @Override  
17. public TestObject updateObjStatus(long id,String status){  
18. TestObject  obj = repos.getByIdForUpdate(id);  
19. if(null == obj ){  
20. throw new RuntimeException("TestObject id = "+id+",not found！");  
21. }  
22. if(status.equals(obj.getStatus())){  
23. throw new RuntimeException("TestObject id = "+id+",status is alread be："+status+",update fail!");  
24. }  
25. obj.setStatus(status);  
26. repos.save(obj);  
27.   
28. }  
29. }  

在上面的例子中，我们尝试更新TestObject 对象的status，更新之前先将数据查询出来加上行级锁，确保某个线程在更新之时数据不会被其他线程修改掉，更新之前也进行判断，如果发现数据已被更新就跑出去异常结束更新。这样在多个线程同时对TestObject 对象进行更新时，最终只有一个线程会更新成功。