Hibernate事务

JDBCTransaction 

单个数据库（一个SesisonFactory对应一个数据库），由JDBC实现。

Session session = null;
Transaction tx =null;
try {
session = sessionFactory.openSession();
tx = session.beginTransaction();//相当于JDBC的connection.setAutoCommit(false);
//process
tx.commit();//相当于JDBC的connection.commit();
} catch(HibernateException e){
if(tx != null)tx.rollback();//相当于JDBC的connection.rollback();
                 throw e;
}finally {
if (session != null)session.close();
}

  

JTATransaction（分布式事务，垮数据库，比如说银行转账，就需要这种跨数据库的事务来操作）

可以简单的理解成跨数据库的事物，由应用JTA 容器实现；使用JTATransaction需要配置hibernate.transaction.factory_class参数，该参数缺省值 是org.hibernate.transaction. JDBCTransactionFactory，当使用JTATransaction时需要将该参数改成org.hibernate.transaction.JTATransactionFactory，并配置jta.UserTransaction参数JNDI名(Hibernate在启动JTATransaction时要用该值到JNDI的上下文Context中去找javax.transaction.UserTransaction)。

javax.transaction.UserTransactin tx = context.lookup(“jndiName”);
try{
tx.begin();
//多个数据库的session操作;
//session1….
//session2….
tx.commit();
}catch(Exception e){
tx.rollback();
        throw e;
}

 
session context和事务边界

事务边界：即事务开启，提交，关闭这些代码的位置。

mvc三层架构的思想上，事务边界的处理应该放在业务逻辑层中，但是Transaction对象是dao层的，所以要采用spring这种框架来实现明确的mvc分层。

Open session in view解决事务边界问题和数据懒加载问题。

Open session in view带来的问题：

session和transaction的时间延长。如果对数据加锁那就更长时间占用对象，session延长对内存的占用时间更长，对内存大小要求更大，且和数据库长时间交互，数据库的并发能力降低。

 

 

用current_session_context_class属性来定义context（用sessionFactory.getCurrentSession()来获得session），其值为：

1.thread：ThreadLocal来管理Session实现多个操作共享一个Session，避免反复获取Session，并控制事务边界，此时session不能调用close当commit或rollback的时候session会自动关闭(connection.release_mode:after_transaction)。Open session in view：在生成（渲染）页面时保持 session打开。

2.jta：由JTA事务管理器来管理事务(connection.release_mode:after_statement)。

用图理解：

从图中可以显示：客户端看到viewHTML时session还没有关闭，session要消息4后Filter中关闭。

把session的范围扩大到整个请求的范围内，这样在一方面很好的解决了懒加载session关闭的问题，另一方面一次请求变成了一个事务，那么用户做的更新操作对数据库来说都是一条sql语句了。

但是放大了session范围，如果网速比较慢，那么session就会一直打开，一级缓存的数据得不到释放，还有事务本应当在业务逻辑层开启关闭的，也放大到了整个请求。

code：

HibernateUtil.java

 

package cn.itcast.hibernate;
import java.io.Serializable;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
//工具类一般不需要更改，所以final
public final class HibernateUtil {
	private static SessionFactory sessionFactory;
	private static ThreadLocal session = new ThreadLocal();//把ThreadLocal当成一个Map容器
    //禁止别的类new
	private HibernateUtil() {
	}

	static {
		Configuration cfg = new Configuration();
		cfg.configure();
		sessionFactory = cfg.buildSessionFactory();
	}

	public static Session getThreadLocalSession() {
		Session s = (Session) session.get();//ThreadLocal的key是默认的，可以把key理解为当前线程
		if (s == null) {
			s = getSession();
			session.set(s);
		}
		return s;
	}

	public static void closeSession() {
		Session s = (Session) session.get();
		if (s != null) {
			s.close();
			session.set(null);
		}
	}

	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}
}

 OpenSessionInView.java过滤器。负责从ThreadLocal中获得session和关闭session

 

package com.taobao.hibernate;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class OpenSessionInView implements Filter {

	public void destroy() {
	}

	public void doFilter(ServletRequest arg0, ServletResponse arg1,
			FilterChain arg2) throws IOException, ServletException {
		Session session = null;
		Transaction tx = null;
		try {
			session = HibernateUtil.getThreadLocalSession();
			tx = session.beginTransaction();
			arg2.doFilter(arg0, arg1);
			tx.commit();
		} catch (Exception e) {
			if (tx != null)
				tx.rollback();
			throw new RuntimeException(e.getMessage(), e);
		} finally {
			HibernateUtil.closeSession();
		}

	}

	public void init(FilterConfig arg0) throws ServletException {
	}

}

 然后在业务层可以处理多个业务数据，在dao层获得过滤器打开的session处理数据和数据库的交互。

悲观锁和乐观锁

悲观锁由数据库来实现，从读取的时候开始加锁，直到修改完成。

缺点：读取完以后，用户修改过程缓慢，造成同步性降低。

乐观锁hibernate用version和timestamp来实现。两人同时编辑时候，假设获取的版本号都为1，编辑完提交的时候，版本号为2，第一个提交完以后，数据库版本号为2，第二个提交的时候对比版本号就会报错。 

code：

给Users加上版本号

Users.java

 

import java.util.Date;  
  
public class Users {  
    private int id;  
    private String name;  
    private Date birthday;  
    private int ver;  
      
    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 Date getBirthday() {  
        return birthday;  
    }  
    public void setBirthday(Date birthday) {  
        this.birthday = birthday;  
    }  
    public void setVer(int ver) {  
        this.ver = ver;  
    }  
    public int getVer() {  
        return ver;  
    }  
}  

 Users.hbm.xml

 

<?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 package="com.taobao.hibernate.domain">
	<class name="User">
		<id name="id">
			<generator class="native" />
		</id>
		<version name="ver"/><!--版本号，时间戳必须写在id后面--><!--也可以使用<timestamp name=""/>,但version标签可以铜鼓type指定不同类型-->
		<!-- <property name="name" /> -->
		<component name="name">
			<property name="firstName" column="first_name"/>
			<property name="lastName" column="last_name" />
		</component>
		<property name="birthday" />
	</class>
</hibernate-mapping>

 VersionTest.java

 

package com.taobao.hibernate;

import java.util.Date;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.taobao.hibernate.domain.Name;
import com.taobao.hibernate.domain.User;

public class VersionTest {

	public static void main(String[] args) {
		User user = new User();
		user.setBirthday(new Date());
		Name n = new Name();
		n.setFirstName("firstName");
		n.setLastName("lastName");
		user.setName(n);
		// 111
		addUser(user);
		// System.out.println("id: " + user.getId());
		// 222
		System.out.println("1111111");
		update(user.getId());
	}

	static void update(int id) {
		Session s1 = null;
		s1 = HibernateUtil.getSession();
		Transaction tx1 = s1.beginTransaction();
		User user1 = (User) s1.get(User.class, id);

		Session s2 = HibernateUtil.getSession();
		Transaction tx2 = s2.beginTransaction();
		User user2 = (User) s2.get(User.class, id);

		user1.getName().setFirstName("new1 firstName");

		user2.getName().setFirstName("new2 firstName");

		tx1.commit();
		tx2.commit();

		

		s1.close();
		s2.close();
	}

	static void addUser(User user) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.save(user);
			// 333
			// s.persist(user);
			Name n = new Name();
			n.setFirstName("firstName");
			n.setLastName("lastName");
			user.setName(n);
			user.setBirthday(new Date());
			tx.commit();
			user.setBirthday(new Date());
			tx = s.beginTransaction();
			tx.commit();
			// 444
		} catch (HibernateException e) {
			if (tx != null)
				tx.rollback();
			throw e;
		} finally {
			if (s != null)
				s.close();
		}
	}

	static void addUser1(User user) {
		Session s = null;
		Transaction tx = null;
		try {
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.save(user);
			tx.commit();
		} finally {
			if (s != null)
				s.close();
		}
	}
}

 拟两个线程同步操作，更新user

运行结果如下

Hibernate: insert into Users (ver, name, birthday) values (?, ?, ?)

Hibernate: select users0_.id as id0_0_, users0_.ver as ver0_0_, users0_.name as name0_0_, users0_.birthday as birthday0_0_ from Users users0_ where users0_.id=?

Hibernate: update Users set ver=?, name=?, birthday=? where id=? and ver=?

Hibernate: update Users set ver=?, name=?, birthday=? where id=? and ver=?

Exception in thread "main" org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [domain.Users#1]

第二个提交的事务内报错，数据库内字段修改为new2。