hibernate 事务处理

Hibernate的事务处理:
事务:
* 事务就是逻辑上的一组操作,要么全都成功,要么全都失败!!!

事务特性:
* 原子性:事务一组操作不可分割.
* 一致性:事务的执行前后,数据完整性要保持一致.
* 隔离性:一个事务在执行的过程中不应该受到其他事务的干扰.
* 持久性:一旦事务结束,数据就永久保存数据库.

如果不考虑事务的隔离性引发一些安全性问题:
* 5大类问题:3类读问题 2类写问题.
* 读问题:
* 脏读                  :一个事务读到另一个事务未提交数据.
* 不可重复读     :一个事务读到另一个事务已经提交数据(update),导致查询结果不一致.
* 虚读                  :一个事务读到另一个事务已经提交的数据(insert),导致查询结果不一致

* 避免三种读的问题:
* 设置事务的隔离级别:
* 未提交读:以上三种读问题 都有可能发生.
* 已提交读:避免脏读,但是不可重复读和虚读有可能发生.
* 重复读:避免脏读和不可重复读,但是虚读是有可能发生.
* 串行的:可以避免以上三种读问题.

* 在Hibernate中设置事务的隔离级别:
* 在核心配置文件中:
<property name="hibernate.connection.isolation">4</property>

写问题:丢失更新
* 解决;
* 悲观锁：当一个事务正在进行时，其他事务不允许修改数据。

@Test
/*
 * 使用悲观锁解决丢失更新
 */
public void demo1(){
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();

    // 使用悲观锁(拍他锁)
    Customer customer = (Customer) session.get(Customer.class, 3, LockMode.UPGRADE);
    customer.setAge(32);

    tx.commit();
    session.close();
}

@Test
/*
 * 使用悲观锁解决丢失更新
 */
public void demo2(){
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();

    // 使用悲观锁(拍他锁)
    Customer customer = (Customer) session.get(Customer.class, 3, LockMode.UPGRADE);
    customer.setCname("老汤姆");

    tx.commit();
    session.close();
}

* 乐观锁：

在映射文件中加一句<version name="version"/>，

在Customer实体类中加一个属性 version

标签version是固定的，name里面的属性可以随意取名，为方便区分，version更好。

@Test
/*
 * 使用乐观锁解决丢失更新
 */
public void demo3(){
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();

    Customer customer = (Customer) session.get(Customer.class, 3);
    customer.setAge(26);

    tx.commit();
    session.close();
}

@Test
/*
 * 使用乐观锁解决丢失更新
 */
public void demo4(){
    Session session = HibernateUtils.openSession();
    Transaction tx = session.beginTransaction();

    Customer customer = (Customer) session.get(Customer.class, 3);
    customer.setCname("老汤姆");

    tx.commit();
    session.close();
}

关于悲观锁和乐观锁更清晰的讲述：

悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁。

两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果经常产生冲突，上层应用会不断的进行retry，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适。

原文:http://blog.csdn.net/hongchangfirst/article/details/26004335

另外关于二级缓存，，