java Hibernate 用法

Hibernate 用法总结：

 import java.io.Serializable;
 import java.sql.SQLException;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.hibernate.FlushMode;
 import org.hibernate.HibernateException;
 import org.hibernate.Query;
 import org.hibernate.SQLQuery;
 import org.hibernate.Session;
 import org.hibernate.type.Type;
 import org.springframework.orm.hibernate3.HibernateCallback;
 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 import com.krm.dao.DAO;

 /**
  * @Title:
  *
  * @Description: HibernateTemplate是Spring框架接管hibernate的提供方法集合
  *
  * @Copyright: Copyright (c) 2015
  *
  * @author HHT
  */
 public class BaseDAOHibernate extends HibernateDaoSupport implements DAO {

     protected final Log log = LogFactory.getLog(getClass());

     // ---------------------------------------------- VO操作-------------------------------------------- //

     /**
      * 按主键查询，返回唯一结果
      *
      * @param clazz
      *            DTO.class返回值的类
      * @param id
      *            主键(Long型就可以)
      * @return 查询结果
      */
     public Object getObject(Class clazz, Serializable id) {
         return getHibernateTemplate().get(clazz, id); // get
     }

     /**
      * 取得查询结果，返回所有结果
      *
      * @param clazz
      *            DTO.class返回值的类
      * @return 查询结果列表
      */
     public List getObjects(Class clazz) {
         return getHibernateTemplate().loadAll(clazz); // load
     }

     /**
      * 删除数据，按住键删除
      *
      * @param clazz
      *            DTO.class返回值的类
      * @param id
      *            主键(Long型就可以)
      * @return
      */
     public void removeObject(Class clazz, Serializable id) {
         getHibernateTemplate().delete(getObject(clazz, id)); // delete
     }

     /**
      * 删除数据
      *
      * @param o
      *            VO实体类
      * @return
      */
     public void removeObject(Object o) {
         getHibernateTemplate().delete(o); // delete
     }

     /**
      * 更新或插入数据
      *
      * @param o
      *            VO实体类
      * @return
      */
     public void saveObject(Object o) {
         getHibernateTemplate().saveOrUpdate(o); // saveOrUpdate
         getHibernateTemplate().flush();
     }

     /**
      * 经过检索操作，更新或插入数据
      *
      * @param o
      *            VO实体类
      * @return
      */
     public void saveObjectAfterFind(final Object o) {
         getHibernateTemplate().execute(new HibernateCallback() {  // execute
             public Object doInHibernate(Session session) throws HibernateException,
                     SQLException {
                 session.saveOrUpdate(o);
                 session.setFlushMode(FlushMode.COMMIT);
                 session.flush();
                 return null;
             }
         });
     }

     /**
      * 批量更新或插入数据
      *
      * @param objectList
      *            VO实体类
      * @return 查询结果列表
      */
     public void batchSaveOrUpdateVO(final List objectList) {
         HibernateCallback callback = new HibernateCallback() {
             public Object doInHibernate(Session session) throws HibernateException,
                     SQLException {
                 int i = 0;
                 for (Iterator it = objectList.iterator(); it.hasNext();) {
                     session.saveOrUpdate(it.next());
                     if (i % 20 == 0) {
                         session.flush();
                         session.clear();
                     }
                     i++;
                 }
                 session.flush();
                 session.clear();
                 return null;
             }
         };
         getHibernateTemplate().execute(callback); // execute
     }

     // ---------------------------------------------- SQL，HQL语句-------------------------------------------- //

     /**
      * 执行简单的HQL查询，返回多件结果
      *
      * @param hql
      *            HQL查询语句
      * @return 查询结果列表
      */
     protected List list(String hql) {
         return getHibernateTemplate().find(hql); // find
     }

     /**
      * 执行带参数的HQL查询，返回多件结果
      *
      * @param hql
      *            HQL查询语句
      * @param values
      *            HQL语句数组类型的参数
      * @return 查询结果列表
      */
     // String hql = "SELECT * FROM table WHERE entityId=? AND entityKind=? AND status=1 ORDER BY dispOrder";
     // list(hql, new Object[]{entityId, accessoryType});
     protected List list(String hql, Object[] values) {
         return getHibernateTemplate().find(hql, values); // find
     }    

     /**
      * 执行带参数的HQL查询，返回多件结果
      *
      * @param hql
      *            HQL查询语句
      * @param parameters
      *            HQL语句Map类型的参数
      * @return 查询结果列表
      */
     // String hql = "from ImportRule t where t.report_type=:type and t.reportid=:reportid";
     // Map map = new HashMap();
     // map.put("type",report_type);
     // map.put("reportid",reportid);
     // list(hql,map);
     protected List list(final String hql, final Map parameters) {
         HibernateCallback callback = new HibernateCallback() {
             public Object doInHibernate(Session session) throws HibernateException,
                     SQLException {
                 Query query = session.createQuery(hql);
                 setQueryParameters(query, parameters);
                 return query.list();
             }
         };
         return (List) getHibernateTemplate().execute(callback); // execute
     }

     // 方法重载
     // Object[][] scalaries = {{"money", Hibernate.DOUBLE}};
     // List list = list(sql, null, scalaries);
     protected List list(String sql, Object[][] entities, Object[][] scalaries) {
         return list(sql, entities, scalaries, null);
     }

     // 方法重载
     protected List list(String sql, Object[][] entities, Object[][] scalaries, int maxResults) {
         return list(sql, entities, scalaries, null, maxResults);
     }

     // 方法重载
     // String sql = "SELECT {u.*} " + "FROM table u WHERE  u.status = '1'  AND u.loginname=? AND u.password = ?" ;
     // list(sql, new Object[][]{{"u", User.class}}, null, new Object[]{loginName, passWord});
     //------------------上种方法必须配置VO实体类表映射xml文件 下面则不用--------------------------------------------------
     // String sql = "SELECT rdf.PKID AS PKID,rdf.ORGAN_ID AS ORGAN_ID FROM table rdf WHERE rdf.report_id = ?  AND rdf.report_date = ? AND rdf.organ_id ='"+organId +"'";
     // Object[][] scalaries = {{"PKID", Hibernate.LONG}, {"ORGAN_ID", Hibernate.STRING}};
     // List result = list(sql, null, scalaries, new Object[]{reportId, reportDate});
     // ------------------下面的方法结果解析麻烦-----------------------------
     // for (Iterator it = result.iterator(); it.hasNext();)
     // {
     //         Object[] oa = (Object[])it.next();
     //         (Long)oa[0];
     //         (String)oa[1];
     // }
     protected List list(String sql, Object[][] entities, Object[][] scalaries, Object[] values) {
         return list(sql, entities, scalaries, values, 0);
     }

     // 方法重载
     protected List list(String sql, Object[][] entities, Object[][] scalaries, Object[] values, int maxResults) {
         return list(sql, entities, scalaries, values, 0, maxResults);
     }

     // 方法重载
     protected List page(String sql, Object[][] entities, Object[][] scalaries, Object[] values, int pageNo, int pageSize) {
         return list(sql, entities, scalaries, values, (pageNo - 1) * pageSize, pageSize);
     }

     /**
      * 执行HQL或SQL的带分页功能的查询(数据量大时，分页有效率问题)，返回多件结果
      *
      * @param sql
      *            HQL或者SQL查询语句
      * @param entities
      *            表别名和映射BEAN的类型
      * @param scalaries
      *                SQL列类型映射
      * @param values
      *            参数列表，替换语句中的？参数
      * @param firstResult
      *            分页参数 起始位置
      * @param maxResults
      *            分页参数 最大上限
      * @return list 查询结果集
      */
     protected List list(final String sql, final Object[][] entities,
             final Object[][] scalaries, final Object[] values, final int firstResult,
             final int maxResults) {
         try {
             HibernateCallback callback = new HibernateCallback() {
                 public Object doInHibernate(Session session) throws HibernateException,
                         SQLException {
                     // Query query = session.createQuery(sql);
                     // Query只能执行HQL语句，但是以Hibernate生成的Bean为对象装入List返回
                     // SQLQuery 可以执行原生SQL语句，以对象数组返回，可以用addEntity()方法指定映射Bean
                     SQLQuery query = session.createSQLQuery(sql);
                     // 追加结果映射的BEAN
                     if (entities != null) {
                         for (int i = 0; i < entities.length; i++) {
                             query.addEntity(entities[i][0].toString(),
                                     (Class) entities[i][1]);
                         }
                     }
                     //
                     if (scalaries != null) {
                         for (int i = 0; i < scalaries.length; i++) {
                             query.addScalar(scalaries[i][0].toString(), (Type) scalaries[i][1]);
                         }
                     }
                     // 设置查询参数
                     setQueryParameters(query, values);
                     // 分页起始位置
                     if (firstResult > 0) {
                         query.setFirstResult(firstResult);
                     }
                     // 分页上位置
                     if (maxResults > 0) {
                         query.setMaxResults(maxResults);
                     }
                     return query.list();
                 }
             };
             return (List) getHibernateTemplate().execute(callback); // execute
         } catch (Exception e) {
             // log.error(" BaseDAOHIBERNATE list is error" + e.getMessage());
             return null;
         }
     }

     /**
      * 执行HQL查询，返回唯一结果
      *
      * @param hql
      *            HQL查询语句
      * @return 查询结果对象
      */
     protected Object uniqueResult(final String hql) {
         HibernateCallback callback = new HibernateCallback() {
             public Object doInHibernate(Session session) throws HibernateException,
                     SQLException {
                 return session.createQuery(hql).uniqueResult();
             }
         };
         return getHibernateTemplate().execute(callback); // execute
     }

     /**
      * 执行HQL查询，返回唯一结果
      *
      * @param hql
      *            HQL查询语句
      * @param parameters
      *            HQL语句Map类型的参数
      * @return 查询结果对象
      */
     protected Object uniqueResult(final String hql, final Map parameters) {
         HibernateCallback callback = new HibernateCallback() {
             public Object doInHibernate(Session session) throws HibernateException,
                     SQLException {
                 Query query = session.createQuery(hql);
                 setQueryParameters(query, parameters);
                 return query.uniqueResult();
             }
         };
         return getHibernateTemplate().execute(callback); // execute
     }

     /**
      * 执行HQL查询，返回唯一结果
      *
      * @param hql
      *            HQL查询语句
      * @param values
      *            HQL语句数组类型的参数
      * @return 查询结果对象
      */
     protected Object uniqueResult(final String hql, final Object[] values) {
         HibernateCallback callback = new HibernateCallback() {
             public Object doInHibernate(Session session) throws HibernateException,
                     SQLException {
                 Query query = session.createQuery(hql);
                 setQueryParameters(query, values);
                 return query.uniqueResult();
             }
         };
         return getHibernateTemplate().execute(callback); // execute
     }

     private void setQueryParameters(Query query, Object[] values) {
         if (values != null) {
             for (int i = 0; i < values.length; i++) {
                 query.setParameter(i, values[i]);
             }
         }
     }

     private void setQueryParameters(Query query, Map parameters) {
         if (parameters != null) {
             for (Iterator it = parameters.entrySet().iterator(); it.hasNext();) {
                 Map.Entry entry = (Map.Entry) it.next();
                 String paramName = (String) entry.getKey();
                 Object paramValue = entry.getValue();
                 if (paramValue instanceof Collection) {
                     query.setParameterList(paramName, (Collection) paramValue);
                 } else if (paramValue instanceof Object[]) {
                     query.setParameterList(paramName, (Object[]) paramValue);
                 } else {
                     query.setParameter(paramName, paramValue);
                 }
             }
         }
     }

     /**
      * 更新，删除或插入数据
      *
      * @param sql
      *            HQL或者SQL查询语句
      * @return boolean 是否有影响的记录
      */
     public boolean save(final String sql) {
         Integer result = (Integer) getHibernateTemplate().execute( // execute
                 new HibernateCallback() {
                     public Object doInHibernate(Session session) throws HibernateException,
                             SQLException {
                         Query query = session.createQuery(sql);
                         int rowCount = query.executeUpdate();
                         session.flush();
                         return rowCount;
                     }
                 });
         if (result > 0) {
             return true;
         } else {
             return false;
         }
     }
 }