【Hibernate步步为营】--锁机制详解

时间：2022-04-21 15:43:16

       上篇文章详细讨论了hql的各种查询方法，在讨论过程中写了代码示例，hql的查询方法类似于sql，查询的方法比较简单，有sql基础的开发人员在使用hql时就会变得相当的简单。Hibernate在操作数据库的同时也提供了对数据库操作的限制方法，这种方法被称为锁机制，Hibernate提供的锁分为两种一种是乐观锁，另外一种是悲观锁。通过使用锁能够控制数据库的并发性操作，限制用户对数据库的并发性的操作。


一、锁简介


       锁能控制数据库的并发操作，通过使用锁来控制数据库的并发操作，Hibernate提供了两种锁来控制数据库的操作，分别是乐观锁和悲观锁。

       乐观锁：大多数是采用数据版本的方式实现，一般在数据库中加入一个version字段，在读取数据的时候将version取出来，在保存数据的时候判断version的值是否小于数据库中的version值，如果小于不会更新，否则可更新数据库。

       悲观锁：通常是由数据库机制实现的，在整个过程中把数据锁住（查询时），只要事务不释放（提交/回滚）那么任何用户都不能查看和修改，通过使用LockMode来控制对数据库的操作。

 

二、乐观锁


       乐观锁是通过在数据库中添加一个名为version的字段来实现每次对数据的校验，在每次操作数据库的时候会自动更新version的值，这样每次操作的version值是不一样的，所以如果有并发操作时将会首先校验version值是否小于数据库的version值，如果小于的话不会更新数据库，它的具体使用方法如下示例：

 

  2.1 映射实体Inventory.java


       该类是映射的实体类，其中的属性quantity是数字的个数，在下面演示的示例中通过操作quantity来更新数据库的信息，另外的version字段是数据库信息的版本号，能通过校验来实现控制数据库的操作，它的具体控制方法要在映射文件中编写实现。

package com.src.hibernate;

public class Inventory {

//主键id，标识号
private String itemNo;
public String getItemNo() {
return itemNo;
}
public void setItemNo(String itemNo) {
this.itemNo = itemNo;
}

//列表名称
private String itemName;
public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}

//个数
private int quantity;
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}

        //版本号
        private int version;
        public int getVersion() {
               return version;
        }
        public void setVersion(int version) {
               this.version = version;
        }
 }

     2.2  映射文件


        在映射文件中需要添加<version>字段来实现对数据库版本号的映射，该标签的name属性要设置为对应实体中的version字段，这样在操作数据库时它会自动校验数据库版本号来限制对数据的操作。

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.src.hibernate.Inventory" table="t_inventory">
<id name="itemNo">
<generator class="assigned"/>
</id>
<version name="version"/>
<property name="itemName" type="string"/>
<property name="quantity" type="integer"/>
</class>
</hibernate-mapping>

   2.3  数据操作


        测试上面的示例，在程序中添加了两个方法来加载并修改数据，其中的testLoad1()方法首先加载数据库中的数据，并修改字段Quantity的值，修改后保存数据，这时要设置断点，在提交事务时设置断点，停止对数据库的提交操作，此时执行testLoad2()方法，将会发出错误信息，不能更新数据库操作。

public void testLoad1(){
Session session=null;
try{
//创建session对象
session=HibernateUtils.getSession();
//开启事务
session.beginTransaction();
Inventory inven=(Inventory)session.load(Inventory.class, "1001");
System.out.println("p1-->name:"+inven.getItemName());
inven.setQuantity(inven.getQuantity()-200);
session.save(inven);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
public void testLoad2(){
Session session=null;
try{
//创建session对象
session=HibernateUtils.getSession();
//开启事务
session.beginTransaction();
Inventory inven=(Inventory)session.load(Inventory.class, "1001");

System.out.println("p2-->name:"+inven.getItemName());
inven.setQuantity(inven.getQuantity()-200);
session.save(inven);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}

      在不停止testLoad1()方法时执行testLoad2()方法，Hibernate发出如下语句，该语句说明testLoad2已经修改了数据库中的数据，但是testLoad1也在修改只是没有提交。 

Hibernate: select inventory0_.itemNo as itemNo0_0_, inventory0_.version as version0_0_, inventory0_.itemName as itemName0_0_, inventory0_.quantity as quantity0_0_ from t_inventory inventory0_ where inventory0_.itemNo=?
p2-->name:zhangsan
Hibernate: update t_inventory set version=?, itemName=?, quantity=? where itemNo=? and version=?

     testLoad2()提交更改后，接下来运行testLoad1()的断点，将会发出： Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect) 的错误，说明两个同时在修改同一条数据，导致了并发操作，发出了错误提示。


 三、悲观锁


     悲观锁和乐观锁不同，它是通过数据库机制限制对数据库的操作的，通过使用方法的LockMode参数来配置对数据库的并发操作，在一次访问过程中将会把数据锁住（查询时），只要事务不提交那么任何用户都不能查看和修改，其它用户操作时将会被阻塞，不能同时操作，需要等待第一次访问完成后再进行其它的操作。具体方法如下示例。


  3.1 实体Inventory.java


     实体内容和乐观锁相同，不同的是在实体中不需要添加版本号属性，因为它不是通过判断版本号来限制操作的。

package com.src.hibernate;

public class Inventory {

//主键id，标识号
private String itemNo;
public String getItemNo() {
return itemNo;
}
public void setItemNo(String itemNo) {
this.itemNo = itemNo;
}

//列表名称
private String itemName;
public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}

//个数
private int quantity;
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
}

  3.2 映射文件


       实体对应的映射文件也相当的简单，只需要配置相应的映射即可，没有其它复杂的操作，如下代码：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.src.hibernate.Inventory" table="t_inventory">
<id name="itemNo">
<generator class="assigned"/>
</id>

<property name="itemName" type="string"/>
<property name="quantity" type="integer"/>
</class>
</hibernate-mapping>

 3.3 测试代码


      这里采用两个方法来测试操作，其中的testLoad1()方法首先查询数据然后修改数据，testLoad2()也是查询和修改数据，如下代码：

public void testLoad1(){
Session session=null;
try{
//创建session对象
session=HibernateUtils.getSession();
//开启事务
session.beginTransaction();
Inventory inven=(Inventory)session.load(Inventory.class, "1001",LockMode.UPGRADE);
System.out.println("p1-->name:"+inven.getItemName());

inven.setQuantity(inven.getQuantity()-200);
session.save(inven);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
public void testLoad2(){
Session session=null;
try{
//创建session对象
session=HibernateUtils.getSession();
//开启事务
session.beginTransaction();
Inventory inven=(Inventory)session.load(Inventory.class, "1001",LockMode.UPGRADE);

System.out.println("p2-->name:"+inven.getItemName());
inven.setQuantity(inven.getQuantity()-200);
session.save(inven);
session.getTransaction().commit();
}catch(Exception e){
e.printStackTrace();
session.getTransaction().rollback();
}finally{
HibernateUtils.closeSession(session);
}
}

      演示并发操作时在testLoad1()方法的打印处设置相应的断点，然后启动Debug调试，运行到断点后停止，此时运行testLoad2()方法，实现了对数据库的并发操作，在运行testLoad2()方法时Hibernate发出了SQL语句，但是却一直不能查询和检索数据，因为数据库中加了悲观锁，数据库限制了并发性的操作，所以Hibernate只是发出了命令但是一直没有操作权限，也就是说testLoad2()方法在执行时遭到了阻塞，操作被压到堆栈中等待上次的完成。当testLoad1()方法执行完后，将会从堆栈中继续获取testLoad2()的操作命令，这种乐观锁不仅限制了对数据的操作而且还能保证数据的完整性。


结语


      Hibernate的锁机制限制了数据库的并发性的操作，功能很强大，在使用时建议使用悲观锁，因为悲观锁使用的是数据库的机制，限制彻底，而且能确保数据的完整性。在使用这两种锁时各有优缺点，大数据量建议采用乐观锁，它会直接提示错误，性能上会高于悲观锁，悲观锁会加大数据库的负担，大数据量的话容易出现问题。


标签：

相关文章