`
hyj_dx
  • 浏览: 101539 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

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

DAOHibernateSQLJDBCSpring 
阅读更多

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

 

其中包括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操作

分享到：
| 不一样的互联网危机
评论
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 写道
你的代码好像有点问题啊？太复杂了。
还有一个问题就是为什么你们总喜欢用HIBERNATE呢？莫非你是做外包的/
我个人比较喜欢用Spring做底层，抑或是直接JDBC连接。
这样好控制。


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


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


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

顺便说一句，如果当时你导师的团队人员不足以在有限时间内把hibernate搞得很明白很深入，及时转移到jdbc挽救项目的决定还是正确的，不管怎样，成品才是硬道理。
26 楼 m_isunshine 2009-09-07  
EXvision 写道
楼主的abstractDao封装的方法过于少了。
其实可以整合criteria，另外一般情况下用hibernate写sql的时候比较少。

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


公司内用的没必要面面俱到，够用就行了。
25 楼 mfdkydyw4 2009-09-07  
EXvision 写道
逆风的香1314 写道
你的代码好像有点问题啊？太复杂了。
还有一个问题就是为什么你们总喜欢用HIBERNATE呢？莫非你是做外包的/
我个人比较喜欢用Spring做底层，抑或是直接JDBC连接。
这样好控制。


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


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

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();
}
});
}
16 楼 xiao0556 2008-12-20  
这个还算靠谱，和我们的思路大方面上一致。
上次见到一个什么通用ＤＡＯ差点吐血
15 楼 xijunhu 2008-12-19  
不知道楼主的dao的实现类为什么是抽象类呢？是不是为了便于扩展？对项目本身有什么厉害关系吗？

另外我有个关于变量赋值的疑惑，感兴趣的可以看看：http://xijunhu.iteye.com/blog/297767
14 楼 derickkoo 2008-12-19  
主键类型不要用Long，用Serialized吧
发表评论

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

相关推荐

    泛型dao

    在研究泛型DAO的源码时，我们可以学习到如何实现泛型类，以及如何在具体操作中使用反射或类型信息来处理泛型类型。例如，Hibernate的`Session`接口和`SessionFactory`类就提供了泛型版本的`get()`和`load()`方法，...

    SSH 泛型DAO分页

    - 实现泛型DAO：创建泛型接口和实现，定义基本的CRUD操作，并添加分页方法。 - 编写Service层：调用DAO接口实现业务逻辑，处理分页参数。 - 创建Struts2 Action：接收用户请求，调用Service方法，将分页数据传递给视...

    ssh通用泛型DAO

    BaseHibernateDAO是基于Hibernate框架的一个基类，它封装了常见的数据库操作，如增删查改（CRUD）。通过继承这个基类，开发者可以快速创建自定义的DAO实现，避免重复编写相似的代码。BaseHibernateDAO通常会包含以下...

    ssh整合下的通用泛型DAO+分页

    在这个特定的讨论中，我们聚焦于SSH1中的一个关键概念：通用泛型DAO（Data Access Object）以及分页功能的实现。DAO层是模型层和数据访问层之间的桥梁，它的主要职责是处理数据库操作，为业务层提供无状态的数据访问...

    Hibernate泛型DAO及使用方法

    这个接口包含了基本的CRUD（创建、读取、更新、删除）操作，以及一些高级操作如加锁、批量操作和HSQL（Hibernate SQL）查询。 1. **基本操作**： - `get(PK id)`：根据主键获取一个实体，如果不存在则返回null。 ...

    泛型通用DAO，可以很简化DAO层的代码

    在泛型DAO中，反射主要用于在运行时动态获取数据实体的属性，以便进行CRUD操作。例如，通过反射可以找到实体类的`id`字段，并根据这个字段执行SQL查询。 `MyTestDao`可能是实现泛型DAO的一个具体示例，它可能包含了...

    DAO模式设计

    - `泛型dao的实现.doc`：可能详细描述了创建泛型DAO的具体步骤，包括如何处理CRUD（Create, Read, Update, Delete）操作。 - `使用AOP实现类型安全的泛型DAO.doc`：可能阐述了如何利用Spring AOP来增强泛型DAO，确保...

    hibernate不是泛型的通用DAo1

    例如，`DynamicDao`可能是一个非泛型接口，它包含了一些基本的CRUD操作，可以直接被任何类实现，而不需要指定特定的实体类型。`DynamicDaoImpl`可能是实现了`DynamicDao`接口的具体类，它包含了与Hibernate集成的...

    基于泛型反射的数据层封装+MSSQLJDBC3.0驱动

    `MyDAO`可能是实现了上述泛型反射数据层封装的自定义DAO类，包含了具体的数据库操作逻辑。这个类可能包含了一些如`insert(T entity)`, `update(T entity)`, `deleteById(ID id)`, `selectById(ID id)`等方法，这些...

    hibenate 对DAO的封装

    然后，用户只需要为自己的实体类创建一个继承自泛型DAO模板的接口，即可获得CRUD操作。例如，对于一个名为`User`的实体类，我们可以创建一个`UserDAO`接口，如下： ```java public interface UserDAO extends ...

    Mybatis通用DAO设计封装（mybatis）

    这个接口通常会包含CRUD（Create, Read, Update, Delete）的基本方法，如`insert`, `update`, `delete`, `selectById`, `selectAll`等。这些方法可以通过Mybatis的注解或XML配置来绑定SQL语句。 2. **动态SQL**： ...

    java软件开发dao层泛型模式

    泛型DAO模式的核心在于定义一个泛型接口`GenericDao`，该接口用于封装所有基本的数据库操作。如上所述的接口定义示例中： ```java public interface GenericDao, PK extends Serializable&gt; { // 基本检索、增加、...

    基于MAVEN的SpringMVC+Mybatis整合及dao、service强封装

    另一种机制采用xml文件形式实现dao、service、controller层封装，具体业务类只需继承就可实现基本的CRUD操作，整个工程导入即可运行（一个月心算之作，稍贵一点，下载以后大部分资料都不需要看了）

    Hibernate封装dao层

    - **CRUD操作**：封装基本的Create（创建）、Read（读取）、Update（更新）、Delete（删除）方法。例如，`save()`用于保存对象，`getById()`用于根据ID获取对象，`update()`用于更新对象，`deleteById()`用于删除...

    数据库Dao封装类

    使用Dao封装类的好处在于，开发人员可以专注于业务逻辑，而不必关心底层数据库的细节，同时，由于所有数据库操作集中在Dao层，便于进行性能优化和维护。在大型项目中，这种封装方式尤为重要，因为它使得团队成员可以...

    ssh数据库基本操作封装

    在这个主题中，“ssh数据库基本操作封装”指的是将常用的数据库交互功能，如增删改查（CRUD），通过SSH框架进行封装，以便在项目中更方便地调用。这通常涉及到Spring的IoC（Inversion of Control）容器来管理数据库...

    C#特性标签实现通用Dao层

    这样，我们就无需为每个实体类编写单独的Dao，而是使用泛型Dao实例即可处理所有带有`[DatabaseEntity]`特性的类。 总结起来，通过C#的特性标签和反射技术，我们可以构建一个灵活且可扩展的通用Dao层，大大减少了...

    泛型解决方案

    这样，一个DAO实例就能处理任何符合特定接口或基类的数据实体，实现插入、更新、删除等操作。 3. CRUD操作：插入（Create）、读取（Read）、更新（Update）和删除（Delete）是数据库操作的基本功能。泛型可以帮助...

    通用DAO

    1. **创建泛型DAO接口**：定义一个泛型接口，如`GenericDAO&lt;T&gt;`，其中T代表数据库实体类型。 2. **实现DAO接口**：在实现类中，使用反射获取实体类的字段信息，构造SQL语句。 3. **执行SQL操作**：使用JDBC或其他ORM...

    自定义Dao，反射实现

    在Java开发中，数据访问对象（DAO）模式是一种常见的设计模式，用于封装对数据库的操作，以提高代码的可重用性和可维护性。本篇将深入探讨如何自定义Dao，并利用反射技术来实现这一目标。博客链接：[此处无法提供...

Magicbox
Global site tag (gtag.js) - Google Analytics