1. Hibernate分页
数据分页显示,在系统实现中往往会带来较大的工作量,对于基于JDBC的程序而言,不同数据库提供的分页(部分读取)模式往往不同,也带来了数据库间可移植性上的问题。
Hibernate中,通过对不同数据库的统一接口设计,实现了透明化、通用化的分页实现机制。
我们可以通过Criteria.setFirstResult和Criteria.setFetchSize方法设定分页范围,如:
Criteria criteria = session.createCriteria(TUser.class);
criteria.add(Expression.eq("age","20"));
//从检索结果中获取第100条记录开始的20条记录
criteria.setFirstResult(100);
criteria.setFetchSize(20);
同样,Query接口也提供了与其一致的方法。
Hiberante中,抽象类net.sf.hibernate.dialect指定了所有底层数据库的对外统一接口。通过针对不同数据库提供相应的dialect实现,数据库之间的差异性得以消除,从而为上层机制提供了透明的、数据库无关的存储层基础。
对于分页机制而言,dialect中定义了一个方法如下:
public String getLimitString(
String querySelect,
boolean hasOffset
)
此方法用于在现有Select语句基础上,根据各数据库自身特性,构造对应的记录返回限定子句。如MySQL中对应的记录限定子句为Limit,而Oracle中,可通过rownum子句实现。
来看MySQLDialect中的getLimitString实现:
public String getLimitString(String sql, boolean hasOffset){
return new StringBuffer(sql.length()+20)
.appeng(sql)
.appeng(hasOffset ?" limit ?,?" : " limit ?")
.toString();
}
从上面可以看到,MySQLDialect.getLimitString方法的实现实际上是在给定的Select语句后追加MySQL所提供的专有SQL子句limit来实现。
下面是Oracle9Dialect中的getLimitString实现,其中通过Oracle特有的rownum子句实现了数据的部分读取。
public String getLimitString(String sql, boolean hasOffset){
StringBuffer pagingSelect = new StringBuffer(sql.length()+100);
if(hasOffset){
pagingSelect.append("select * from (select row_.*,rownum rownum_ from(");
}else{
pagingSelect.append("select * from (");
}
paginSelect.appeng(sql);
if(hasOffset){
pagingSelect.append(") row_ where rownum<=?) where rownum_>?");
}
else{
pagingSelect.append(") where rownum<=?");
}
return pagingSelect.toString();
}
大多数主流数据库都提供了数据部分读取机制,而对于某些没有提供过相应机制的数据库而言,Hibernate也通过其它途径实现了分页,如通过Scrollable ResultSet,如果JDBC不支持Scrollable ResultSet,Hibernate也会自动通过ResultSet的next方法进行记录定位。
这样,Hibernate通过底层对分页机制的良好封装,使得开发人员无需关心数据分页的细节实现,将数据逻辑和存储逻辑分离开来,在提高生产效率的同时,也大大加强了系统在不同数据库平台之间的可移植性。
2. Session管理
无疑Session是Hibernate运作的灵魂,作为贯穿Hibernate应用的关键,Session中包含了数据库操作相关的状态信息。如对JDBC Connection的维护,数据实体的状态维持等。
对Session进行有效管理的意义,类似JDBC程序设计中对于JDBC Connection的调度管理。有效的Session管理机制,是Hibernate应用设计的关键。
大多数情况下,Session管理的目标聚焦于通过合理的设计,避免Session的频繁创建和销毁,从而避免大量的内存开销和频繁的JVM垃圾回收,保证系统高效平稳运行。
在各种Session管理方案中,ThreadLocal模式得到了大量使用。
ThreadLocal是Java中一种较为特殊的线程绑定机制。通过ThreadLocal存取的数据,总是与当前线程相关,也就是说,JVM为每个运行的线程,绑定了私有的本地实例存取空间,从而为多线程环境常出现的并发访问问题提供了一种隔离机制。
首先,我们需要知道,SessinFactory负责创建Session, SessionFactory是线程安全的,多个并发线程可以同时访问一个SessionFactory并从中获取Session实例。
而Session并非线程安全,也就是说,如果多个线程同时使用一个Session实例进行数据存取,则将会导致Session数据存取逻辑混乱。下面是一个典型的Servlet,我们试图通过一个类变量session实现Session的重用,以避免每次操作都要重新创建:
public class TestServlet entends HttpServlet{
private Session session;
public void doGet(HttpServletRequest request, HttpServletResponse response){
session = getSession();
doSomething();
session.flush();
}
public void doSomething(){
…//基于session的存取操作
}
}
代码看上去正确无误,甚至在单机测试的时候可能也不会发生什么问题,但这样的代码一旦编译部署到实际运行环境中,接踵而来的莫名其妙的错误很可能会使得我们摸不着头脑。
问题出在哪里?
首先,Servlet运行是多线程的,而应用服务器并不会为每个线程都创建一个Servlet实例,也就是说,TestServlet在应用服务器中只有一个实例(在tomcat中是这样,其他的应用服务器可能有不同的实现),而这个实例会被许多个线程并发调用,doGet方法也将被不同的线程反复调用,可想而知,每次调用doGet方法,这个唯一的TestServlet实例的session变量都会被重置,线程A的运行过程中,其他的线程如果也被执行,那么session的引用将发生改变,之后线程A再调用session,可能此时的session与之前所使用的session就不再一致,显然,错误也就不期而至。
ThreadLocal的出现,使得这个问题迎刃而解。
对上面的例子进行一些小小的修改:
public class TestServlet entends HttpServlet{
private ThreadLocal localSession = new ThreadLocal();;
public void doGet(HttpServletRequest request, HttpServletResponse response){
localSession .set(getSession());
doSomething();
session.flush();
}
public void doSomething(){
Session session = (Session)localSession.get();
…//基于session的存取操作
}
}
可以看到,localSession是一个ThreadLocal类型的对象,在doGet方法中,我们通过其set方法将获取的session实例保存,而在doSomething方法中,通过get方法取出session实例。
这也就是ThreadLocal的独特之处,它会为每个线程维护一个私有的变量空间。实际上,其实现原理是在JVM中维护一个Map,这个Map的key就是当前的线程对象,而value则是线程通过ThreadLocal.set方法保存的对象实例。当线程调用ThreadLocal.get方法时,ThreadLocal会根据当前线程对象的引用,取出Map中对应的对象返回。
这样,ThreadLocal通过以各个线程对象的引用作为区分,从而将不同线程的变量隔离开来。
回到上面的例子,通过应用ThreadLocal机制,线程A的session实例只能为线程A所用,同样,其他线程的session实例也各自从从属自己的线程。这样,我们就实现了线程安全的session共享机制。
Hibernate官方开发手册的示例中,提供了一个通过ThreadLocal维护session的好榜样:
public class HibernateUtil {
private static SessionFactory sessionFactory;
static{
try{
//create the sessionFactory
sessionFactory = new Configuration().configure().buildSessionFactory();
}catch(HibernateException ex){
throw new RuntimeException(“Configuration problem: “+ ex.getMessage(), ex);
}
}
public static final ThreadLocal session = new ThreadLocal();
public static Session currentSession() throws HibernateException{
Session s = (Session)session.get();
//open a new session, if this Thread has none yet
if(s==null){
s = sessionFactory.openSession();
session.set(s);
}
return s;
}
public static void closeSession() throws HibernateException{
Session s = (Session)session.get();
session.set(null);
if(s!=null)
s.close();
}
}
在代码中,只要借助上面这个工具类获取Session实例,我们就可以实现线程范围内的Session共享,从而避免了在线程中频繁的创建和销毁Session实例。不过注意在线程结束时关闭Session。
同时值得一提的是,当前版本的Hibernate在处理Session的时候已经内置了延迟加载机制,只有在真正发生数据库操作的时候,才会从数据库连接池获取数据库连接,我们不必过于担心Session的共享会导致整个线程生命周期内数据库连接被持续占用。
上面的HibernateUtil类可以应用在任何类型的Java程序中。特别的,对于Web程序而言,我们可以借助Servlet2.3规范中新引入的Filter机制,轻松实现线程生命周期内的Session管理(关于Filter的具体描述,参考Servlet2.3规范)。
Filter的生命周期贯穿了其所覆盖的Servlet(JSP也可以看作是一种特殊的Servlet)及其底层对象。Filter在Servlet被调用之前执行,在Servlet调用结束之后结束。因此,在Filter中管理Session对于Web程序而言就显得水到渠成。下面是一个通过Filter进行Session管理的典型案例:
public class PersistenceFilter implements Filter{
protected static ThreadLocal hibernateHolder = new ThreadLocal();
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException{
hibernateHolder.set(getSession());
try{
…
chain.doFilter(request, response);
…
}finally{
Session sess = (Session)hibernateHolder.get();
if(sess!=null){
hibernateHolder.set(null);
try{
sess.close();
}catch(HibernateException ex){
throw new ServletException(ex);
}
}
}
}
…
}
通过在doFilter中获取和关闭Session,并在周期内运行的所有对象(Filter链中其余的Filter,及其覆盖的Servlet和其他对象)对此Session实例进行重用,保证了一个HttpRequest处理过程中只占用一个Session,提高了整体性能表现。
在实际设计中,大多数情况下Session重用做到线程级别一般已经足够,企图通过HttpSession实现用户级的Session重用反而可能导致其他的问题。凡事不能过火,Session重用也一样。
3. Hibernate与Spring Framework
下面主要就Hibernate在Spring Framework中的应用加以介绍,关于Spring Framework请参见《深入浅出Spring Framework》。
Spring的参数化事务管理功能相对强大,笔者建议在基于Spring Framework的应用开发中,尽量使用容器管理事务,以获得数据逻辑代码的最佳可读性。下面的介绍,将略过代码控制的事务管理部分,而将重点放在参数化的容器事务管理应用。代码级事务管理实现原理参见《深入浅出Spring Framework》相关内容。
首先,针对Hibernate,需进行如下配置:
Hibernate-Context.xml
<beans> <bean id=”dataSource” class=”org.apache.common.dbcp.BasicDataSource” destroy-method=”close”> <property name=”driverClassName”> <value>net.sourceforge.jtds.jdbc.Driver</value> </property> <property name=”url”> <value>jdbc:jtds:sqlserver://127.0.0.1:1433/sample</value> </property> <property name=”username”> <value>test</value> </property> <property name=”password”> <value>changeit</value> </property> </bean> <bean id=”sessionFactory” class=”org.springframework.orm.hibernate.LocalSessionFactoryBean”> <property name=”dataSource”> <ref local=”dataSource”/> </property> <property name=”mappingResources”> <list> <value>net/xiaxin/dao/entity/User.hbm.xml</value> </list> </property> <property name=”hibernateProperties”> <props> <prop key=”hibernate.dialect”> net.sf.hibernate.dialect.SQLServerDialect </prop> <prop key=”hibernate.show_sql”> true </prop> </props> </property> </bean> <bean id=”transactionManager” class=”org.springframework.orm.hibernate.HibernateTransactionManager”> <property name=”sesisonFactory”> <ref local=”sessionFactory”/> </property> </bean> <bean id=”userDAO” class=”net.xiaxin.dao.UserDAO”> <property name=”sessionFactory”> <ref local=”sessionFactory”/> </property> </bean> <bean id=”userDAOProxy” class=”org.springframework.transaction.interceptor. TransactionProxyFactoryBean”> <property name=”transactionManager”> <ref bean=”transactionManager”/> </property> <property name=”target”> <ref local=”userDAO”/> </property> <property name=”transactionAttributes”> <props> <prop key=”insert*”>PROPAGATION_REQUIRED</prop> <prop key=”get”>PROPAGATION_REQUIRED,readOnly</prop> </props> </property> </bean> <beans>
其中:
1)SessionFactory的配置
Hibernate中通过SessionFacctory创建和维护Session,Spring对SessionFactory的配置也进行了整合,无需再通过Hibernate.cfg.xml对SessionFactory进行设定。
SessionFactory节点的mappingResources属性包含了映射文件的路径,list节点下可配置多个映射文件。
hibernateProperties节点则容纳了所有的属性配置。
可以对应传统的hibernate.cfg.xml文件结构对这里的SessionFactory配置进行解读。
2)采用面向Hibernate的TransactionManager实现
org.springframework.orm.hibernate.HiberateTransactionManager
这里引入了一个非常简单的库表:Users,建立如下映射类:
User.java
/**@hibernate.class table=”users”*/
public class User{
public Integer id;
public String username;
public String password;
/**@hibernate.id column=”id” type=”java.lang.Integer”
generate-class=”native”*/
public Integer getId(){
return id;
}
public void setId(Integer id){
this.id = id;
}
/**@hibernate.property column=”password” length=”50”*/
public String getPassword(){
return password;
}
public void setPassword(String password){
this.password = password;
}
/**@hibernate.property column=”username” length=”50”*/
public String getUsername(){
return username;
}
public void setUsername(String username){
this.username = username;
}
}
上面的代码中,通过xdoclet指定了类/表、属性/字段的映射关系,通过xdoclet ant task我们可以根据代码生成对应的user.hbm.xml文件。
下面是生成的user.hbm.xml:
<hibernate-mapping> <class name=”net.xiaxin.dao.entity.User” table=”users” dynamic-update=”false” dynamic-insert=”false”> <id name=”id” column=”id” type=”java.lang.Integer”> <generator class=”native”/> </id> <property name=”password” column=”password” type=”java.lang.String” update=”true” insert=”true” access=”property” length=”50”/> <property name=”username” column=”username” type=”java.lang.String” update=”true” insert=”true” access=”property” length=”50”/> </class> </hibernate-mapping>
UserDAO.java
public class UserDAO extends HibernateDaoSupport implementd IUserDAO{
public void insertUser(User user){
getHibernateTemplate().saveOrUpdate(user);
}
}
看到这段代码想必会有点诧异,似乎太简单了一点,不过已经足够。短短一行代码我们已经实现了与上一章中示例相同的功能,这也正体现了Spring+Hibernate的威力所在。
上面的UserDAO实现了自定义的IUserDAO接口,并扩展了抽象类: HibernateDaoSupport。
HibernateDaoSupport实现了HibernateTemplate和SessionFactory实例的关联。
HibernateTemplate对Hibernate Session操作进行了封装,而HibernateTemplate.execute方法则是一封装机制的核心,有兴趣可以研究其实现机制。
借助HibernateTemplate我们可以脱离每次数据操作必须首先获得Session实例、启动事务、提交/回滚事务以及try/catch/finally等繁杂的操作。从而获得以上代码中精于集中的逻辑呈现效果。
对比下面这段实现了同样功能的Hibernate原生代码,想必更有体会:
Session session;
try{
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
User user = new User();
user.setName(“Erica”);
user.setPassword(“mypass”);
session.save(user);
tx.commit();
}catch(HibernateException e){
e.printStackTrace();
tx.rollback();
}finally{
session.close();
}
附上例的测试代码:
InputStream is = new FileInputStream(“Hibernate-Context.xml”);
XmlBeanFactory factory = new XmlBeanFactory(is);
IUserDAO userDAO = (IUserDAO)factory.getBean(“userDAOProxy”);
User user = new User();
user.setUsername(“Erica”);
user.setPassword(“mypass”);
userDAO.insertUser(user);
转载于:https://blog.51cto.com/1831651/1228021