您的位置：首页 > 数据库

由HibernateTemplate执行原生SQL总结

2018-04-01 13:52 274 查看

一次做项目中，我将数据源放在了db.properties文件中，将数据源dataSource交给Spring来管理。然后在dao的实现层继承HibernateSupport类，从而通过this.getHibernateTemplate()就可以执行HQL语句。据说是在HibernateTemplate类里面就有sessionFactory这个属性。

附上我的db.properties和spring配置datasources的代码

Db.propertits
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///hospital_manager
jdbc.user=root
jdbc.password=123456

spring配置数据源的xml

<!-- 引入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 配置c3po -->
<!-- c3po数据源
从propertites文件中读取-->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

<!-- Hibernate的相关信息 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 注入连接池 -->
<property name="dataSource" ref="dataSource"/>
<!-- 配置Hibernate的其他的属性 -->
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate3.SpringSessionContext</prop>
</props>
</property>
<!-- 配置Hibernate的映射文件 -->
<property name="mappingResources">
<list>

</list>

</property>
</bean>

当我在do的实现层要使用getHibernateTemplate()来执行原生SQL时，犯难了百度了一番

一看

方式一：直接使用HibernateTemplate的find()方法，find方法支持执行hql语句
List<T> list = this.getHibernateTemplate().find(finalHql, params);

方式二：获取SessionFactory，再获取Session

SessionFactory sf = this.getHibernateTemplate().getSessionFactory();

Session s = sf.getCurrentSession();

Query query = s.createQuery(finalHql);

query.setParameter(0, params[0]);

query.setParameter(1, params[1]);

List<T> list = query.list();

方式三：使用hibernateTemplate调用回调函数

List<T> list = this.getHibernateTemplate().execute(new HibernateCallback() {

public Object doInHibernate(Session session)

throws HibernateException, SQLException {

Query query = session.createQuery(finalHql);

if(params!=null && params.length>0){

for(int i=0;i<params.length;i++){

query.setParameter(i, params[i]);

} } return query.list();
} });
二看
getHibernateTemplate用法
前提条件:你的类必须继承HibernateDaoSupport
一：
回调函数:
Java代码

public List getList(){

        return (List ) getHibernateTemplate().execute(

                new HibernateCallback() {

                    public List doInHibernate(final Session s)

                            throws HibernateException, SQLException {



StringBuffer sb = new StringBuffer();

Query query = s.createSQLQuery(sb.toString());//执行普通sql

Query query = s.createQuery(sb.toString());//   执行hql

List list = query.list();

return list ;

                    }

                });

    }

采用这种做法的好处是:不用关心事务。session的创建和销毁，一切都在程序内部完成。看看名字doInHibernate就知道好处了。不好的是程序看起来比较乱！个人认为。
二：
Java代码

getHibernateTemplate().find（）:

ist list = getHibernateTemplate().find（String sql ）:

这种的前提是sql必须是hql ,原始sql 不能执行。

三：
自己获取session处理。
获取session的两种方式:this.getSession();和this.getHibernateTemplate().getSessionFactory().openSession();
获取session以后再createQuery操作就一样了。但是这种做法，是需要自己去手动关闭session的。所以你需要配置openSessioninview，个人认为不推荐使用！

其他：
getHibernateTemplate.delete(Object);

getHibernateTemplate.save(Object);
getHibernateTemplate.update(Object);

总结:推荐使用回调函数。

补充百科：

Spring的Hibernate ORM 框架带来了方便的HibernateDaoSupport类,你的DAO类可以继承它：

public class StudentDaoHibernate extends HibernateDaoSupport implements StudentDao{

.................

}如果你选择这种设计,就需要动态注入SessionFactory而HibernateDaoSupport包含这个属性.这个类提供了一个方便的方法getHibernateTemplate(); 就能得到HibernateTemplate的一个实例.它也有getSession()和releaseSession,以便于你应为某些原因而不使用HibernateTempate的情况下执行Hibernate操作。

HibernateDaoSupport提供了基于AOP事务的自动处理，程序员完全可以不用理会事务的开始与提交。在JDBC中一个Connection对象使用一个事务，那么在Hibernate中一个事务肯定要关联一个SessionFactory了，然而这个SessionFactory却没有在DAO中体现。其实主要的原因是HibernateDaoSupport类已经默默地做了封装的工作，它用一个setSessionFactory方法将SessionFactory进行注入，所以继承自HibernateDaoSupport类的DAO都会具有SessionFactory的属性，从而可以通过SessionFactory创建Session实例操作数据库。

在继承HibrnateDaoSupport的DAO实现里，Hibernate Session的管理完全不需要Hibernate代码打开，而由Spring来管理。Spring会根据实际的操作，采用"每次事务打开一次session"的策略，自动提高数据库访问的性能。
再论hibernatetemplate
自动生成hibernate配置文件的时候，会在dao层用到getSession()方法来操作数据库记录，但是他还有个方法getHibernateTemplate()，这两个方法究竟有什么区别呢？

1.使用getSession()方法你只要继承sessionFactory，而使用getHibernateTemplate()方法必须继承 HibernateDaoSupport当然包括sessionFactory，这点区别都不是特别重要的，下面这些区别就很重要了

2.getSession()方法是没有经过spring包装的，spring会把最原始的session给你，在使用完之后必须自己调用相应的 close方法，而且也不会对声明式事务进行相应的管理，一旦没有及时关闭连接，就会导致数据库连接池的连接数溢出，getHibernateTemplate()方法是经过spring封装的，例如添加相应的声明式事务管理，由spring管理相应的连接。

在实际的使用过程中发现的确getHibernateTemplate()比getSession()方法要好很多，但是有些方法在getHibernateTemplate()并没有提供，这时我们用HibernateCallback 回调的方法管理数据库.

例如如下代码：

/**
     * 使用 hql 语句进行操作
     * @param hql HSQL 查询语句（使用回调函数访问外部变量，必须是final的）
     * @param offset 开始取数据的下标
    * @param length 读取数据记录数
    * @return List 结果集
*/
public List getListForPage ( final String hql , final int offset , final int length ) {

              List list = getHibernateTemplate().executeFind ( new HibernateCallback ( ) {
                            public Object doInHibernate ( Session session ) throws HibernateException, SQLException {
                                            Query query = session.createQuery ( hql ) ;
                                            query.setFirstResult ( offset ) ;
                                            query.setMaxResults ( length ) ;
                                            List list = query.list ( ) ;
                                            return list ;
                           }               }) ;
               return list ;
}自己尝试过这种方式，遇到一个问题是使用回调函数返回的List是由Object数组，不好用对象.属性进行取值

最后看

Hibernate原生SQL查询

　　最近在做一个较为复杂的查询，hibernate基本的查询不能满足，只好使用其提供的原生sql查询。参考网上的一些资料，做一些总结。
　　对原生SQL查询执行的控制是通过SQLQuery接口进行的，通过执行Session.createSQLQuery()获取这个接口。该接口是Query接口的子接口。　
　　执行SQL查询步骤如下：
         1、获取Hibernate Session对象
         2、编写SQL语句
         3、通过Session的createSQLQuery方法创建查询对象
         4、调用SQLQuery对象的addScalar()或addEntity()方法将选出的结果与标量值或实体进行关联，分别用于进行标量查询或实体查询
         5、如果SQL语句包含参数，调用Query的setXxxx方法为参数赋值
         6、调用Query的list方法返回查询的结果集　
　　一、标量查询
　　最基本的SQL查询就是获得一个标量的列表：

session.createSQLQuery("select
*
from person_info").list();

session.createSQLQuery("select id,name,age from person_info").list();

　　它们都将返回一个Object数组组成的List，数组每个元素都是person_info表的一个字段值。Hibernate会使用ResultSetMetadata来判定返回的标量值的实际顺序和类型。但是在JDBC中过多的使用ResultSetMetadata会降低程序的性能。所以为了过多的避免使用ResultSetMetadata或者为了指定更加明确的返回值类型，我们可以使用addScalar()方法：

session.createSQLQuery("select
*
from person_inf")

.addScalar("name",StandardBasicTypes.STRING)

.addScalar("age",StandardBasicTypes.INT)

.list();

　　这个查询指定了：
         1、SQL查询字符串。
         2、要返回的字段和类型。
         它仍然会返回Object数组,但是此时不再使用ResultSetMetdata,而是明确的将name和age按照String和int类型从resultset中取出。同时，也指明了就算query是使用*来查询的，可能获得超过列出的这三个字段，也仅仅会返回这三个字段。
　　如果仅仅只需要选出某个字段的值，而不需要明确指定该字段的数据类型，则可以使用addScalar(String columnAlias)。

public void scalarQuery(){

Session session = HibernateUtil.getSession();

Transaction tx = session.beginTransaction();

String sql = "select
*
from person_info";

List list = session.createSQLQuery(sql).

addScalar("person_id",StandardBasicTypes.INTEGER).

addScalar("name", StandardBasicTypes.STRING).

                    addScalar("age",StandardBasicTypes.INTEGER).list();

for(Iterator iterator = list.iterator();iterator.hasNext();){

//每个集合元素都是一个数组，数组元素师person_id,person_name,person_age三列值

Object[] objects = (Object[]) iterator.next();

System.out.println("id="+objects[0]);

System.out.println("name="+objects[1]);

System.out.println("age="+objects[2]);

System.out.println("----------------------------");

tx.commit();

session.close();

　　从上面可以看出。标量查询中addScalar()方法有两个作用：
         1、指定查询结果包含哪些数据列---没有被addScalar选出的列将不会包含在查询结果中。
         2、指定查询结果中数据列的数据类型
　　二、实体查询
         上面的标量查询返回的标量结果集，也就是从resultset中返回的"裸"数据。如果我们想要的结果是某个对象的实体，这是就可以通过addEntity()方法来实现。addEntity()方法可以讲结果转换为实体。但是在转换的过程中要注意几个问题：
         1、查询返回的是某个数据表的全部数据列
         2、该数据表有对应的持久化类映射
　　这时才可以通过addEntity()方法将查询结果转换成实体。

session.createSQLQuery("select
*
from perons_inf").addEntity(Person.class).list;

session.createSQLQuery("select id,name,age from person_inf").addEntity(Person.class).list();

　　这个查询指定：
         1、SQL查询字符串
         2、要返回的实体
         假设Person被映射为拥有id,name和age三个字段的类，以上的两个查询都返回一个List，每个元素都是一个Person实体。
　　假若实体在映射时有一个many-to-one的关联指向另外一个实体，在查询时必须也返回那个实体（获取映射的外键列），否则会导致发生一个"column not found"的数据库错误。这些附加的字段可以使用*标注来自动返回，但我们希望还是明确指明，看下面这个具有指向teacher的many-to-one的例子：

session.createSQLQuery("select id, name, age, teacherID from person_info").addEntity(Person.class).list();

　　这样就可以通过person.getTeacher()获得teacher了。

public void entityQuery(){

Session session = HibernateUtil.getSession();

Transaction tx = session.beginTransaction();

String sql = "select
*
from person_info";

List list = session.createSQLQuery(sql).

addEntity(Person.class).    //指定将查询的记录行转换成Person实体

list();

for (Iterator iterator = list.iterator();iterator.hasNext();) {

Person person = (Person) iterator.next();      //集合的每个元素都是一个Person对象

System.out.println("name="+person.getName());

System.out.println("age="+person.getAge());

tx.commit();

session.close();

　　上面的都是单表查询，如果我们在SQL语句中使用了多表连接，则SQL语句可以选出多个数据表的数据。Hibernate支持将查询结果转换成多个实体。如果要将查询结果转换成多个实体，则SQL字符串中应该为不同数据表指定不同别名，并且调用addEntity()方法将不同数据表转换成不同实体。如下:

public void multiEntityQuery(){

Session session = HibernateUtil.getSession();

Transaction tx = session.beginTransaction();

String sql = "select p.*,e.*
from person_inf as p inner
join event_inf as e" +

" on p.person_id=e.person_id";

List list = session.createSQLQuery(sql)

.addEntity("p",Person.class)

.addEntity("e", MyEvent.class)

                .list();

for(Iterator iterator = list.iterator();iterator.hasNext();){

//每个集合元素都是Person、MyEvent所组成的数组

Object[] objects = (Object[]) iterator.next();

Person person = (Person) objects[0];

MyEvent event = (MyEvent) objects[1];

System.out.println("person_id="+person.getId()+" person_name="+person.getName()+" title="+event.getTitle());

　　三、处理关联和继承
　　通过提前抓取将Event连接获得，而避免初始化proxy带来的额外开销也是可能的。这是通过addJoin()方法进行的，通过这个方法可以将实体的关联实体转换成查询对象。如下：

public void joinQuery(){

Session session = HibernateUtil.getSession();

Transaction tx = session.beginTransaction();

String sql = "select p.*,e.*
from person_inf as p,event_inf as e where e.person_id=p.person_id";

List list = session.createSQLQuery(sql)

.addEntity("p",Person.class)

.addJoin("e","p.myEvents")

                .list();

for(Iterator iterator = list.iterator();iterator.hasNext();){

//每个集合元素都是Person、MyEvent所组成的数组

Object[] objects = (Object[]) iterator.next();

Person person = (Person) objects[0];

MyEvent event = (MyEvent) objects[1];

System.out.println("person_id="+person.getId()+" person_name="+person.getName()+" title="+event.getTitle());

　　上面的程序返回的Person对象，其属性myEvent属性已经完全被初始化，不再需要数据库的额外操作，同时将该属性转换成别名为e的实体。也就是说返回的结果是Person、Event对象数组的列表。
　　四、命名查询
　　我们可以将SQL语句不放在程序中，而是放在配置文件中。这样可以更好地提高程序解耦。
Hibernate使用<sql-query.../>元素来配置命名SQL查询，配置<sql-query.../>元素有一个必填的name属性，该属性用于指定该命名SQL查询的名称。
使用<sql-query.../>元素定义命名查询时，可以包含如下几个元素：
            <return.../>：将查询结果转换成持久化实体
            <return-join.../>：预加载持久化实体的关联实体
            <return-scalar.../>：将查询的数据列转换成标量值
在使用命名SQL查询时，不需要调用addEntity()、addScalar()等方法。因为在配置命名SQL查询时，已经指定了查询返回的结果信息。

<sql-query name="sqlquery">

<!-- 将p别名转换为Person实体 -->

<return alias="p" class="Person"
/>

<!-- 将e别名转换成Event实体 -->

<return alias="e" class="MyEvent"
/>

<!-- 指定将person_inf表的name属性列作为标量值返回-->

<return-scalar column="p.name" type="string"/>

select p.*,e.* from person_inf as p,event_inf as e where p.person_id = e.person_id and p.age=:age

</sql-query>

public void query(){

Session session = HibernateUtil.getSession();

//调用命名查询，直接返回结果

List list = session.getNamedQuery("sqlquery")

                .setInteger("age", 30).list();

for(Iterator iterator = list.iterator();iterator.hasNext();){

//每个集合元素都是Person、MyEvent所组成的数组

Object[] objects = (Object[]) iterator.next();

Person person = (Person) objects[0];

MyEvent event = (MyEvent) objects[1];

System.out.println("person_id="+person.getId()+" person_name="+person.getName()+" title="+event.getTitle());

session.close();

Hibernate允许吧把结果集的映射信息放在<resultset.../>元素定义，这样就可让多个命名查询共有该结果集映射。

<resultset name="person_resultSet">

<return alias="p" class="Person" />

<return-scalar column="p.age" type="int"/>

</resultset>

<sql-query name="sqlquery" resultset-ref="person_resultSet">

select p.* from person as p

</sql-query>

　　五、调用存储过程
　　Hibernate可以通过命名SQL查询来调用存储过程或者函数。对于函数，该函数必须返回一个结果集；对于存储过程，该存储过程的第一个参数必须传出参数，且数据类型是结果集。
　　下面是一个简单的存储过程：

Create
procedure select_person()

select
*
from person_inf;

　　如果需要使用该存储过程，可以先将其定义成命名SQL查询，然后在程序中使用。
当使用原生SQL来调用存储过程，应该为<sql-query.../>元素指定callable="true"。

<sql-query name="callProcedure" callable="true">

<return class="Person">

<!-- 将查询的数据列转换成实体的属性 -->

<return-property name="name" column="name"/>

<return-property name="age" column="age" />

<return-property name="person_id" column="id" />

</return>

</sql-query>

通过实体查询，调用addEntity方法。于是问题就此解决了。
引伸一个问题：

hibernate用setResultTransformer转换

　　当你用hibernate查出数据,但是类型不是原来的类型怎么办,新增的实体类还可以用，query.setResultTransformer(Transformers.aliasToBean(AA.class));这种形式可以解决查出来的数据不能使用的问题.

String sql = "select USER_ID,USERNAME from test where USER_ID= :id";

Query query = getCurrentSession().createSQLQuery(sql);//.addScalar("MODULE_ID", LongType.INSTANCE);

query.setBigDecimal("id", new BigDecimal("1"));

query.setResultTransformer(Transformers.aliasToBean(UserEntity.class));

List<UserEntity> list=null;

        list=query.list();

return list;

　　注意：
　　(1)这种转换实体类很严格,必须连属性名字要和数据库字段高度一致(注解此时没很大作用用.
　 (2)实体类可以比表字段少一些字段.

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航