Hibernate_HibernateCallback

HibernateTemplate还提供一种更加灵活的方式来操作数据库，通过这种方式可以完全使用Hibernate的操作方式。HibernateTemplate的灵活访问方式是通过如下两个方法完成：

Object execute(HibernateCallback action)

List execute(HibernateCallback action)

这两个方法都需要一个HibernateCallback的实例，HibernateCallback实例可在任何有效的Hibernate数据访问中使用。程序开发者通过HibernateCallback，可以完全使用Hibernate灵活的方式来访问数据库，解决Spring封装Hibernate后灵活性不足的缺陷。HibernateCallback是一个接口，该接口只有一个方法doInHibernate(org.hibernate.Session session)，该方法只有一个参数Session。在开发中提供HibernateCallback实现类时，必须实现接口里包含的 doInHibernate方法，在该方法体内即可获得Hibernate Session的引用，一旦获得了Hibernate Session的引用，就可以完全以Hibernate的方式进行数据库访问。

注意：方法doInHibernate方法内可以访问Session，该Session对象是绑定到该线程的Session实例。该方法内的持久层操作，与不使用Spring时的持久层操作完全相同。这保证对于复杂的持久层访问，依然可以使用Hibernate的访问方式。

 

通常，程序中采用实现HibernateCallback的匿名内部类来获取HibernateCallback的实例，方法doInHibernate的方法体就是Spring执行的持久化操作。具体代码如下：

 

public class PersonDaoImpl implements PersonDao

{

 private SessionFactory sessionFactory;

 public void setSessionFactory(SessionFactory sessionFactory){

  this.sessionFactory = sessionFactory;

 }

 /**

  * 

  * 通过人名查找所有匹配该名的Person实例

  * 

  * @param name

  *            匹配的人名

  * 

  * @return 匹配该任命的全部Person集合

  * 

  */

 public List findPersonsByName(final String name){

  HibernateTemplate hibernateTemplate =new HibernateTemplate(this.sessionFactory); // 创建HibernateTemplate实例

  return (List) hibernateTemplate.execute( // 返回HibernateTemplate的execute的结果

    // 创建匿名内部类

    new HibernateCallback(){

     public Object doInHibernate(Session session) throws HibernateException{

      List result = session.createCriteria(Person.class).add(Restrictions.like("name", name+"%").list();

      return result;

     }

    });

    }

}

 

 

---------------------------------------------------------------

Spring 对 hibernate 的集成（使用回调callback）

 

比如在删除一条在数据库操作的时候 我们一般是类似是这样使用：

this.getHibernateTemplate().delete("from Information where INFOID='"+infoid.trim()+"'");

 

然而具体在spring内部是怎么操作的呢？

delete()----->excecute()----->执行回调方法HibernateCallback .doInHibernate()。

 

下面来让我们来直接看一下spring的源代码。

//hibernate回调接口

public interface HibernateCallback {

Object doInHibernate(Session session) throws HibernateException, SQLException;

}

//...

 

package org.springframework.orm.hibernate;

public class HibernateTemplate extends HibernateAccessor implements HibernateOperations {

//...

 

public int delete(final String queryString) throws DataAccessException {

  Integer deleteCount = (Integer) execute(new HibernateCallback() {//定义回调实现

   public Object doInHibernate(Session session) throws HibernateException {

    checkWriteOperationAllowed(session);

    return new Integer(session.delete(queryString));//此处有hibernate的实现操作

   }

  });

  return deleteCount.intValue();

 }

 

 public Object execute(HibernateCallback action) throws DataAccessException {

  Session session = (!isAllowCreate() ? SessionFactoryUtils.getSession(getSessionFactory(), false) :

  SessionFactoryUtils.getSession(getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator()));

  boolean existingTransaction = TransactionSynchronizationManager.hasResource(getSessionFactory());

  if (!existingTransaction && getFlushMode() == FLUSH_NEVER) {

   session.setFlushMode(FlushMode.NEVER);

  }

  try {

   Object result = action.doInHibernate(session);//此处调用hibernatecallback回调接口即hibernate的实现

   flushIfNecessary(session, existingTransaction);

   return result;

  }

  catch (HibernateException ex) {

   throw convertHibernateAccessException(ex);

  }

  catch (SQLException ex) {

   throw convertJdbcAccessException(ex);

  }

  catch (RuntimeException ex) {

   // callback code threw application exception

   throw ex;

  }

  finally {

   SessionFactoryUtils.closeSessionIfNecessary(session, getSessionFactory());

  }

 }

 

//...

 

//其他操作类似

}

 

--------------------------------------------------------

Hibernate中运用doInHibernate 构造公用findByhql和updateByHql方法

 

在hibernate中，运用doInHibernate，避免了手动open session和close session ,减少了一系列session关闭的麻烦。

 

公用的setParameter 方法，下面有调用，传入一个query 实例，和Map<String, Object> map 类型的参数

private void setParameter(Query query, Map<String, Object> map) {

  if (map != null && !map.isEmpty()) {

   Set<String> keySet = map.keySet();

   for (String string : keySet) {

    Object obj = map.get(string);

    // 这里考虑传入的参数是什么类型，不同类型使用的方法不同

    if (obj instanceof Collection<?>) {

     query.setParameterList(string, (Collection<?>) obj);

    } else if (obj instanceof Object[]) {

     query.setParameterList(string, (Object[]) obj);

    } else {

     query.setParameter(string, obj);

    }

   }

  }

 }

 

 

public void updateByHql(final String hql, final Map<String, Object> map) throws Exception {

  template.execute(new HibernateCallback() {

      @Override

      public Object doInHibernate(Session session) throws HibernateException, SQLException {

         Query query = session.createQuery(hql);

         setParameter(query, map); //调用set参数的方法

         query.executeUpdate();

         return null;

         }

      });

    }

 

public List<Object> findByHql(final String hql, final Map<String, Object> map) throws Exception {

  return (List<Object>) template.execute(new HibernateCallback() {

   public List<Object> doInHibernate(final Session session) throws HibernateException, SQLException {

    Query query = session.createQuery(hql);

    setParameter(query, map);

    return query.list();

   }

  });

}

 

 

调用例子：

String hql = "from ABC where bb = :aa";

  Map<String, Object> map = new HashMap<String, Object>();

  map.put("aa", 22);

  List<Object> cList = commonDao.findByHql(hql, map);

  if (cList == null || cList.size() == 0)

   return null;

  else

   return (ABC) cList.get(0);

 

update类似与query，只是没有返回参数

 

 

 

--------------------------------------------------------

下面的代码对HibernateDaoSupport类进行扩展（虽然Spring 2.0的HibernateTemplate提供了一个分页方法setMaxResults，但仅此一个方法依然不能实现分页查询），这种扩展主要是为该类增加了3个分页查询的方法，分页查询时必须直接调用Hibernate的Session完成，因此，必须借助于HibernateCallBack的帮助。

public class YeekuHibernateDaoSupport extends HibernateDaoSupport

{

    /**

     * 使用hql 语句进行分页查询操作

     * @param hql 需要查询的hql语句

     * @param offset 第一条记录索引

     * @param pageSize 每页需要显示的记录数

     * @return 当前页的所有记录

     */

    public List findByPage(final String hql, final int offset, final int pageSize)

    {

        //HibernateDaoSupport已经包含了getHibernateTemplate()方法

        List list = getHibernateTemplate().executeFind(new

        HibernateCallback()

            {

                public Object doInHibernate(Session session) throws HibernateException, SQLException

                //该方法体内以Hibernate方法进行持久层访问

                {

                    List result = session.createQuery(hql) .setFirstResult(offset) .setMaxResults(pageSize) .list();

                    return result;

                }

            });

        return list;

    }

    /**

     * 使用hql 语句进行分页查询操作

     * @param hql 需要查询的hql语句

     * @param value 如果hql有一个参数需要传入，value就是传入的参数

     * @param offset 第一条记录索引

     * @param pageSize 每页需要显示的记录数

     * @return 当前页的所有记录

     */

    public List findByPage(final String hql , final Object value , final int offset, final int pageSize)

    {

        List list = getHibernateTemplate().executeFind(new

        HibernateCallback()

            {

                public Object doInHibernate(Session session) throws HibernateException, SQLException

                {

                    //下面查询的是最简单的Hiberante HQL查询

                    List result = session.createQuery(hql) .setParameter(0, value) .setFirstResult(offset) .setMaxResults(pageSize) .list();

                    return result;

                }

            });

        return list;

    }

    /**

     * 使用hql 语句进行分页查询操作

     * @param hql 需要查询的hql语句

     * @param values 如果hql有多个参数需要传入，values就是传入的参数数组

     * @param offset 第一条记录索引

     * @param pageSize 每页需要显示的记录数

     * @return 当前页的所有记录

     */

    public List findByPage(final String hql, final Object[] values, final int offset, final int pageSize)

    {

        List list = getHibernateTemplate().executeFind(new

        HibernateCallback()

            {

                public Object doInHibernate(Session session) throws HibernateException, SQLException

                {

                    Query query = session.createQuery(hql);

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

                    {

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

                    }

                    List result = query.setFirstResult(offset) .setMaxResults(pageSize) .list();

                    return result;

                }

            });

        return list;

    }

}

在上面的代码实现中，直接使用了getHibernateTemplate()方法，这个方法由Hibernate- DaoSupport提供。而YeekuHibernateDaoSupport是HibernateDaoSupport的子类，因此，可以直接使用该方法。

当实现doInHibernate(Session session)方法时，完全以Hibernate的方式进行数据库访问，这样保证了Hibernate进行数据库访问的灵活性。

注意：Spring提供的XxxTemplate和XxxCallBack互为补充，二者体现了Spring框架设计的用心良苦：XxxTemplate对通用操作进行封装，而XxxCallBack解决了封装后灵活性不足的缺陷。

 

 

--------------------------------------------------------

Spring和Hibernate集成的HibernateTemplate的一些常用方法总结

 

1：get/load存取单条数据

public Teacher getTeacherById(Long id) {  

    return (Teacher)this.hibernateTemplate.get(Teacher.class, id);  

}  

public Teacher getTeacherById(Long id) {  

    return (Teacher)this.hibernateTemplate.load(Teacher.class, id);  

}  

 

2：find/iterate查询操作

public Iterator getTeachersByAge(int age) {  

    Iterator iterator = null;  

      

    //使用find方法  

    List list = (List)this.hibernateTemplate().find("from Teacher t where t.age>?", new Integer(age));  

    iterator = list.iterator();  

      

    //使用iterator方法  

    iterator = this.hibernateTemplate().iterate("from Teacher t where t.age>?", new Integer(age));  

      

    return iterator;  

}  

find和iterato的区别主要是iterate采用了N+1次查询，对于大批量查询，比如查询10000条记录，那么iterate就要执行10000+1次查询，find和iterate应根据具体的实际

情况来使用，对于频繁的写操作对象，应使用find查询，而对于一些只读的数据对象，应使用iterate操作，因为iterate操作使用了Hibernate的缓存机制

 

3：save/update/saveOrUpdate/delete 保存/更新/删除操作  

public void save(Teacher teacher) {  

    this.hibernateTemplate.save(teacher);  

}  

public void update(Teacher teacher) {  

    this.hibernateTemplate.update(teacher);  

}  

public void update(Teacher teacher) {  

    this.hibernateTemplate.saveOrUpdate(teacher);  

}  

public void update(Teacher teacher) {  

    this.hibernateTemplate.delete(teacher);  

}  

 

4：bulkUpdate批量删除或者更新

bulkUpdate提供了批量删除和更新，直接转换为相应的update/delete SQL进行批量删除和更新

public void batchDelete(String name, int age) {  

    this.hibernateTemplate.bulkUpdate("delete Teacher where name=? and age = ?", new Object[]{name, age});  

}  

public void batchUpdate(String name, String newName) {  

    this.hibernateTemplate.bulkUpdate("update Teacher set name=? where name=?", new Object[]{newName, name});  

}  

此时要注意的一个问题是，使用bulkUpdate操作，必须手工清除相关对象在Hibernate中的缓存(包括一级缓存和二级缓存)

 

5：execute核心方法

public Object execute(HibernateCallBack action, boolean exposeNativeSession) throws DataAccessException {  

        Session session = getSession();  //获取一个Session  

        boolean existingTransaction = SessionFactoryUtils.isSessionTransactional(session, getSessionFactory());  //当前session是否在事务中  

        FlushMode previousFlushMode = null;  

        try {  

            previousFlushMode = applyFlushMode(session, existingTransaction); //应用flush模式  

            enableFilters(session);  

              

            Session sessionToExpose = (exposeNativeSession? session: createSessionProxy(session));  //暴露给action的session  

            Object result = action.doInHibernate(sessionToExpose);  //执行action  

            flushIfNecessary(session, existingTransaction);  

            return result;  

              

        } catch(HibernateException ex) {  

            throw convertHibernateAccessException(ex);  

        } catch(SQLException ex) {  

            throw convertJdbcAccessException(ex);  

        } catch(RuntimeException ex) {  

            throw ex;  

        } finally {  

            if(existingTransaction) {  //如果session在事务中，则不关闭session  

                disableFilters(session);  

                if(previousFlushMode != null) {  

                    session.setFlushMode(previousFlushMode);  

                }  

            } else {  

                SessionFactoryUtils.releaseSession(session, getSessionFactory());  //释放session  

            }  

        }  

    }  

*HibernateCallBack，一般用来实现特定的业务逻辑

*exposeNativeSession：是一个布尔值，要暴露给HibernateCallBack实际的session对象，而不是一个代理过的对象

 

6：一般情况下，只有HIberateTemplate提供的方法不能满足要求时才使用execute方法，它的使用情况如下所示，

public void createDatabaseSchema() throws DataAccessException {  

    HibernateTemplate hibernateTemplate = new HibernateTemplate(this.sessionFactory);  

    //调用HibernateTempalte的execute方法  

    hibernateTemplate.execute(new HibernateCallback() {  

        public Object doInHibernate(Session session) throws HibernateException, SQLException {  //实现HibernateCallback的doInHibernate方法  

            //具体实现  

            Connection conn = session.connection();  

            final Dialect dialect = Dialect.getDialect(configuration.getProperties);  

            String[] sql = configuration.generateSchemaCreationScript(dialect);  

            executeSchemaScript(conn, sql);  

        }  

    });  

}  

使用execute方法的重点是实现HibernateCallback的doInHibernate方法，它会传递一个Session实例，可以使用此Session实例操作数据库，由此看出execute方法的好处是应用程序不用关心session的创建和释放，只需要处理关心的业务逻辑即可。

 

--------------------------------------------------------

 

ref: 

http://www.blogjava.net/rain1102/articles/170638.html

http://blog.csdn.net/changewang/article/details/575191

http://yunqiang-zhang-hotmail-com.iteye.com/blog/1973010

http://www.linuxidc.com/Linux/2011-12/48719.htm