泛型dao架构实现,封装crud等基本操作

hyj_dx

浏览: 99626 次
性别:
来自: 深圳

最近访客更多访客>>

w2745554997

lzylin

ln_lz

guiyun1989

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

spring struts spring

DAO Hibernate SQL JDBC Spring

今天闲着没事,根据公司的框架中的程序架构进行了修改增加了泛型实现

其中包括4个基类 BaseDao.java, BaseDAOHibernate.java,BaseManager.java,BaseManagerImpl.java

1. dao接口基类

/**
 * BaseDAO.java
 *
 *
 */
package com.easou.ad.dao;

import java.util.HashMap;
import java.util.List;

public interface BaseDAO<E> {

    /**
     * 根据主键获得实体
     * 
     * @param id 实体主键
     * @return BaseEntity
     */
    E getEntity(Long id);

    /**
     * 获得所有实体
     * 
     * @return List
     */
    List<E> getAllEntity();

    /**
     * 保存实体
     * 
     * @param entity pojo instance
     */
    void saveEntity(E entity);

    /**
     * 根据主键删除实体
     * 
     * @param id 实体主键
     */
    void removeEntity(Long id);

    public List<E> search(HashMap con ,int page,int rowsPerPage);
	public List<E> search(HashMap con);
}

2. dao实现类

/**
 * BaseDAOHibernate.java
 *
 *Copyright 2007 easou, Inc. All Rights Reserved.
 */
package com.easou.ad.dao.hibernate;

import java.lang.reflect.ParameterizedType;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;


import com.easou.framework.util.PageList;
import com.easou.ad.dao.BaseDAO;


public abstract class BaseDAOHibernate<E> extends HibernateDaoSupport implements
        BaseDAO<E> {
    protected final Log log = LogFactory.getLog(this.getClass().getName());
    protected Class<E> clazz;
 
    public BaseDAOHibernate() {
     
        this.clazz =(Class<E>)((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];     
    }
    /**
     * 根据主键获得实体
     * 
     * @param id 实体主键
     * @return 实体对象
     */
    @SuppressWarnings("unchecked")
	public final E getEntity(final Long id) {
        return (E)getHibernateTemplate().get(clazz, id);
    }

    /**
     * 获得所有实体
     * 
     * @return List
     */
    @SuppressWarnings("unchecked")
    public final List<E> getAllEntity() {
        PageList result = new PageList();
        List l = getHibernateTemplate().loadAll(clazz);
        result.addAll(l);
        result.setCurrentPage(1);
        result.setPageCount(1);
        result.setTotalRowCount(l.size());
        return result;
    }

    /**
     * 保存实体
     * 
     * @param entity 实体对象
     */
    public final void saveEntity(final E entity) { 
            getHibernateTemplate().saveOrUpdate(entity);
    }

    /**
     * 根据主键删除实体
     * 
     * @param id 实体主键
     */
    public final void removeEntity(final Long id) {
        Object o = getEntity(id);
        if (null != o) {
            getHibernateTemplate().delete(o);
        }
    }

    /**
     * 执行批量更新和删除操作的HQL
     * 
     * @param sql hql语句
     * @return PageList
     */
    @SuppressWarnings("unchecked")
	protected final List<E> executeHQL(final String sql) {
        Session session = null;
        List<E> ret = null;
        try {
        	log.info(sql);
            session = this.getSession();
            if (sql.toUpperCase().startsWith("DELETE")
                    || sql.toUpperCase().startsWith("UPDATE")) {
                session.createQuery(sql).executeUpdate();
            } else {
                ret = session.createQuery(sql).list();
            }
        } catch (HibernateException e) {
            log.error("executeHQL() error:" + sql, e);
            throw convertHibernateAccessException(e);
        } finally {
            this.releaseSession(session);
        }
        return ret;
    }

    /**
     * 执行分页查询
     * 
     * @param selectField HQL语句中，SELECT 的内容(如果设置了此参数值,则sql参数中不可带SELCT语句部分)
     * @param countField HQL语句中，count 的内容
     * @param sql HQL语句
     * @param page 第几页
     * @param rowsPerPage 每页记录数
     * @return PageList
     */
    @SuppressWarnings("unchecked")
	protected final List<E> pageListQuery(final String selectField,
            String countField, String sql, int page, int rowsPerPage) {
        PageList result = new PageList();
        Session session = null;
        try {
            session = this.getSession();
            // 预留count的sql语句
            String countSql = sql.substring(sql.toUpperCase().indexOf("FROM"));
            // 设置返回的列，进行查询
            if (null != selectField) {
                sql = "SELECT " + selectField + sql;
            }
            if (page <= 0) {
                page = 1; // page最小为1
            }
            log.debug("query sql:" + sql);
            Query q = session.createQuery(sql);
            if (rowsPerPage > 0) { // rowsPerPage的值是0或-1时,都返回全部结果集
                q.setFirstResult(rowsPerPage * (page - 1));
                q.setMaxResults(rowsPerPage);
            }

            result.addAll(q.list());

            // 设置分页查询的列
            if (null == countField) {
                countField = "*";
            }

            int rowsCount = result.size();
            if (rowsPerPage > 1 && rowsCount > 0) {
                // 每页记录数大于1且结果集大于0才计算分页信息,否则当前页记录数就作为总的记录数
                // TODO 解决page值过大,可能导致rowsCount为0的问题
                countSql = "select count(" + countField + ") " + countSql;
                // 计算总记录数时,消除 Order by语句，提高性能
                int oPos = countSql.toUpperCase().indexOf("ORDER BY");
                if (oPos > 0) {
                    countSql = countSql.substring(0, oPos);
                }
                rowsCount = ((Integer) session.createQuery(countSql).iterate().next()).intValue();
            }

            if (0 == rowsCount) {
                page = 0;
            }
            if (rowsPerPage < 0) {
                page = 1;
                rowsPerPage = rowsCount;
            }

            result.setCurrentPage(page);
            result.setTotalRowCount(rowsCount);
            result.calcPageCount(rowsPerPage);

        } catch (HibernateException e) {
            log.error("pageListQuery() error:" + sql, e);
            throw convertHibernateAccessException(e);
        } finally {
            this.releaseSession(session);
        }
        return result;
    }

    /**
     * 执行分页查询
     * 
     * @param selectField HQL语句中，SELECT 的内容(如果设置了此参数值,则sql参数中不可带SELCT语句部分)
     * @param sql HQL语句
     * @param page 第几页
     * @param rowsPerPage 每页记录数
     * @param totalRowCount HQL语句获得的总记录数
     * @return PageList
     */
    @SuppressWarnings("unchecked")
    protected final PageList pageListQuery(final String selectField,
            String sql, int page, int rowsPerPage, final int totalRowCount) {
        PageList result = new PageList();
        Session session = null;
        try {
            session = this.getSession();
            // 设置返回的列，进行查询
            if (null != selectField) {
                sql = "SELECT " + selectField + sql;
            }
            if (page <= 0) {
                page = 1; // page最小为1
            }

            Query q = session.createQuery(sql);
            if (rowsPerPage > 0) { // rowsPerPage的值是0或-1时,都返回全部结果集
                q.setFirstResult(rowsPerPage * (page - 1));
                q.setMaxResults(rowsPerPage);
            }

            result.addAll(q.list());

            if (0 == totalRowCount) {
                page = 0;
            }
            if (rowsPerPage < 0) {
                page = 1;
                rowsPerPage = totalRowCount;
            }

            result.setCurrentPage(page);
            result.setTotalRowCount(totalRowCount);
            result.calcPageCount(rowsPerPage);

        } catch (HibernateException e) {
            log.error("pageListQuery() error:" + sql, e);
            throw convertHibernateAccessException(e);
        } finally {
            this.releaseSession(session);
        }
        return result;
    }

    /**
     * 执行分页查询
     * 
     * @param sql HQL语句
     * @param page 第几页
     * @param rowsPerPage 每页记录数
     * @param totalRowCount HQL语句获得的总记录数
     * @return PageList
     */
    protected final PageList pageListQuery(final String sql, final int page,
            final int rowsPerPage, final int totalRowCount) {
        return pageListQuery(null, sql, page, rowsPerPage, totalRowCount);
    }

    /**
     * 执行分页查询
     * 
     * @param sql HQL语句
     * @param rowsPerPage 每页记录数
     * @param page 第几页
     * @return PageList
     * @throws HibernateException hibernate 异常
     */
    protected List<E> pageListQuery(final String sql, final int page,
            final int rowsPerPage) throws HibernateException {
        return pageListQuery(null, null, sql, page, rowsPerPage);
    }

    /**
     * 执行分页查询
     * 
     * @param countField HQL语句中，count 的内容
     * @param sql HQL语句
     * @param rowsPerPage 每页记录数
     * @param page 第几页
     * @return PageList
     * @throws HibernateException hibernate 异常
     */
    protected List pageListQuery(final String countField, final String sql,
            final int page, final int rowsPerPage) throws HibernateException {
        return pageListQuery(null, countField, sql, page, rowsPerPage);
    }

    /**
     * 计算HQL查询的返回记录数
     * 
     * @param sql 查询语句
     * @param countField count语句操作的字段
     * @return 记录数
     */
    protected int countHQL(String sql, String countField) {

        int rowsCount = 0;
        Session session = null;
        try {
            session = this.getSession();
            if (null == countField) {
                countField = "*";
            }
            sql = "select count(" + countField + ") " + sql;
            rowsCount = ((Integer) session.createQuery(sql).iterate().next())
                    .intValue();
        } catch (HibernateException e) {
            log.error("countHQL() error:" + sql, e);
            throw convertHibernateAccessException(e);
        } finally {
            this.releaseSession(session);
        }
        return rowsCount;
    }

    /**
     * 计算HQL查询的返回记录数
     * 
     * @param sql 查询语句
     * @return 记录数
     */
    protected int countHQL(String sql) {
        return countHQL(sql, null);
    }
}

3. 业务逻辑基类接口

/**
 * BaseManager.java
 *
 * Copyright 2007 easou, Inc. All Rights Reserved.
 */
package com.easou.ad.bl;

import java.util.HashMap;
import java.util.List;

/**
 * TODO 业务逻辑基类接口
 * 
 * Revision History
 * 
 * 
 */
public interface BaseManager<E> {
    /**
     * 根据主键获得实体
     * 
     * @param id 主键id
     * @return BaseEntity
     */
    E get(Long id);

    /**
     * 获得所有实体
     * 
     * @return List
     */
    List<E> getAll();

    /**
     * 保存实体
     * 
     * @param entity pojo instance
     */
    void save(E entity);

    /**
     * 根据主键删除实体
     * 
     * @param id 实体主键
     */
    void remove(Long id);

    /**
     * 分页搜索
     * @param con
     * @param page
     * @param rowsPerPage
     * @return
     */
    public List<E> search(HashMap con ,int page,int rowsPerPage);
    /**
     * 搜索
     * @param con
     * @return
     */
	public List<E> search(HashMap con);
}

4.业务逻辑实现基类

/**
 * BaseManagerImpl.java
 *
 * Copyright 2007 easou, Inc. All Rights Reserved.
 */
package com.easou.ad.bl.impl;

import java.util.HashMap;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.easou.ad.bl.BaseManager;
import com.easou.ad.dao.BaseDAO;

/**
 * 业务逻辑基类
 * 
 * Revision History
 * 
 * 
 */
public class BaseManagerImpl<E,D extends BaseDAO<E>> implements BaseManager <E> {
    protected final Log log = LogFactory.getLog(getClass().getName());

    /**
     * 数据访问接口
     */
    protected D dao;

    /**
     * @return List 所有实体
     */
    public final List<E> getAll() {
        return dao.getAllEntity();
    }

    /**
     * @param id 实体主键
     * @return 实体
     */
    public final E get(final Long id) {
    
        return dao.getEntity(id);
    }

    /**
     * @param id 实体主键
     */
    public final void remove(final Long id) {
        dao.removeEntity(id);
    }
    
    public List<E> search(HashMap con, int page, int rowsPerPage) {
		return ((D)dao).search(con, page, rowsPerPage);
	}

	public List<E> search(HashMap con) {
		return ((D)dao).search(con);
	}
    /**
     * @param entity 实体
     */
    public final void save(final E entity) {
        dao.saveEntity(entity);
    }

    /**
     * 
     * @return 获取泛形
     */
    public final D getDao() {
        return dao;
    }

    /**
     * 
     * @param dao 泛形
     */
    public final void setDao(final D dao) {
        this.dao = dao;
    }
	

}

接下来只需要实现基类,就包含了基本crud操作

分享到：

我也SHOW下JDBC底层操作工具类 | 不一样的互联网危机

2008-11-10 11:07
浏览 4247
评论(33)
论坛回复 / 浏览 (32 / 27466)
分类:企业架构
查看更多

33 楼 kaki 2009-10-09

建议吸收大家意见，打包下载吧。

32 楼 xuhbiao 2009-10-08

不错，学习了。。

31 楼 danjp 2009-10-08

LZ
单从你DAO的借口定制来说，我觉得不是太好，特别是更新方法方面，虽然你有executeHQL(String hql)，我觉得应该改为executeHQL(String hql,Map<String,Object> map),这样能尽量避免update T set a="+value+" where ..
这样的情况，update T set a=:a where...这样的实现岂不更好？
再者，其实更新的方法应该定义在BaseDAO接口中，如：
update(String hql),update(String hql,Map<String,Object> map)等。
Lz可以对BaseDAO再定义的细致一点。
还有主键的类型尽可能的用Serializable id.

30 楼 danjp 2009-10-08

jeff312 写道

mfdkydyw4 写道

EXvision 写道

逆风的香1314 写道

你的代码好像有点问题啊？太复杂了。
还有一个问题就是为什么你们总喜欢用HIBERNATE呢？莫非你是做外包的/
我个人比较喜欢用Spring做底层，抑或是直接JDBC连接。
这样好控制。

所以你这辈子都不会明白ORM。

楼主也不能这样讲的，hibernate再好，他也从jdbc过来的，我的导师以前就做个一个项目，结束测试的时候，邮件服务老是出错，最后把hibernate改成了jdbc，问题解决，最后导师给我们说了一句深刻的话，用不用hibernate要慎重，因为jdbc才是真正的老祖宗嘛

Hibernate的主要贡献我认为是在系统设计上，至少在设计和原型阶段，不会再有繁冗的jdbc代码分散我们的注意力。Hibernate本身由于过于强大，需要注意的地方太多了，调优也不是很简单，这可能为实施阶段带来意想不到的bug，不过总之，一般情况下问题并非hibernate本身不能解决，而是你还没弄明白hibernate。

顺便说一句，如果当时你导师的团队人员不足以在有限时间内把hibernate搞得很明白很深入，及时转移到jdbc挽救项目的决定还是正确的，不管怎样，成品才是硬道理。

是的，会用hibernate很简单，用好hibernate蛮难的！

29 楼 danjp 2009-10-08

derickkoo 写道

主键类型不要用Long，用Serialized吧

赞同，这样就不用考虑主键是什么类型了，我公司的项目开发中就是这样的！

28 楼 laitaogood 2009-10-08

其实在appfuse里早就有好的实现了

27 楼 jeff312 2009-09-30

mfdkydyw4 写道

EXvision 写道

逆风的香1314 写道

所以你这辈子都不会明白ORM。

26 楼 m_isunshine 2009-09-07

EXvision 写道

楼主的abstractDao封装的方法过于少了。
其实可以整合criteria，另外一般情况下用hibernate写sql的时候比较少。

建议参照SpringSide的泛型DAO。很漂亮。

公司内用的没必要面面俱到，够用就行了。

25 楼 mfdkydyw4 2009-09-07

EXvision 写道

逆风的香1314 写道

所以你这辈子都不会明白ORM。

24 楼 j1s2chen 2009-09-05

写的很不乐观

23 楼 caicop 2009-09-03

tangbo530 写道

public abstract class BaseDAOImpl<T, PK extends Serializable> extends HibernateDaoSupport implements
BaseDAO<T, PK> {

protected abstract Class<T> type();

// 保存
public void save(T instance) {
getHibernateTemplate().save(instance);
}

// 更新
public void update(T instance) {
getHibernateTemplate().update(instance);
}

// 删除
public void delete(T instance) {
getHibernateTemplate().delete(instance);
}

// 根据ID查询
@SuppressWarnings("unchecked")
public T get(PK id) {
return (T) getHibernateTemplate().get(type(), id);
}

// 查询所有
@SuppressWarnings("unchecked")
public List<T> findAll() {
return getHibernateTemplate().loadAll(type());
}

// 根据例子查询
@SuppressWarnings("unchecked")
public List<T> findByExample(T instance) {
return getHibernateTemplate().findByExample(instance);
}

// 根据HQL语句进行update操作等
public int bulkUpdate(String hql) {
return getHibernateTemplate().bulkUpdate(hql);
}

// 根据HQL语句进行update操作等
public int bulkUpdate(String hql, Object value) {
return getHibernateTemplate().bulkUpdate(hql, value);
}

// 根据HQL语句进行update操作等
public int bulkUpdate(String hql, Object[] value) {
return getHibernateTemplate().bulkUpdate(hql, value);
}

// 根据HQL语句进行查询
@SuppressWarnings("unchecked")
public List<T> find(String queryString) {
return getHibernateTemplate().find(queryString);
}

// 根据HQL语句进行查询
@SuppressWarnings("unchecked")
public List<T> find(String queryString, Object obj) {

return getHibernateTemplate().find(queryString, obj);
}

// 根据HQL语句进行查询
@SuppressWarnings("unchecked")
public List<T> find(String queryString, Object[] obj) {
return getHibernateTemplate().find(queryString, obj);
}

/**
* 使用命名查询进行查询
*
* @param queryString
*            HQL
* @param paramName
*            参数名
* @param value
*            参数值
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedParam(String queryString, String paramName, Object value) {
return this.getHibernateTemplate().findByNamedParam(queryString, paramName, value);
}

/**
* 使用命名查询进行查询多个参数
*
* @param queryString
*            HQL
* @param paramNames
*            参数名的数组
* @param values
*            参数值的数组
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedParam(String queryString, String[] paramNames, Object[] values) {
return this.getHibernateTemplate().findByNamedParam(queryString, paramNames, values);
}

/**
* 使用HIBERNATE映射文件中的定义的HQL语句进行查询
*
* @param queryName
*            文件中定义的HQL语句的名字
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedQuery(String queryName) {
return getHibernateTemplate().findByNamedQuery(queryName);
}

/**
*
* @param queryName
* @param value
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedQuery(String queryName, Object value) {
return getHibernateTemplate().findByNamedQuery(queryName, value);
}

/**
*
* @param queryName
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedQuery(String queryName, Object[] values) {
return getHibernateTemplate().findByNamedQuery(queryName, values);
}

/**
* 根据属性查询
*
* @param property
* @param value
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByProperty(String property, Object value) {
return this.getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(type()).add(Restrictions.eq(property, value)));
}

/**
* 分页查询
* 注:不能满足要求子类重写该方法
* @param t
* @param firstResult
* @param maxResult
* @return 返回分页查询的数据
*/
@SuppressWarnings("unchecked")
public List<T> findByPagination(final T t, final int firstResult, final int maxResult) {
return getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(type());
criteria.add(Example.create(t).enableLike(MatchMode.ANYWHERE));
criteria.setFirstResult(firstResult);
criteria.setMaxResults(maxResult);
return criteria.list();
}
});
}

/**
* 分页统计查询
*
* @param t
* @return 一共有多少条数据
*/
@SuppressWarnings("unchecked")
public int countByPagination(final T t) {
return (Integer) getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(type());
criteria.setProjection(Projections.rowCount());
criteria.add(Example.create(t).enableLike(MatchMode.ANYWHERE));
return criteria.uniqueResult();
}
});
}

这个比lz的更好呢！

22 楼 slieer 2009-08-22

还有分页采用displaytag 可能会更好吧。

21 楼 slieer 2009-08-22

面向接口编程，所以在方法定义中不要用HashMap 。pageListQuery， PageList 在哪里啊？

20 楼 hanjs 2008-12-26

dao是不是也应该区分数据库啊？

如何能支持多数据库呢？是定义一个接口，然后每个数据库用一个实现类来处理？

19 楼 tangbo530 2008-12-25

这是一个子类的DAO代码

public class ClassInfoDAOImpl<T,PK extends Serializable> extends BaseDAOImpl<T,PK> implements ClassInfoDAO<T,PK> {

@SuppressWarnings("unchecked")
protected Class type() {
return ClassInfo.class;
}

}

18 楼 tangbo530 2008-12-25

啥也不用说　直接贴代码

17 楼 tangbo530 2008-12-25

16 楼 xiao0556 2008-12-20

这个还算靠谱，和我们的思路大方面上一致。
上次见到一个什么通用ＤＡＯ差点吐血

15 楼 xijunhu 2008-12-19

不知道楼主的dao的实现类为什么是抽象类呢？是不是为了便于扩展？对项目本身有什么厉害关系吗？

另外我有个关于变量赋值的疑惑，感兴趣的可以看看：http://xijunhu.iteye.com/blog/297767

14 楼 derickkoo 2008-12-19

主键类型不要用Long，用Serialized吧

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论