Hibernate：不容易理解的 lock 和 merge

背景

lock 和 merge 在字面上很容易理解它们的语义，不过它们的实际行为所代表的语义范围要大一点，本文就简单的记录下来，还请朋友们多批评和指正。

Lock

官方的注释

     /**
      * Obtain the specified lock level upon the given object. This may be used to
      * perform a version check (<tt>LockMode.READ</tt>), to upgrade to a pessimistic
      * lock (<tt>LockMode.PESSIMISTIC_WRITE</tt>), or to simply reassociate a transient instance
      * with a session (<tt>LockMode.NONE</tt>). This operation cascades to associated
      * instances if the association is mapped with <tt>cascade="lock"</tt>.
      *
      * @param object a persistent or transient instance
      * @param lockMode the lock level
      *
      * @deprecated instead call buildLockRequest(LockMode).lock(object)
      */
     @Deprecated
     public void lock(Object object, LockMode lockMode);

根据注释可以知道其有三个职责：

1. 执行乐观锁检查，然后执行。
2. 提升为悲观锁，然后执行。
3. 将一个透明的实例（脱钩）和 Session 进行关联。

注意：1 和 2 都会执行 3。

LockMode.NONE

测试代码

 package demo;
 
 import model.*;
 import org.hibernate.*;
 
 /*
  * lock 会将处于 transparent 状态的对象变为 persisted。
  */
 public class LockDemo implements Demo {
 
     @Override
     public void run() {
         SessionHelper.read(new SessionAction() {
             User user = UserHelper.createUser();
 
             @SuppressWarnings("deprecation")
             @Override
             public void action(Session session) {
                 session.lock(user, LockMode.NONE);
 
                 // 为了测试执行 lock 后实例是否变为持久化状态。
                 user = (User) session.get(User.class, user.getId());
             }
 
         });
     }
 }

说明：上例执行后没有任何 SQL 输出。

LockMode.READ

测试代码

 package demo;
 
 import model.*;
 import org.hibernate.*;
 
 /*
  * lock 会将处于 transparent 状态的对象变为 persisted。
  */
 public class LockDemo implements Demo {
 
     @Override
     public void run() {
         SessionHelper.read(new SessionAction() {
             User user = UserHelper.createUser();
 
             @SuppressWarnings("deprecation")
             @Override
             public void action(Session session) {
                 session.lock(user, LockMode.READ);
 
                 // 为了测试执行 lock 后实例是否变为持久化状态。
                 user = (User) session.get(User.class, user.getId());
             }
 
         });
     }
 }

输出结果

     /* READ lock model.User */ select
         Id
     from
         Users
     where
         Id =?
         and Version =?

说明：上例执行了乐观锁检查，我还没有测试检查失败的场景，估计是会抛出异常。

LockMode.UPGRADE

测试代码

 package demo;
 
 import model.*;
 import org.hibernate.*;
 
 /*
  * lock 会将处于 transparent 状态的对象变为 persisted。
  */
 public class LockDemo implements Demo {
 
     @Override
     public void run() {
         SessionHelper.read(new SessionAction() {
             User user = UserHelper.createUser();
 
             @SuppressWarnings("deprecation")
             @Override
             public void action(Session session) {
                 session.lock(user, LockMode.UPGRADE);
 
                 // 为了测试执行 lock 后实例是否变为持久化状态。
                 user = (User) session.get(User.class, user.getId());
             }
 
         });
     }
 }

输出结果

     /* UPGRADE lock model.User */ select
         Id
     from
         Users
     where
         Id =?
         and Version =? for update

说明：上例将对象对应的数据库记录升级为悲观锁，由此可以保证修改的串行化。

Merge

官方注释

     /**
      * Copy the state of the given object onto the persistent object with the same
      * identifier. If there is no persistent instance currently associated with
      * the session, it will be loaded. Return the persistent instance. If the
      * given instance is unsaved, save a copy of and return it as a newly persistent
      * instance. The given instance does not become associated with the session.
      * This operation cascades to associated instances if the association is mapped
      * with {@code cascade="merge"}
      * <p/>
      * The semantics of this method are defined by JSR-220.
      *
      * @param object a detached instance with state to be copied
      *
      * @return an updated persistent instance
      */
     public Object merge(Object object);

根据注释可以知道 merge 有两个职责：

1. 如果对象为 unsaved，对对象的拷贝执行 save 方法，返回拷贝的对象。
2. 如果对象为 detached，将对象的状态拷贝到和对象的标识一样的持久化对象中，如果持久化对象不存在，就执行 get 方法将其加载。

detached 对象测试

测试代码

 package demo;
 
 import model.*;
 import org.hibernate.*;
 
 /*
  * merge 不会将参数变为持久化状态，而是使用参数修改 session 中的持久化对象，如果 session 中不包含持久化
  * 对象，就从数据库中加载一个，如果对象为 unsaved 状态，就对其拷贝执行 save。
  */
 public class MergeDemo implements Demo {
 
     @Override
     public void run() {
         SessionHelper.execute(new SessionAction() {
             User user = UserHelper.createUser();
 
             @Override
             public void action(Session session) {
                 User newUser = new User();
                 newUser.setId(user.getId());
                 newUser.setUsername("shijiucha");
                 newUser.setPassword(user.getPassword());
                 newUser.setVersion(user.getVersion());
 
                 session.merge(newUser);
             }
 
         });
     }
 }

输出结果

 begin transaction
 action
 Hibernate:
     /* load model.User */ select
         user0_.Id as Id1_2_0_,
         user0_.Version as Version2_2_0_,
         user0_.Username as Username3_2_0_,
         user0_.Password as Password4_2_0_
     from
         Users user0_
     where
         user0_.Id=?
 flush and commit
 Hibernate:
     /* update
         model.User */ update
             Users
         set
             Version=?,
             Username=?,
             Password=?
         where
             Id=?
             and Version=?

说明：上例先执行了 select 语句，然后执行了合并过程，因为有修改，在 flush 的时候产生了 update 语句。

unsaved 对象测试

测试代码

 package demo;
 
 import model.*;
 import org.hibernate.*;
 
 /*
  * merge 不会将参数变为持久化状态，而是使用参数修改 session 中的持久化对象，如果 session 中不包含持久化
  * 对象，就从数据库中加载一个，如果对象为 unsaved 状态，就对其拷贝执行 save。
  */
 public class MergeDemo implements Demo {
 
     @Override
     public void run() {
         SessionHelper.execute(new SessionAction() {
             User user = UserHelper.createUser();
 
             @Override
             public void action(Session session) {
                 User newUser = new User();
                 newUser.setId(user.getId());
                 newUser.setUsername("shijiucha");
                 newUser.setPassword(user.getPassword());
                 //newUser.setVersion(user.getVersion());
 
                 session.merge(newUser);
             }
 
         });
     }
 }

输出结果

 begin transaction
 action
 Hibernate:
     /* insert model.User
         */ insert
         into
             Users
             (Version, Username, Password)
         values
             (?, ?, ?)
 flush and commit

说明：上例只执行了 insert 语句，因为 user 是 unsaved 状态。

备注

hibernate 的注释写的真是漂亮。

另外说一句：lock 已经被标记为过时了，可是为啥没有提示其替代方法呢？