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 已经被标记为过时了，可是为啥没有提示其替代方法呢？