7.hibernate事务隔离

1. 事务具有ACID原则，各个数据库实现了这些原则(用日志实现原子性，一致性，持久性，用锁实现隔离性)
2. 隔离级别有四种(Read UnCommitted,Read Committed,Repeated Read, Serializable)，在不同的隔离级别下，有可能会出现脏读，不可重复读，幻读等现象

隔离级别	是否存在脏读	是否存在不可重复读	是否存在幻读
Read UnCommitted	Y	Y	Y
Read Committed	N	Y	Y
Repeated Read	N	N	Y
Serializable	N	N	N

脏读举例：

1. Mary的原工资为1000, 财务人员将Mary的工资改为了8000(但未提交事务)
2. Mary读取自己的工资 ,发现自己的工资变为了8000，欢天喜地！
3. 而财务发现操作有误，回滚了事务,Mary的工资又变为了1000像这样,Mary记取的工资数8000是一个脏数据。

不可重复读：

1. 在事务1中，Mary 读取了自己的工资为1000,操作并没有完成
2. 在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.
3. 在事务1中，Mary 再次读取自己的工资时，工资变为了2000

幻读

目前工资为1000的员工有10人。

1. 事务1,读取所有工资为1000的员工。
2. 这时事务2向employee表插入了一条员工记录，工资也为1000
3. 事务1再次读取所有工资为1000的员工 共读取到了11条记录，

本文就是用hibernate，然后修改mysql数据库中的隔离级别来重现上述现象，以此来深刻体会事务的隔离性

实体类：

    package entity;
    
    import java.util.Date;
    
    public class User {
        private int id;
        private String userName;
        private Date addtime;
    
        public Date getAddtime() {
            return addtime;
        }
    
        public void setAddtime(Date addtime) {
            this.addtime = addtime;
        }
    
        public User(){}
    
        
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }   
    }

映射文件：

    <?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="entity.User" table="_user" >
            <id name="id">
                <generator class="native" />
            </id>
            <property name="userName" />
            <property name="addtime" type="time" />
        </class>    
    </hibernate-mapping>

单元测试：

package entity;

import java.util.Date;
import java.util.List;

import org.hibernate.classic.Session;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;

import junit.framework.TestCase;
import util.hibernateUtil;

/**
 * 测试目的： 1. 不同的数据库实现锁(隔离)的机制不同，在不同机制下，重现脏读，不可重复读，幻读等现象 2. 利用phpunit实现多事务争抢同一数据现象
 * 3. 修改mysql数据库隔离级别
 * 
 * @author arkulo
 *
 */

public class TestTransaction extends TestCase {

    // 1. 改变数据库隔离级别，至Read UnCommitted
    // 查询mysql数据库的隔离级别：select @@global.tx_isolation,@@tx_isolation;
    // 修改mysql数据库当前会话隔离级别：set session transaction isolation level read
    // uncommitted;
    //
    // 问题：在数据库中修改的时候，该session会话级别的隔离是不行的，只能改global级别的隔离
    // 这个函数是查询当前数据库的隔离级别
    // 给user表中初始化一条数据
    public void getACID() {
        Session session = null;
        try {
            session = hibernateUtil.getSession();
            session.beginTransaction();

            List res = session.createSQLQuery("select @@tx_isolation").list();
            for (Object i : res) {
                System.out.println("隔离级别：" + i.toString());
            }

            User user = new User();
            user.setUserName("王蕊");
            user.setAddtime(new Date());
            // id策略是native，在save之后就立刻发出sql语句，这里设断点停住，不提交commit
            session.save(user);

            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            hibernateUtil.closeSession(session);
        }

    }

    // 重现脏读：在一个事务未提交的时候，另外一个事务就可以读取到该事务中的新增数据
    // 2. 启动第一个进程做断点，到save后停止，启动另外一个进程，直接执行，看看能不能读到数据库中的数据
    public void test1() {
        // getACID();
        System.out.println("-------------------------------------");
        Session session = null;
        try {
            session = hibernateUtil.getSession();
            session.beginTransaction();

            User user = (User) session.load(User.class, 1);
            System.out.println("用户名：" + user.getUserName());
            user.setUserName("李四");
            session.update(user);

            session.flush();
            // 单步断点，停在这里不提交，但是需要flush
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            hibernateUtil.closeSession(session);
        }
    }

    // 再启动一个进程，运行这个函数去读取user表中的第一条数据，这时候就会发现
    // 1. 隔离级别是READ UNCOMMITED，读取事务并没有被阻塞
    // 2. 这里读出的用户名是李四，属于脏读
    public void test1_1() {
        Session session = null;
        try {
            session = hibernateUtil.getSession();
            session.beginTransaction();

            User user = (User) session.get(User.class, 1);
            System.out.println("用户名：" + user.getUserName());

            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            hibernateUtil.closeSession(session);
        }
    }

    // －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

    // 这里展示不可重复读问题
    public void test2() {
        Session session = null;
        try {
            session = hibernateUtil.getSession();
            session.beginTransaction();

            User user = (User) session.get(User.class, 1);
            System.out.println("用户名：" + user.getUserName());

            // 因为get函数会缓存对象到一级缓存，这里需要把缓存清理掉
            // 如果不清理，系统会采用缓存中的数据，而下面的get函数就不会发出sql语句查询
            session.evict(user);

            // 在这里断点停住，当另外一个用户的事务结束之后，这里再继续
            User user1 = (User) session.get(User.class, 1);
            // 这里读出的用户名是李四！！
            System.out.println("用户名：" + user1.getUserName());

            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            hibernateUtil.closeSession(session);
        }
    }

    // 当test2第一个查询执行完毕之后,test2_1修改用户名，然后再执行test2中的第二个查询
    public void test2_1() {
        Session session = null;
        try {
            session = hibernateUtil.getSession();
            session.beginTransaction();

            User user = (User) session.get(User.class, 1);
            user.setUserName("李四");

            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            hibernateUtil.closeSession(session);
        }
    }

    // －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

    // 以下部分是幻读的重现
    public void test3() {
        Session session = null;
        try {
            session = hibernateUtil.getSession();
            session.beginTransaction();

            // 以下是两种查询总数的方式，都会用到uniqueResult()
            // int acount = ((Long)session.createQuery("select count(*) from
            // User").uniqueResult()).intValue();
            int acount = ((Number) session.createCriteria("entity.User").setProjection(Projections.rowCount())
                    .uniqueResult()).intValue();
            System.out.println("数量：" + acount);

            // 因为查询的不是对象，因此不会被一级缓存，这里断点停住
            // 这里打印的数据库记录比上面多了1条，好像是幻觉一样
            int acount1 = ((Number) session.createCriteria("entity.User").setProjection(Projections.rowCount())
                    .uniqueResult()).intValue();
            System.out.println("数量：" + acount1);

            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            hibernateUtil.closeSession(session);
        }
    }

    // 新起一个事务做插入
    public void test3_1() {
        Session session = null;
        try {
            session = hibernateUtil.getSession();
            session.beginTransaction();

            User user = new User();
            user.setUserName("李四");
            user.setAddtime(new Date());
            session.save(user);

            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            hibernateUtil.closeSession(session);
        }
    }

}