Hibernate框架中直接操作JDBC接口实例

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用面向对象编程思维来操纵数据库。

Hibernate的优势在于屏蔽了数据库细节，对于新增修改删除的数据层操作，不再需要跟具体的SQL语句打交道，简单的对对象实例进行增删改操作即可。但是，对于多表关联、分组统计、排序等复杂的查询功能时，由于Hibernate自身的O-R映射机制，父子表之间关联取数据会产生大量冗余的查询操作，性能低下。此类情况下，直接使用JDBC的SQL语句反而更加灵活和高效。

Hibernate框架处理复杂查询问题实例分析

考虑如下数据库实体示例，表A为主表，表B和表C为子表，A与B、A与C表均为1对多关系，在B表和C表中以A_ID外键字段关联A表父记录。

 
图 1.数据库实体示例图

在Hibernate框架中，通常采用以下配置方式完成A表与B，C表父子实体之间的级联查询操作，Hibernate实体配置xml如下：

清单1.hibernate实体配置xml  
A.hbm.xml:  
<hibernate-mapping> 
<classnameclassname="XXX.XXX.A"table="A"> 
<idnameidname="id"type="long"> 
<columnnamecolumnname="ID"/> 
<generatorclassgeneratorclass="assigned"> 
</generator> 
</id> 
<setnamesetname="children_B"cascade="delete"inverse="true"lazy="false"> 
<keycolumnkeycolumn="A_ID"></key> 
<one-to-manyclassone-to-manyclass="XXX.XXX.B"/> 
</set> 
<setnamesetname="children_C"cascade="delete"inverse="true"lazy="false"> 
<keycolumnkeycolumn="A_ID"></key> 
<one-to-manyclassone-to-manyclass="XXX.XXX.C"/> 
</set> 
</class> 
</hibernate-mapping> 
 
B.hbm.xml:  
<hibernate-mapping> 
<classnameclassname="XXX.XXX.B"table="B"> 
<idnameidname="id"type="long"> 
<columnnamecolumnname="ID"/> 
<generatorclassgeneratorclass="assigned"> 
</generator> 
</id> 
<propertynamepropertyname="a_id"type="long"> 
<columnnamecolumnname="A_ID"> 
</column> 
</property> 
</class> 
</hibernate-mapping> 
 
C.hbm.xml  
<hibernate-mapping> 
<classnameclassname="XXX.XXX.C"table="C"> 
<idnameidname="id"type="long"> 
<columnnamecolumnname="ID"/> 
<generatorclassgeneratorclass="assigned"> 
</generator> 
</id> 
<propertynamepropertyname="a_id"type="long"> 
<columnnamecolumnname="A_ID"> 
</column> 
</property> 
</class> 
</hibernate-mapping> 

对应的Hibernate领域实体类代码示例如下：

清单2.hibernate实体类示例  
A.java:  
publicclassAimplementsjava.io.Serializable,Comparable{  
privatelongid;  
privateSetchildren_b=newHashSet<B>();  
privateSetchildren_c=newHashSet<C>();  
 
publicA(longid){  
this.id=id;  
}  
 
publiclonggetId(){  
returnid;  
}  
 
publicvoidsetId(longid){  
this.id=id;  
}  
 
publicSetgetChildern_b(){  
returnchildren_b;  
}  
 
publicvoidsetChildren_b(Setchildren_b){  
this.children_b=children_b;  
}  
 
publicSetgetChildern_c(){  
returnchildren_c;  
}  
 
publicvoidsetChildren_c(Setchildren_c){  
this.children_c=children_c;  
}  
 
publicintcompareTo(Objectother){  
AotherSubject=(A)other;  
longcurAmount=this.getChildren_b().size()+this.getChildren_c().size();  
longotherAmount=otherSubject.getChildren_b().size()  
 +otherSubject.getChildren_c().size();  
if(curAmount<otherAmount)  
{  
return-1;  
}  
elseif(curAmount>otherAmount)  
{  
return1;  
}  
else  
{  
return0;  
}  
}  
}  
 
B.java:  
publicclassBimplementsjava.io.Serializable,Comparable{  
privatelongid;  
privatelonga_id;  
 
publiclonggetId(){  
returnid;  
}  
 
publicvoidsetId(longid){  
this.id=id;  
}  
 
publiclonggetA_id(){  
returna_id;  
}  
 
publicvoidsetA_id(longa_id){  
this.a_id=a_id;  
}  
 
publicB(longid){  
this.id=id;  
}  
}  
 
C.java:  
publicclassCimplementsjava.io.Serializable,Comparable{  
privatelongid;  
privatelonga_id;  
 
publiclonggetId(){  
returnid;  
}  
 
publicvoidsetId(longid){  
this.id=id;  
}  
 
publiclonggetA_id(){  
returna_id;  
}  
 
publicvoidsetA_id(longa_id){  
this.a_id=a_id;  
}  
 
publicC(longid){  
this.id=id;  
}  
} 

假设现在要统计A表中从属的B表和C表记录之和最高的top10的A表记录，在Hibernate框架下，由于取A表对应的数据库记录时，已关联取出了对应的B、C表子记录存放于A实体类的children_a，children_c的属性中，因此top10的功能可以通过比较每个A表实体类中children_a、children_c的Set的size大小并进行排序得到，其代码示例如下：

清单3.排序代码示例  
privateArrayList<A>sortAByAmount(ArrayList<A>all)  
{  
for(inti=0;i<all.size();i++)  
{  
for(intj=0;j<all.size()-i-1;++j)  
{  
if(all.get(j).compareTo(all.get(j+1))<=0)  
{  
Atemp=all.get(j);  
all.set(j,all.get(j+1));  
all.set(j+1,temp);  
}  
}  
}  
returnall;  
} 

表面看来很方便，但是由于Hibernate是面向对象的O-R映射机制，每一条A表记录的查询实际都关联有两条B、C表查询的SQL产生，我们可以看到Hibernate的SQL日志中：

清单4.Hibernatesql日志示例  
Hibernate:selecta0_.IDasID2_fromAa0_wherea0_.ID='1' 
Hibernate:selectb0_.IDasID2_,b0_.A_IDasA_ID2_fromBb0_whereb0_.ID=?  
Hibernate:selectc0_.IDasID2_,c0_.A_IDasA_ID2_fromCc0_wherec0_.ID=? 

由上述Sql日志可以看出，每一条A表记录的取出，都伴随以A表ID为查询条件关联B，C表中A_ID外键字段的2条取子记录的sql，这是由A.hbm.xml配置中“lazy=false”决定的。#p#

这种情况下，当A和B、C表中数据量越来越大时，A表取实体的操作开销将随着sql查询的增多而增大，并且在紧接着的排序过程中，即使采用业界最快的快速排序算法，排序时间依然是随原始排序实体数量的线性关系（O(nlgn)），效率会线性下降，最终无法满足客户的前台查询的效率要求。此类情况下如直接采用JDBC，则只需一条如下的SQL语句，即可完成该功能：

清单5.直接JDBC操作sql  
select  
tab1.ID,  
tab1.sumCol+tab2.sumCol  
from  
(  
selecta.ID,  
count(b.ID)sumCol  
fromAaleftjoinBbona.ID=b.ID  
GROUPBY  
a.ID  
)tab1,  
(  
selecta.ID,  
count(c.ID)sumCol  
fromAaleftjoinCcona.ID=c.ID  
GROUPBY  
a.ID  
)tab2  
wheretab1.ID=tab2.ID  
orderbytab1.sumCol+tab2.sumColdesc 

在以上JDBC方式下，即使A、B、C表的数据量持续增长，仍然只有1条SQL的开销，不会出现SQL递增的情况，因此耗时是在可控制的区间内的。并且读者可以注意到上述SQL将3表关联拆分成了2个子查询，这样避免了3表做笛卡尔积的数量和，进一步提高了查询效率。由此可见，直接操作JDBC，除SQL的开销可控外，还可以利用数据库层各种机制，如上述查询语句中的leftjoin、子查询、索引…，灵活的调整SQL语句，以达到最佳的查询性能。

由上可实例可看出，在多表关联、排序等复杂的查询情况下，Hibernate框架由于其自身对象封装的特殊性，不能像JDBC直接操作SQL那样很好的解决查询中高效性和灵活性方面的需求，且由于其屏蔽了数据库的底层，开发人员看到的只是Hibernate提供的数据层API，无法与灵活的使用SQL语句等数据库底层细节。因此，有必要在Hibernate框架中提供直接操作JDBC的接口。

在Hibernate框架中提供操作JDBC的接口的解决方案

Hibernate的session机制

我们知道Hibernate框架本身也是建立在JDBC之上的数据持久层实现，因此，要在框架本身提供操作JDBC的接口，需要切入其对JDBC封装的细节。通过研究和查阅Hibernate的框架源代码及参考文档，我们发现，Hibernate的Session会话是进行持久化的基础，所有的持久化操作都是在Session的基础上进行的，在实现上它是和JDBC中的connection数据库连接绑定的，也就是说，Hibernate的会话域基于一个实际的connection类实例，二者之间的关系如下图所示：

 
图 2.Hibernate Session机制示意图

由上可以看到，Hibernate中的session是单线程的，代表了一次会话的过程。实际上是把一个JDBCConnection打包了，每一个Session实例和一个数据库事务绑定。其生命周期是与与之关联的connection实例的生命周期一致的。

具体解决方案

由上面的Hibernate的Session机制我们意识到，只要能获取到Hibernate当前会话中的Connection，则获得了JDBC的底层数据库连接实例，剩下就都是JDBC的范畴了。再查阅Hibernate的API，发现HibernateTemplate类中SessionFactory成员的getCurrentSession()方法即可获得Hibernate环境下的当前活动的Session会话，而Hibernate中Session实例的connection()方法即可获得该会话中绑定的Connection数据库连接实例。

问题迎刃而解了，既然可以操作Connection实例，那与之关联的Statement、ResultSet等基本JDBC类均在我们控制范围中了，我们采用接口模式设计一个轻量级解决方案，使其在保持原Hibernate的增删改操作方式前提下灵活提供操作JDBC的接口。设计类图如下图所示：

 
图 3.解决方案设计类示意图

设计中，AbstractHibernateDao类作为DAO操作的基本类，保留原有Hibenrate框架下的新增，修改，删除等API。BaseHibernateDao类继承AbstractHibernateDao类，在此类中增加了直接操作JDBC的接口。设计getConnection方法获取JDBC的数据库连接实例，设计getObjectsBySql方法作为对外的主要接口，该方法调用fetchObjects方法，这是具体的数据库记录到领域对象的转换操作，需要使用者override该方法以完成自有领域对象的填充细节。实际实现的类代码如下所示：

清单6.解决方案实现代码  
AbstractHibernateDao.java:  
abstractpublicclassAbstractHibernateDaoextendsHibernateDaoSupport{  
 
protectedLoglogger=LogFactory.getLog(getClass());  
protectedClassentityClass;  
 
protectedClassgetEntityClass(){  
returnentityClass;  
}  
 
publicListgetAll(){  
returngetHibernateTemplate().loadAll(getEntityClass());  
}  
 
publicvoidsave(Objecto){  
getHibernateTemplate().saveOrUpdate(o);  
}  
 
publicvoidremoveById(Serializableid){  
remove(get(id));  
}  
 
publicvoidremove(Objecto){  
getHibernateTemplate().delete(o);  
}  
 
}  
 
BaseHibernateDao.java:  
abstractpublicclassBaseHibernateDaoextendsAbstractHibernateDao{  
publicConnectiongetConnection()  
{  
try  
{  
 
SessioncurSeesion=null;  
Connectioncon=null;  
curSeesion=super.getHibernateTemplate().getSessionFactory()  
 .getCurrentSession();  
con=curSeesion.connection();  
returncon;  
}  
catch(Exceptiones)  
{  
System.out.println(es.getMessage());  
returnnull;  
}  
 
}  
 
publicArrayList<Object>fetchObjects(ResultSetrs)  
{  
ArrayList<Object>ret=newArrayList<Object>();  
//example:  
//while(rs.next())  
//{  
//Objectobject=newObject();  
//rs.getString(1);  
//rs.getString(2);  
//ret.add(object);      
//}  
returnret;  
}  
 
publicArrayList<Object>getObjectsBySql(StringpureSql)  
{  
Connectioncon=curSeesion.connection();  
ps=con.prepareStatement(sqlbuf.toString());  
rs=ps.executeQuery();  
try  
{  
returnthis.fetchObjects(rs);   
     
}  
catch(Exceptiones)  
{  
System.out.println(es.getMessage());  
returnnull;  
}  
finally  
{  
try  
{  
ps.close();  
rs.close();  
con.close();  
}  
catch(SQLExceptione){  
//TODOAuto-generatedcatchblock  
e.printStackTrace();  
}  
     
}  
}  
} 

使用该解决方案时，只需要将代码包解压至项目源代码目录，在想要直接操作JDBC接口的DAO模块继承BaseHibernateDao类，然后重写fetchObjects方法填入从自身数据库表字段填充到领域对象的操作,即可轻松调用getObjectsBySql传入原生SQL语句，返回具体的领域对象实体集合，当然使用者也可以通过getConnection获得JDBC的Connection实例来进行自己需要的特定的JDBC底层操作。仍然以上文中的A、B、C表为例，采用该解决方案完成top10取数的代码示例如下：

清单7.使用解决方案示例  
publicclasstestDAOextendsBaseHibernateDao{  
 
privateStringsqlQuery="selecttab1.ID,tab1.sumCol+tab2.sumCol"+  
"from(selecta.ID,count(b.ID)sumCol"+  
"fromAaleftjoinBbona.ID=b.ID"+  
"GROUPBYa.ID)tab1,"+  
"(selecta.ID,count(c.ID)sumCol"+  
"fromAaleftjoinCcona.ID=c.ID"+  
"GROUPBYa.ID)tab2"+  
"wheretab1.ID=tab2.ID"+  
"orderbytab1.sumCol+tab2.sumColdesc";  
 
@override  
publicArrayList<A>fetchObjects(ResultSetrs)  
{  
ArrayList<A>ret=newArrayList<A>();  
intcount=1;  
while(rs.next())  
{  
Aa=newA();  
a.setId(rs.getLong(1));  
System.out.println("top"+(count++)+"amount:"+rs.getLong(2));  
ret.add(object);      
}  
returnret;  
}  
 
} 

解决方案验证

在实际mySql数据库环境中，以A表数据量1000条，B表数据量3W多条，C表数据量2000条情况下进行上文中提到的top 10的操作，采用Hibernate的耗时和用JDBC接口解决方案的效率比较如下：

 
表 1.Hibernate框架方式与JDBC接口方式效率比较

 
表 2.Hibernate框架方式与JDBC接口方式效率比较

由以上结果可以看出：在数据量递增的情况下，采用Hibernate方式下效率与库表数据呈线性增长，且排序的操作的效率也是一样，而直接采用JDBC接口解决方案下效率远远高于Hibernate方式，且在数据量增长的情况下耗时的增长速度处于合理的区间内。

【编辑推荐】

1. Hibernate的多对一和一对多操作实例
2. Hibernate批量更新与删除实例浅析
3. 浅析Hibernate继承关系树的三种映射方式
4. 教你如何在Hibernate中实例化集合和代理
5. 浅析加速Hibernate应用程序开发