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 已經被標記為過時了，可是為啥沒有提示其替代方法呢？