Hibernate各类概念-乐观锁原理以及其配置方法

Hibernate使用乐观锁来处理脏数据问题

• 首先看不使用乐观锁的情况
  
  故意创造一个场景来制造脏数据。
  
  1. 通过session1得到id=1的对象 product1
  2. 在product1原来价格的基础上增加1000
  3. 更新product1之前，通过session2得到id=1的对象product2
  4. 在product2原来价格的基础上增加1000
  5. 更新product1
  6. 更新product2
  
  最后结果是product的价格只增加了1000，而不是2000
  
  

  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.cfg.Configuration;
   
  import com.how2java.pojo.Product;
   
  public class TestHibernate {
      public static void main(String[] args) {
          SessionFactory sf = new Configuration().configure().buildSessionFactory();
          Session s1 = sf.openSession();
          Session s2 = sf.openSession();
   
          s1.beginTransaction();
          s2.beginTransaction();
   
          Product p1 = (Product) s1.get(Product.class, 1);
          System.out.println("产品原本价格是: " + p1.getPrice());
   
          p1.setPrice(p1.getPrice() + 1000);
   
          Product p2 = (Product) s2.get(Product.class, 1);
          p2.setPrice(p2.getPrice() + 1000);
   
          s1.update(p1);
          s2.update(p2);
   
          s1.getTransaction().commit();
          s2.getTransaction().commit();
   
          Product p = (Product) s1.get(Product.class, 1);
   
          System.out.println("经过两次价格增加后，价格变为: " + p.getPrice());
   
          s1.close();
          s2.close();
   
          sf.close();
      }
   
  }

• 修改配置文件 Product.hbm.xml
  
  

  <version name="version" column="ver" type="int"></version>

  增加一个version字段，用于版本信息控制。这就是乐观锁的核心机制。
  
  比如session1获取product1的时候，version=1。 那么session1更新product1的时候，就需要确保version还是1才可以进行更新，并且更新结束后，把version改为2。
  
  注意： version元素必须紧跟着id后面，否则会出错。
  

  <?xml version="1.0"?>
  <!DOCTYPE hibernate-mapping PUBLIC
          "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
   
  <hibernate-mapping package="com.how2java.pojo">
      <class name="Product" table="product_">
          <id name="id" column="id">
              <generator class="native">
              </generator>
          </id>
          <!--version元素必须紧挨着id后面  -->
          <version name="version" column="ver" type="int"></version>
          <property name="name" />
          <property name="price" />
   
          <many-to-one name="category" class="Category" column="cid" />
   
          <set name="users" table="user_product" lazy="false">
              <key column="pid" />
              <many-to-many column="uid" class="User" />
          </set>
   
      </class>
   
  </hibernate-mapping>

• 修改 Product.java
  
  增加version属性
  

  import java.util.Set;
    
  public class Product {
      int id;
      String name;
      float price;
      Category category;
      int version;
      public int getVersion() {
          return version;
      }
      public void setVersion(int version) {
          this.version = version;
      }
      Set<User> users;
    
      public Set<User> getUsers() {
          return users;
      }
      public void setUsers(Set<User> users) {
          this.users = users;
      }
      public Category getCategory() {
          return category;
      }
      public void setCategory(Category category) {
          this.category = category;
      }
      public int getId() {
          return id;
      }
      public void setId(int id) {
          this.id = id;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public float getPrice() {
          return price;
      }
      public void setPrice(float price) {
          this.price = price;
      }
        
  }

• 重新运行一样的代码
  
  做同样的业务就会抛出异常，提示该行已经被其他事务删除或者修改过了，本次修改无法生效。
  这样就保证了数据的一致性。
  
  

  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.cfg.Configuration;
   
  import com.how2java.pojo.Product;
   
  public class TestHibernate {
      public static void main(String[] args) {
          SessionFactory sf = new Configuration().configure().buildSessionFactory();
          Session s1 = sf.openSession();
          Session s2 = sf.openSession();
   
          s1.beginTransaction();
          s2.beginTransaction();
   
          Product p1 = (Product) s1.get(Product.class, 1);
          System.out.println("产品原本价格是: " + p1.getPrice());
   
          p1.setPrice(p1.getPrice() + 1000);
   
          Product p2 = (Product) s2.get(Product.class, 1);
          p2.setPrice(p2.getPrice() + 1000);
   
          s1.update(p1);
          s2.update(p2);
   
          s1.getTransaction().commit();
          s2.getTransaction().commit();
   
          Product p = (Product) s1.get(Product.class, 1);
   
          System.out.println("经过两次价格增加后，价格变为: " + p.getPrice());
   
          s1.close();
          s2.close();
   
          sf.close();
      }
   
  }

• 原理
  
  1. 假设数据库中产品的价格是10000，version是10
  2. session1,session2分别获取了该对象
  3. 都修改了对象的价格
  4. session1试图保存到数据库，检测version依旧=10，成功保存，并把version修改为11
  5. session2试图保存到数据库，检测version=11，说明该数据已经被其他人动过了。 保存失败，抛出异常