java web项目DAO层通用接口BaseDao与实现类BaseDaoImpl

在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 {
    
}