Hibernate3 学习(十)

12．Locking

Hibernate 透过两种 Locking 机制来保证数据在操作过程中不会被干扰。

12．1悲观锁定（Pessimistic Locking）

在多个客户端可能读取同一笔数据或同时更新一笔数据的情况下，必须要有访问控制的手段，防止同一个数据被修改而造成混乱，最简单的手段就是对数据进行锁定，在自己进行数据读取或更新等动作时，锁定其它客户端不能对同一笔数据进行任何的动作。

悲观锁定（Pessimistic Locking）一如其名称所示，悲观的认定每次资料存取时，其它的客户端也会存取同一笔数据，因此对该笔数据进行锁定，直到自己操作完成后解除锁定。

悲观锁定通常透过系统或数据库本身的功能来实现，依赖系统或数据库本身提供的锁定机制，Hibernate即是如此，可以利用Query或Criteria的setLockMode()方法来设定要锁定的表或列（Row）及其锁定模式，可设定的锁定模式有以下的几个：
LockMode.UPGRADE：利用数据库的for update子句进行锁定。
LockMode.UPGRADE_NOWAIT：使用for update nowait子句进行锁定，在Oracle数据库中使用。

一个设定锁定的例子如下：

Session session = sessionFactory.openSession();

Query query = session.createQuery("from User user");

query.setLockMode("user", LockMode.UPGRADE);

List users = query.list();

...

session.close();

这个程序片段会使用以下的SQL进行查询：

Hibernate: select user0_.id as id, user0_.name as name0_, user0_.age as age0_

from user user0_ for update

也可以在使用Session的load()或是lock()时指定锁定模式以进行锁定。

另外还有三种加锁模式Hibernate内部自动对数据进行锁定，与数据库无关：
LockMode.WRITE：在insert或update时进行锁定，Hibernate会在save()方法时自动获得锁定。
LockMode.READ：在读取记录时Hibernate会自动获得锁定。
LockMode.NONE：没有锁定。

如果数据库不支持所指定的锁定模式，Hibernate会选择一个合适的锁定替换，而不是丢出一个例外。

12．2乐观锁定（Optimistic Locking）

悲观锁定假定任何时刻存取数据时，都可能有另一个客户也正在存取同一笔数据，因而对数据采取了数据库层次的锁定状态，在锁定的时间内其它的客户不能对数据 进行存取，对于单机或小系统而言，这并不成问题，然而如果是在网络上的系统，同时间会有许多联机，如果每一次读取数据都造成锁定，其后继的存取就必须等 待，这将造成效能上的问题，造成后继使用者的长时间等待。

乐观锁定（Optimistic locking）则乐观的认为资料的存取很少发生同时存取的问题，因而不作数据库层次上的锁定，为了维护正确的数据，乐观锁定使用应用程序上的逻辑实现版本控制的解决。

在不实行悲观锁定策略的情况下，数据不一致的情况一但发生，有几个解决的方法，一种是先更新为主，一种是后更新的为主，比较复杂的就是检查发生变动的数据来实现，或是检查所有属性来实现乐观锁定。

Hibernate中透过版本号检查来实现后更新为主，这也是Hibernate所推荐的方式，在数据库中加入一个version字段记录，在读取数据时 连同版本号一同读取，并在更新数据时比对版本号与数据库中的版本号，如果等于数据库中的版本号则予以更新，并递增版本号，如果小于数据库中的版本号就丢出 例外。

实际来透过范例了解Hibernate的乐观锁定如何实现，首先在数据库中新增一个表格：

CREATE TABLE user (

    id INT(11) NOT NULL auto_increment PRIMARY KEY,

    version INT,

    name VARCHAR(100) NOT NULL default '',

    age INT

);

这个user表格中的version用来记录版本号，以供Hibernate实现乐观锁定，接着设计User类别，当中必须包括version属性：

User.java

package onlyfun.caterpillar;

 

public class User {

    private Integer id;

    private Integer version; // 增加版本属性  

    private String name;

    private Integer age;

   

    public User() {

    }

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public Integer getVersion() {

        return version;

    }

 

    public void setVersion(Integer version) {

        this.version = version;

    }

   

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

   

    public Integer getAge() {

        return age;

    }

 

    public void setAge(Integer age) {

        this.age = age;

    }

}

在映射文件的定义方面，则如下所示：

User.hbm.xml

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.User"

           table="user"

           optimistic-lock="version">

          

        <id name="id" column="id" type="java.lang.Integer">

            <generator class="native"/>

        </id>

 

        <version name="version"

                 column="version"

                 type="java.lang.Integer"/>

                

        <property name="name" column="name" type="java.lang.String"/>

 

        <property name="age" column="age" type="java.lang.Integer"/>

       

    </class>

 

</hibernate-mapping>

注意<version>卷标必须出现在<id>卷标之后，接着您可以试着在数据库中新增数据，例如：

User user = new User();

user.setName("caterpillar");

user.setAge(new Integer(30));

Session session = sessionFactory.openSession();

Transaction tx =  session.beginTransaction();

session.save(user);

tx.commit();

session.close();

您可以检视数据库中的数据，每一次对同一笔数据进行更新，version字段的内容都会自动更新，接着来作个实验，直接以范例说明：

// 有使用1者开启了一个session1

Session session1 = sessionFactory.openSession();

// 在这之后，马上有另一个使用者2开启了session2

Session session2 = sessionFactory.openSession();

       

Integer id = new Integer(1);

 

// 使用者1查询数据       

User userV1 = (User) session1.load(User.class, id);

// 使用者2查询同一笔数据

User userV2 = (User) session2.load(User.class, id);

 

// 此时两个版本号是相同的

System.out.println(" v1 v2 "

                + userV1.getVersion().intValue() + " "

                + userV2.getVersion().intValue());

       

Transaction tx1 = session1.beginTransaction();

Transaction tx2 = session2.beginTransaction();

 

// 使用者1更新数据       

userV1.setAge(new Integer(31));

tx1.commit();

 

// 此时由于数据更新，数据库中的版本号递增了

// 两笔数据版本号不一样了

System.out.println(" v1 v2 "

                + userV1.getVersion().intValue() + " "

                + userV2.getVersion().intValue());

       

// userV2 的 age 资料还是旧的

// 数据更新

userV2.setName("justin");

// 因版本号比数据库中的旧

// 送出更新数据会失败，丢出StableObjectStateException例外

tx2.commit();

       

session1.close();

session2.close();

运行以下的程序片段，会出现以下的结果：

Hibernate:

select user0_.id as id0_, user0_.version as version0_0_, user0_.name as name0_0_, user0_.age as age0_0_

from user user0_ where user0_.id=?

 

Hibernate:

select user0_.id as id0_, user0_.version as version0_0_, user0_.name as name0_0_, user0_.age as age0_0_

from user user0_ where user0_.id=?

 v1 v2 0 0

 

Hibernate:

update user set version=?, name=?, age=? where id=? and version=?

 v1 v2 1 0

 

Hibernate:

update user set version=?, name=?, age=? where id=? and version=?

16:11:43,187 ERROR AbstractFlushingEventListener:277 - Could not synchronize database state with session

org.hibernate.StaleObjectStateException:

  Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [onlyfun.caterpillar.User#1]

    at org.hibernate.persister.entity.BasicEntityPersister.check(BasicEntityPersister.java:1441)

由于新的版本号是1，而userV2的版本号还是0，因此更新失败丢出StableObjectStateException，您可以捕捉这个例外作善后处理，例如在处理中重新读取数据库中的数据，同时将目前的数据与数据库中的数据秀出来，让使用者有机会比对不一致的数据，以决定要变更的部份，或者您可以 设计程序自动读取新的数据，并比对真正要更新的数据，这一切可以在背景执行，而不用让您的使用者知道。

要注意的是，由于乐观锁定是使用系统中的程序来控制，而不是使用数据库中的锁定机制，因而如果有人特意自行更新版本讯息来越过检查，则锁定机制就会无效， 例如在上例中自行更改userV2的version属性，使之与数据库中的版本号相同的话就不会有错误，像这样版本号被更改，或是由于数据是由外部系统而来，因而版本信息不受控制时，锁定机制将会有问题，设计时必须注意。

13．Validatable、Lifecycle、Interceptor

分别透过这三个接口，来进行数据验证、于 CRUD（Create Retrieve Update Delete）作对应动作、栏截动作。

13．1 Lifecycle 接口、Validatable 接口

可以在实体对象定义时实作Lifecycle接口，这个接口定义如下：

Lifecycle.java

package org.hibernate.classic;

 

import java.io.Serializable;

import org.hibernate.CallbackException;

import org.hibernate.Session;

 

public interface Lifecycle {

    public static final boolean VETO = true;

    public static final boolean NO_VETO = false;

 

    public boolean onSave(Session s) throws CallbackException;

    public boolean onUpdate(Session s) throws CallbackException;

    public boolean onDelete(Session s) throws CallbackException;

    public void onLoad(Session s, Serializable id);

}

当对象实作Lifecycle接口时，会在save()、update()、delete()、load()等方法执行之前呼叫对应的onSave()、 onUpdate()、onDelete()与onLoad()，其中onSave()、onUpdate()、onDelete()与onLoad() 若传回true或丢出CallbackException，则对应的操作中止。

可以在实体对象定义时实作Validatable接口，其定义如下：

Validatable.java

package org.hibernate.classic;

 

public interface Validatable {

    public void validate() throws ValidationFailure;

}

如果定义时实作了Validatable接口，当对象被持久化之前会呼叫validate()方法，如果丢出ValidationFailure，则验证失败，对象的数据不会储存至数据库中。

13．2 Interceptor 界面

您可以在开启Session时加载一个自订Interceptor，这个Interceptor会在对应的动作发生之前呼叫对应的方法，方法是让您定义的Interceptor实作Interceptor接口，接口的定义如下：

Interceptor.java

package org.hibernate;

 

import java.io.Serializable;

import java.util.Iterator;

 

import org.hibernate.type.Type;

 

public interface Interceptor {

    // 加载对象之前执行

    public

      boolean onLoad(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)

      throws CallbackException;

 

    // flush 时，如果发现有Dirty data，则执行此方法

    public

      boolean onFlushDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState,

                          String[] propertyNames, Type[] types) throws CallbackException;

 

    // 储存对象前执行

    public

      boolean onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)

      throws CallbackException;

 

    // 删除对象前执行

    public

      void onDelete(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types)

      throws CallbackException;

 

    // 在 flush 前执行

    public void preFlush(Iterator entities) throws CallbackException;

 

    // 在 flush 后执行

    public void postFlush(Iterator entities) throws CallbackException;

 

    // 判断传入的对象是否为 transient 状态

    public Boolean isTransient(Object entity);

 

    // flush 前呼叫这个方法判断 Dirty data

    // 传回Dirty data属性索引或null采预设行为

    public

      int[] findDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState,

                      String[] propertyNames, Type[] types);

 

    // 手动建立实体对象，如果传回 null，则使用预设的建构方法建立实例

    public Object instantiate(String entityName, EntityMode entityMode, Serializable id)

      throws CallbackException;

 

    // 传回实体名称

    public String getEntityName(Object object) throws CallbackException;

 

    // 取得实体对象

    public Object getEntity(String entityName, Serializable id) throws CallbackException;

 

    // beginTransaction() 之后执行

    public void afterTransactionBegin(Transaction tx);

 

    // 在事务完成前执行

    public void beforeTransactionCompletion(Transaction tx);

 

    // 在事务完成后执行

    public void afterTransactionCompletion(Transaction tx);

}

假设您实作了SomeInterceptor类别：

SomeInterceptor.java

package onlyfun.caterpillar;

....

public class SomeInterceptor implements Interceptor {

    ....

}

在开启Session时，可以如下加载自订的Interceptor：

SomeInterceptor someInterceptor = new SomeInterceptor();

Session session = sessionFactory.openSession(someInterceptor);