在spring+hibernate的web項目中，處理數據層通常會使用Spring框架提供的HibernateTemplate類提供的方法。通常的用法是每一個實體類對應的去寫DAO層的接口和實現類。每個實現類中都寫hibernateTemp.save(entity)、hibernateTemp.update(entity)、hibernateTemp.get(id)...這樣寫固然沒錯，但存在着大量的重復代碼。所以懶惰的程序員煩了，他們要寫一個通用的實現類來解決這個問題，讓DAO層解放出來。如果有特殊的需要則在實現類中寫個方法去處理，沒有特殊的需要那么我們就不用在寫DAO層的代碼了。
下面是我寫的一個通用DAO層接口和實現類，初次寫這種通用型的代碼可能會有很多不到位的地方，如果您看到了，請在評論中不吝賜教，謝謝！
BaseDao.Java
package org.lxl.mr.common.base.db;
import java.util.List;
/**
* 通用數據層接口
* @author liuXueLiang
* @param <Entity>
* @param <PK>
*/
public interface BaseDao<Entity,PK> {
/**
* 增加
* @param entity
*/
public void save(Entity entity);
/**
* 修改
* @param entity
*/
public void update(Entity entity);
/**
* 刪除
* @param entity
*/
public void delete(Entity entity);
/**
* 通過主鍵刪除
* @param pk
* @param pkName
*/
public void deleteByPK(final PK pk,final String pkName);
/**
* 通過主鍵查詢
* @param pk
* @return
*/
public Entity get(PK pk);
/**
* 通過主鍵查詢，延遲加載
* @param pk
* @return
*/
public Entity load(PK pk);
/**
* 查詢全部
* @return
*/
public List<Entity> findAll();
}
BaseDaoImpl.java
package org.lxl.mr.common.base.db;
import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.lxl.mr.common.page.Pagination;
import org.lxl.mr.common.util.ReflectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.util.Assert;
/**
* 通用數數據層實現
* @author liuXueLiang
* @param <Entity>
* @param <PK>
*/
public class BaseDaoImpl<Entity,PK extends Serializable> extends HibernateDaoSupport implements BaseDao<Entity, PK> {
/**
* 給HibernateDaoSupport中的hibernateTemplate賦值
* @param sessionFactory
*/
@Autowired
public void setMySessionFactory(SessionFactory sessionFactory){
super.setSessionFactory(sessionFactory);
}
/**
* 子類的類對象
*/
private Class<Entity> entityClass;
/**
* 創建對象時給entityClass賦值
*/
protected BaseDaoImpl(){
this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
}
/**
* 增加
* @param entity
*/
@Override
public void save(Entity entity) {
super.getHibernateTemplate().save(entity);
}
/**
* 修改
* @param entity
*/
@Override
public void update(Entity entity) {
super.getHibernateTemplate().update(entity);
}
/**
* 通過主鍵刪除 PK為主鍵的類型
* @param pk 主鍵值
* @param pkName主鍵名稱（如：id、uuid）
*/
@Override
public void deleteByPK(final PK pk,final String pkName) {
Integer executeCount = super.getHibernateTemplate().execute(new HibernateCallback<Integer>(){
@Override
public Integer doInHibernate(Session session) throws HibernateException, SQLException {
Assert.hasText(pkName);
Assert.notNull(pk);
String hql = "delete from "+entityClass.getName()+" where "+pkName+":=pk";
Query query = session.createQuery(hql);
if(pk instanceof java.lang.Integer){
query.setInteger("pk", (Integer) pk);
}
else if(pk instanceof java.lang.Long){
query.setLong("pk", (Long) pk);
}
else if(pk instanceof java.lang.String){
query.setString("pk", (String) pk);
}
else{
throw new RuntimeException("Does not support the type of the primary key! The primary key only support the type Integer,Long,String types. ");
}
return query.executeUpdate();
}
});
if(executeCount!=1)
throw new RuntimeException("Through the primary key to delete data failed");
}
/**
* 刪除
* @param entity
*/
@Override
public void delete(Entity entity) {
super.getHibernateTemplate().delete(entity);
}
/**
* 通過主鍵查詢 PK為主鍵類型
* @param pk 主鍵值
*/
@Override
public Entity get(PK pk) {
return super.getHibernateTemplate().get(entityClass, pk);
}
/**
* 通過主鍵查詢，延遲加載 PK為主鍵類型
* @param pk 主鍵值
*/
@Override
public Entity load(PK pk) {
return super.getHibernateTemplate().load(this.entityClass, pk);
}
/**
* 查詢全部
* @return List<Entity>
*/
@Override
public List<Entity> findAll() {
return this.findListByMap(null);
}
/**
* 根據條件查詢唯一對象
* @param map
* @return Entity
*/
public Entity findUnique(final Map<String,Object> map){
return getHibernateTemplate().execute(new HibernateCallback<Entity>(){
@SuppressWarnings("unchecked")
@Override
public Entity doInHibernate(Session session) throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
if(map!=null){
criteria.add(Restrictions.allEq(map));
}
return (Entity) criteria.uniqueResult();
}
});
}
/**
* 根據條件查詢
* @param map
* @return List<Entity>
*/
@SuppressWarnings("unchecked")
public List<Entity> findListByMap(final Map<String,Object> map){
return (List<Entity>) getHibernateTemplate().execute(new HibernateCallback<Entity>(){
@Override
public Entity doInHibernate(Session session) throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(entityClass);
if(map!=null){
criteria.add(Restrictions.allEq(map));
}
return (Entity) criteria.list();
}
});
}
@SuppressWarnings("unchecked")
public List<Entity> findListByDetachedCriteria(final DetachedCriteria detachedCriteria){
return (List<Entity>) getHibernateTemplate().execute(new HibernateCallback<List<Entity>>(){
@Override
public List<Entity> doInHibernate(Session session) throws HibernateException, SQLException {
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
return (List<Entity>) criteria.list();
}
});
}
/**
* 使用HQL語句查詢唯一對象
* @param hql
* @param paramMap
* @return Entity
*/
@SuppressWarnings("unchecked")
public Entity findByHqlUnique(final String hql,final Map<String,Object> paramMap){
Assert.hasText(hql);
return (Entity) createHqlQuery(hql, paramMap).uniqueResult();
}
/**
* 使用HQL語句查詢
* @param hql
* @param paramMap
* @return List<Entity>
*/
@SuppressWarnings("unchecked")
public List<Entity> findByHQL(final String hql,final Map<String,Object> paramMap){
Assert.hasText(hql);
return createHqlQuery(hql, paramMap).list();
}
/**
* 使用SQL語句查詢唯一對象
* @param sql
* @param paramMap
* @return
*/
public Object findBySQLUnique(final String sql,final Map<String,Object> paramMap){
Assert.hasLength(sql);
return createSqlQuery(sql, paramMap).uniqueResult();
}
/**
* 使用SQL語句查詢唯一對象
* @param sql
* @param paramMap
* @return
*/
@SuppressWarnings("unchecked")
public <T> List<T> findBySQL(final String sql,final Map<String,Object> paramMap){
Assert.hasText(sql);
return (List<T>) createSqlQuery(sql, paramMap).list();
}
/**
* 批處理，使用HQL語句
* @param hql
* @param values
* @return
*/
public int execHQLBatchByMap(final String hql,final Map<String,Object> values){
Assert.hasText(hql);
return getHibernateTemplate().execute(new HibernateCallback<Integer>(){
@Override
public Integer doInHibernate(Session session) throws HibernateException, SQLException {
Query query = session.createQuery(hql);
query.setProperties(values);
return query.executeUpdate();
}
});
}
/**
* 批處理，使用SQL語句
* @param sql
* @param values
* @return
*/
public int execSQLBatchByMap(final String sql,final Map<String,Object> values){
Assert.hasText(sql);
return getHibernateTemplate().execute(new HibernateCallback<Integer>(){
@Override
public Integer doInHibernate(Session session) throws HibernateException, SQLException {
Query query = session.createSQLQuery(sql);
query.setProperties(values);
return query.executeUpdate();
}
});
}
/**
* HQL分頁
* @param hql
* @param pageNo
* @param pageSize
* @param map
* @return
*/
@SuppressWarnings("rawtypes")
public Pagination findPageByHql(final String hql,final int pageNo,final int pageSize,
final Map<String,Object> map){
Query query = createHqlQuery(hql, map);
Pagination page = new Pagination();
page.setPageSize(pageSize);
page.setPageNo(pageNo);
return this.pageResult(page, hql, null, query, map);
}
@SuppressWarnings("rawtypes")
public Pagination findPageBySql(final String sql,int pageNo,int pageSize,
final Map<String,Object> map){
Query query = this.createSqlQuery(sql, map);
Pagination page = new Pagination();
page.setPageSize(pageSize);
page.setPageNo(pageNo);
return this.pageResult(page, null, sql, query, map);
}
@SuppressWarnings("rawtypes")
private Pagination pageResult(final Pagination page,String hql,
String sql,Query query,final Map<String,Object> map){
Pagination pagination = page;
Object obj = null;
if(hql!=null && !"".equals(hql)){
obj = createHqlQuery(hql, map).uniqueResult();
}else if(sql!=null && !"".equals(sql)){
obj = createSqlQuery(sql, map).uniqueResult();
}else{
return null;
}
int totalCount = Integer.parseInt(obj.toString());
pagination.setTotalCount(totalCount);
//查詢列表，並保存到pagination對象中
if(pagination.getPageSize()>0){
query.setMaxResults(pagination.getPageSize());
query.setFirstResult(pagination.getFirstResult());
}
pagination.setList(query.list());
return pagination;
}
/**
* 創建Query對象，用來處理HQL查詢
* @param hql
* @param paramMap
* @return
*/
protected Query createHqlQuery(final String hql,final Map<String,Object> paramMap){
Assert.hasText(hql);
return getHibernateTemplate().execute(new HibernateCallback<Query>(){
@Override
public Query doInHibernate(Session session) throws HibernateException, SQLException {
if(session==null){
session = getSessionFactory().getCurrentSession();
}
Query query = session.createQuery(hql);
query.setProperties(paramMap);
return query;
}
});
}
/**
* 創建Query對象，用來處理SQL查詢
* @param sql
* @param paramMap
* @return
*/
protected Query createSqlQuery(final String sql,final Map<String,Object> paramMap){
Assert.hasText(sql);
return getHibernateTemplate().execute(new HibernateCallback<Query>(){
@Override
public Query doInHibernate(Session session) throws HibernateException, SQLException {
Query query = session.createSQLQuery(sql);
query.setProperties(paramMap);
return query;
}
});
}
}
使用
UserDao.java
package org.lxl.mr.dao;
import org.lxl.mr.common.base.db.BaseDao;
import org.lxl.mr.pojo.User;
public interface UserDao extends BaseDao<User, String>{
}
UserDaoImpl.java
package org.lxl.mr.dao.impl;
import org.lxl.mr.common.base.db.BaseDaoImpl;
import org.lxl.mr.dao.UserDao;
import org.lxl.mr.pojo.User;
import org.springframework.stereotype.Component;
@Component
public class UserDaoImpl extends BaseDaoImpl<User, String> implements UserDao {
}