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;
}
}
}