`
lym6520
  • 浏览: 709687 次
  • 性别: Icon_minigender_1
  • 来自: 福建
社区版块
存档分类
最新评论

我的万能dao 设计源码，请大家多多指教！

DAO设计模式HibernateSQLSpring 
阅读更多
首先，先看下类图：（在这篇文章已经发过了http://lym6520.iteye.com/admin/blogs/421504）
我补充了Query层来存放hql或sql，如下：


现在我们来看下IBaseDao.java文件： 

package lym.dao.base.hibernate;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

import lym.dao.obj.AbstractHandleObj;

import org.hibernate.type.Type;

/**
 * 基础Dao接口,定义通用的操作
 * @author 林元脉
 * @version v1.1 2009/07/17
 *
 */
public interface IBaseDao {

	/**
	 * 对于返回列表的方法，通过调用我来实现返回记录数的控制，
	 * 设置返回记录数，若top为0不设置
	 */
	public void setMaxResults(int top);
	
	/**
	 * 保存AbstractHandleObj实体
	 * @param hobj 继承AbstractHandleObj抽象类的实体
	 * @return Serializable 主键
	 */
	public Serializable save(AbstractHandleObj hobj);
	
	/**
	 * 更新AbstractHandleObj实体
	 * @param hobj 继承AbstractHandleObj抽象类的实体  
	 */
	public void update(AbstractHandleObj hobj);
	
	/**
	 * 保存或更新AbstractHandleObj实体
	 * @param hobj 继承AbstractHandleObj抽象类的实体
	 */
	public void saveOrUpdate(AbstractHandleObj hobj);
	
	/**
	 * 保存或跟新实体集合Collection<AbstractHandleObj>
	 * 若实体已经存（根据主键判断）在则更新实体，则保存实体
	 * @param hobjList 继承AbstractHandleObj抽象类的实体集合
	 */
	public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList);
	
	/**
	 * 删除AbstractHandleObj实体
	 * @param hobj 继承AbstractHandleObj抽象类的实体
	 */
	public void delete(AbstractHandleObj hobj);
	
	/**
	 * 删除Collection<AbstractHandleObj>集合实体
	 * @param hobjList 继承AbstractHandleObj抽象类的实体集合
	 */
	public void deleteAll(Collection<AbstractHandleObj> hobjList);
	
	/**
	 * 根据主键值获得继承AbstractHandleObj的实体
	 * @param entityName 继承AbstractHandleObj抽象类的实体名称(注：包含包名)
	 * @param id 实体主键
	 * @return AbstractHandleObj
	 */
	public AbstractHandleObj findByID(String entityName, String id);
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
	 * @param hql HQL查询语句
	 * @return List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql);
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql) ;
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql, Object[] objs);
	
	/**
	 * 根据hql语句查找某些列，返回List<String[]>类型,支持分页
	 * @param hql HQL查询语句
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuerySupportPaging(String hql, int start, int reCount);
	
	/**
	 * 根据hql语句查找某些列，返回List<String[]>类型,支持分页
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @param types  查询参数类型数组，按顺序对应objs中的参数类型
	 * 			注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuerySupportPaging(String hql, Object[] objs,
			Type[] types, int start, int reCount);
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T
	 * @param hql HQL查询语句
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql) ;
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T where ...
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql, Object obj) ;
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T where ...
	 * @param hql
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql) ;
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @param obj 查询参数，匹配站位符?
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql, Object obj);
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页
	 * @param hql HQL查询语句
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return  List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, 
			int start, int reCount); 
	
	/**
	 * 根据hql语句查找AbstractHandleObj，返回List<AbstractHandleObj>类型,支持分页
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @param types  查询参数类型数组，按顺序对应objs中的参数类型
	 * 			注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<AbstractHandleObj>
	 */
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(String hql, Object[] objs,
			Type[] types, int start, int reCount) ;
	
	/**
	 * 支持SQL查询，根据sql语句查找某些列，返回List<String[]>类型
	 * @param sql SQL查询语句
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsBySqlQuery(String sql) ;
	
	/**
	 * 支持SQL查询，根据sql语句查找某列，返回List<Object>类型
	 * @param sql SQL查询语句
	 * @return List<Object>
	 */
	public List<Object> findColBySqlQuery(String sql) ;
	
	/**
	 * 支持SQL操作，执行sql语句update/delete/存储过程
	 * @param sql SQL语句
	 * @return int
	 */
	public int executeSqlQuery(String sql) ;
	
}


看下实现类BaseDaoImpl.java： 
package lym.dao.base.hibernate;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import lym.dao.obj.AbstractHandleObj;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.type.Type;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;



/**
 * 基础Dao接口,实现通用操作
 * @author 林元脉
 * @version v1.1 2009/07/17
 *
 */
public class BaseDaoImpl extends HibernateDaoSupport implements IBaseDao {
	
	
	/**
	 * 对于返回列表的方法，通过调用我来实现返回记录数的控制，
	 * 设置返回记录数，若top为0不设置
	 */
	public void setMaxResults(int top){	
		if(top > 0){
			getHibernateTemplate().setMaxResults(top);
		}		
	}
	
	public Serializable save(AbstractHandleObj hobj){
		return getHibernateTemplate().save(hobj);		
	}

	public void update(AbstractHandleObj hobj) {
		getHibernateTemplate().update(hobj);		
	
	}
	
	public void saveOrUpdate(AbstractHandleObj hobj) {
		getHibernateTemplate().saveOrUpdate(hobj);
		
	}
		
	public void saveOrUpdateAll(Collection<AbstractHandleObj> hobjList) {
		getHibernateTemplate().saveOrUpdateAll(hobjList);				
	}
	
	public void delete(AbstractHandleObj hobj) {
		getHibernateTemplate().delete(hobj);			
	}
	
	public void deleteAll(Collection<AbstractHandleObj> hobjList) {
		getHibernateTemplate().deleteAll(hobjList);		
	}
	
	public AbstractHandleObj findByID(String entityName, String id)
		{
		return (AbstractHandleObj) getHibernateTemplate().get(entityName, id);			
	}
	
	@SuppressWarnings("unchecked")	
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql) 
		{	
		List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
		resultList = getHibernateTemplate().find(hql);
		return resultList;
	}

	@SuppressWarnings("unchecked")	
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object obj) 
		{		
		List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
		resultList = getHibernateTemplate().find(hql, obj);
		return resultList;			
	}

	@SuppressWarnings("unchecked")	
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuery(String hql, Object[] objs) 
		{		
		List<AbstractHandleObj> resultList = new ArrayList<AbstractHandleObj>();
		resultList = getHibernateTemplate().find(hql, objs);
		return resultList;		
	}	
	
	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuery(String hql) 
		{		
		List<Object[]> resultList = getHibernateTemplate().find(hql);
		return resultList;		
	}

	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuery(String hql, Object obj) 
		{		
		List<Object[]> resultList = getHibernateTemplate().find(hql, obj);
		return resultList;
	}

	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuery(String hql, Object[] objs)
		{		
		List<Object[]> resultList = getHibernateTemplate().find(hql, objs);
		return resultList;		
	}
	
	@SuppressWarnings("unchecked")	
	public List<Object> findColByHqlQuery(String hql) 
		{		
		List<Object> resultList = getHibernateTemplate().find(hql);
		return resultList;
	}

	@SuppressWarnings("unchecked")	
	public List<Object> findColByHqlQuery(String hql, Object obj) 
		{		
		List<Object> resultList = getHibernateTemplate().find(hql, obj);
		return resultList;		
	}

	@SuppressWarnings("unchecked")	
	public List<Object> findColByHqlQuery(String hql, Object[] objs) 
		{		
		List<Object> resultList = getHibernateTemplate().find(hql, objs);
		return resultList;		
	}
	
	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,final int start, 
			final int reCount) {
		List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session.createQuery(hql);
				query.setFirstResult(start);
				query.setMaxResults(reCount);
				
				return query.list();
			}				
		});
		return resultList;		
	}
	
	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsByHqlQuerySupportPaging(final String hql,
			final Object[] objs, final Type[] types, final int start, final int reCount) 
			{
		List<Object[]> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
				public Object doInHibernate(Session session)
						throws HibernateException, SQLException {
					Query query = session.createQuery(hql);
					/*设置参数*/
					query.setParameters(objs, types);
					query.setFirstResult(start);
					query.setMaxResults(reCount);
					
					return query.list();
				}				
			});
			return resultList;		
	}
	
	public long getRecordCountByHqlQuery(String hql) {
		long recordCount = (Long) getHibernateTemplate().find(hql).get(0);
		return recordCount;		
	}
	
	public long getRecordCountByHqlQuery(String hql, Object obj) {
		long recordCount = (Long) getHibernateTemplate().find(hql, obj).get(0);
		return recordCount;		
	}
	
	public long getRecordCountByHqlQuery(String hql, Object[] objs) {
		long recordCount = (Long) getHibernateTemplate().find(hql, objs).get(0);
		return recordCount;		
	}
	
	public int executeHqlQuery(String hql) {
		return getHibernateTemplate().bulkUpdate(hql);			
	}
	
	public int executeHqlQuery(String hql, Object obj) {
		return getHibernateTemplate().bulkUpdate(hql, obj);
	}

	public int executeHqlQuery(String hql, Object[] objs) {
		return getHibernateTemplate().bulkUpdate(hql, objs);			
	}

	@SuppressWarnings("unchecked")
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql,
			final int start, final int reCount) {
		List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
				public Object doInHibernate(Session session)
						throws HibernateException, SQLException {
					Query query = session.createQuery(hql);
					query.setFirstResult(start);
					query.setMaxResults(reCount);
					
					return query.list();
				}				
			});
			return resultList;		
	}

	@SuppressWarnings("unchecked")
	public List<AbstractHandleObj> findAbstractHandleObjByHqlQuerySupportPaging(final String hql, final Object[] objs,
			final Type[] types, final int start, final int reCount) {
		List<AbstractHandleObj> resultList = getHibernateTemplate().executeFind(new HibernateCallback(){
				public Object doInHibernate(Session session)
						throws HibernateException, SQLException {
					Query query = session.createQuery(hql);
					/*设置参数*/
					query.setParameters(objs, types);
					query.setFirstResult(start);
					query.setMaxResults(reCount);
					
					return query.list();
				}				
			});
			return resultList;	
	}

	@SuppressWarnings("unchecked")	
	public List<Object[]> findColsBySqlQuery(final String sql) {		
		List<Object[]> resultList = new ArrayList<Object[]>();			
		Session session = getHibernateTemplate().getSessionFactory().openSession();
		resultList = session.createSQLQuery(sql).list();
		session.close();
		return resultList;		
	}

	@SuppressWarnings("unchecked")	
	public List<Object> findColBySqlQuery(String sql) {		
		List<Object> resultList = new ArrayList<Object>();			
		Session session = getHibernateTemplate().getSessionFactory().openSession();
		resultList = session.createSQLQuery(sql).list();
		session.close();
		return resultList;		
	}
	
	public int executeSqlQuery(final String sql) {		
		int result = 0;
		Session session = getHibernateTemplate().getSessionFactory().openSession();
		result = session.createSQLQuery(sql).executeUpdate();
		session.close();
		return result;		
	}
}


现在我来说说抽象类AbstractHandleObj.java的作用，先看下代码，其实也就一个抽象类，空类！ 
package lym.dao.obj;

/**
 * 抽象类，为了实现通用基础Dao而定义的，
 * 让实体来继承(需要返回的对象也继承他)
 * @author 林元脉
 * @version v1.0 2009/07/05
 *
 */
public abstract class AbstractHandleObj {

}

建立这个抽象类的目的，其实就是让实体继承，或者返回对象继承他，这样就可以通过dao对实体进行操作，这也是使用这个dao对实体进行操作的前提条件！当然，如果不继承的话你也可以

因为我们项目使用的是spring+hibernate开发的，所以配置的话： 
   <bean id="baseDao" class="lym.dao.base.hibernate.BaseDaoImpl">
   		<!--注入sessionFactory-->
 		<property name="sessionFactory" ref="sessionFactory"></property>
   </bean>

我想目前存在的缺点是对命名参数的支持，大家给补上吧！
  • 大小: 20.3 KB
分享到：
| 该贴已删除
评论
35 楼 lym6520 2010-04-02  
鲜血的记忆 写道
楼主对万能dao的理解有点问题，以至于把分页都放在dao接口中了，所以才会导致hql散落在各处，如果BasicDao接口使用反射和泛型一般他的BasicDaoImpl就能够满足大部分的需求（都说反射影响性能，没有亲自测试，但是ssh都很频繁的使用了反射技术），hql放在BasicDaoImpl的继承类中（比如ItemDaoImpl），传入的只是参数列表和实体列表。通过反射确定实体和返回类型的类型。而像分页这种事情通常都单独的设计成service接口或实现类让ItemDaoImpl继承或实现，这样可以定制分页等实现，什么时候想分页了只要继承一下就好了，很灵活。楼主这种设计颗粒度太大，冗余和不可复用其实是与楼主的目的背道而驰了。

你说的没错，可以把AbstractGenericDao（已经修改成这个名称了）进行拆分，但是这里用到的是继承，只能单一继承。
34 楼 鲜血的记忆 2010-04-02  
楼主对万能dao的理解有点问题，以至于把分页都放在dao接口中了，所以才会导致hql散落在各处，如果BasicDao接口使用反射和泛型一般他的BasicDaoImpl就能够满足大部分的需求（都说反射影响性能，没有亲自测试，但是ssh都很频繁的使用了反射技术），hql放在BasicDaoImpl的继承类中（比如ItemDaoImpl），传入的只是参数列表和实体列表。通过反射确定实体和返回类型的类型。而像分页这种事情通常都单独的设计成service接口或实现类让ItemDaoImpl继承或实现，这样可以定制分页等实现，什么时候想分页了只要继承一下就好了，很灵活。楼主这种设计颗粒度太大，冗余和不可复用其实是与楼主的目的背道而驰了。
33 楼 lym6520 2010-04-01  
soloker 写道
lym6520 写道
xxxccc81 写道
楼主，写的是基于Hibernate。如果要跳出Hibernate直接用Spring的JDBC可以实现DAO的对象化封装么？

这个倒是没仔细想过

这个是不是可以再优化一下，修改代码 满足开发中使用什么类型的框架，程序就自动调用相关代码......

那要看什么框架了，你可以有多种实现方式。
32 楼 soloker 2010-04-01  
lym6520 写道
xxxccc81 写道
楼主，写的是基于Hibernate。如果要跳出Hibernate直接用Spring的JDBC可以实现DAO的对象化封装么？

这个倒是没仔细想过

这个是不是可以再优化一下，修改代码 满足开发中使用什么类型的框架，程序就自动调用相关代码......
31 楼 lym6520 2010-04-01  
JavaLanguageFun 写道
LZ 的接口规定 考虑的很 全面 ，我大概看了一下 ，但是我没有仔细用 ，不知道能不能经得起需求的考验！

这个我已经在项目中实践过了，基本上是可以满足需求的。
30 楼 JavaLanguageFun 2010-03-31  
LZ 的接口规定 考虑的很 全面 ，我大概看了一下 ，但是我没有仔细用 ，不知道能不能经得起需求的考验！
29 楼 lym6520 2010-03-30  
fancyboy2050 写道
楼主用什么画的图哦？

用的是violet UML Editor，看附件吧！
28 楼 fancyboy2050 2010-03-30  
楼主用什么画的图哦？
27 楼 lym6520 2010-03-15  
sky_dream 写道
   个人认为你的万能DAO写的太繁琐了，每一个类操作都的去实现你那么多方法，不太灵活，其次最好使用泛型，最好借鉴点适配器模式的思想，你可以看看我的DAO类，不太完善，还需要修改。


谢谢你，你可以看下我重新整理的dao，现在我基本上不用写新的方法，泛型dao接口定义的方法基本能满足我的需求了，在开发效率上明显提高很多： 

package com.lym.db.dao;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.type.Type;
import org.springframework.stereotype.Repository;

/**
 * 基础Dao接口,定义通用的操作
 * @author LYM
 *
 */
@Repository
public interface IGenericDao<T, PK extends Serializable> {

	/**
	 * 对于返回列表的方法，通过调用我来实现返回记录数的控制，
	 * 设置返回记录数，若top为0不设置
	 */
	public void setMaxResults(int top);
	
	/**
	 * 获得hibernate session
	 * @return
	 */
	public Session getHibernateSession();
	
	/**
	 * 保存T实体
	 * @param entity 继承T抽象类的实体
	 * @return Serializable 主键
	 */
	public Serializable save(T entity);
	
		
	/**
	 * 更新T实体
	 * @param entity 继承T抽象类的实体  
	 */
	public void update(T entity);
	
	/**
	 * 保存或更新T实体
	 * @param entity 继承T抽象类的实体
	 */
	public void saveOrUpdate(T entity);
	
	/**
	 * 保存或跟新实体集合Collection<T>
	 * 若实体已经存（根据主键判断）在则更新实体，则保存实体
	 * @param entityList 继承T抽象类的实体集合
	 */
	public void saveOrUpdateAll(Collection<T> entityList);
	
	/**
	 * 删除T实体
	 * @param entity 继承T抽象类的实体
	 */
	public void delete(T entity);
	
	/**
	 * 删除Collection<T>集合实体
	 * @param entityList 继承T抽象类的实体集合
	 */
	public void deleteAll(Collection<T> entityList);
	
	/**
	 * 根据主键值获得继承T的实体
	 * @param id 实体主键
	 * @return T
	 */
	public T findEntityById(PK id);
	
	/**
	 * 根据hql语句查找T，返回List<T>类型
	 * @param hql HQL查询语句
	 * @return List<T>
	 */
	public List<T> findEntityByHqlQuery(String hql);
	
	/**
	 * 根据hql语句查找T，返回List<T>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<T>
	 */
	public List<T> findEntityByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找T，返回List<T>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<T>
	 */
	public List<T> findEntityByHqlQuery(String hql, Object[] objs);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object[]>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql) ;
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql, Object obj);
	
	/**
	 * 根据hql语句查找某些列，返回List<Object>类型
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return List<Object>
	 */
	public List<Object> findColByHqlQuery(String hql, Object[] objs);
	
	/**
	 * 根据hql语句查找某些列，返回List<String[]>类型,支持分页
	 * @param hql HQL查询语句
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuerySupportPaging(String hql, int start, int reCount);
	
	/**
	 * 根据hql语句查找某些列，返回List<String[]>类型,支持分页
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @param types  查询参数类型数组，按顺序对应objs中的参数类型
	 * 			注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsByHqlQuerySupportPaging(String hql, Object[] objs,
			Type[] types, int start, int reCount);
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T
	 * @param hql HQL查询语句
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql) ;
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T where ...
	 * @param hql HQL查询语句
	 * @param obj 查询参数，匹配站位符?
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql, Object obj) ;
	
	/**
	 * 根据hql语句查找，获得记录数
	 * 例如：select count(*) from T where ...
	 * @param hql
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return long
	 */
	public long getRecordCountByHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql) ;
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @param obj 查询参数，匹配站位符?
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql, Object obj);
	
	/**
	 * 执行更新update/删除delete操作
	 * @param hql
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @return int 更新数量/删除数量
	 */
	public int executeHqlQuery(String hql, Object[] objs) ;
	
	/**
	 * 根据hql语句查找T，返回List<T>类型,支持分页
	 * @param hql HQL查询语句
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return  List<T>
	 */
	public List<T> findEntityByHqlQuerySupportPaging(String hql, 
			int start, int reCount); 
	
	/**
	 * 根据hql语句查找T，返回List<T>类型,支持分页
	 * @param hql HQL查询语句
	 * @param objs 查询参数数组，按顺序匹配站位符?
	 * @param types  查询参数类型数组，按顺序对应objs中的参数类型
	 * 			注：参数必须是Hibernate类型的，比如String对应Hibernate.STRING,boolean对应Hibernate.BOOLEAN等
	 * @param start 查找记录数其实位置（从0开始）
	 * @param reCount  要返回的记录数（页显示记录数）
	 * @return List<T>
	 */
	public List<T> findEntityByHqlQuerySupportPaging(String hql, Object[] objs,
			Type[] types, int start, int reCount) ;
	
	/**
	 * 支持SQL查询，根据sql语句查找某些列，返回List<String[]>类型
	 * @param sql SQL查询语句
	 * @return List<Object[]>
	 */
	public List<Object[]> findColsBySqlQuery(String sql) ;
	
	/**
	 * 支持SQL查询，根据sql语句查找某列，返回List<Object>类型
	 * @param sql SQL查询语句
	 * @return List<Object>
	 */
	public List<Object> findColBySqlQuery(String sql) ;
	
	/**
	 * 支持SQL操作，执行sql语句update/delete/存储过程
	 * @param sql SQL语句
	 * @return int
	 */
	public int executeSqlQuery(String sql) ;
	
}
26 楼 mercyblitz 2010-03-15  
很难做到“万能”
25 楼 sky_dream 2010-03-15  
   个人认为你的万能DAO写的太繁琐了，每一个类操作都的去实现你那么多方法，不太灵活，其次最好使用泛型，最好借鉴点适配器模式的思想，你可以看看我的DAO类，不太完善，还需要修改。
24 楼 bhj626 2009-08-12  
呵呵，菜鸟路过，什么都看不懂
23 楼 lym6520 2009-08-11  
weich_1211 写道
linliangyi2007 写道
虽然想法有点“幼稚”（因为无数的人都像楼主这样设想过），但精神还是值得鼓励的。

这样做不适合复杂逻辑的应用，尤其是性能上不好处理。具体为啥，楼主可以在今后的使用中感悟吧，一言难尽！！

赞同，不知道楼主参加工作多久了，能有这样的想法。对于任何的项目或者工程，程序员应该注重的是业务，而不是DB，DB是根据业务来做的，你这种对于复杂的业务来讲，有点太过于牵强了。

刚出来工作不久，差两个月就以年了吧，很多东西还是要自己摸索的...
22 楼 lym6520 2009-08-11  
xxxccc81 写道
楼主，写的是基于Hibernate。如果要跳出Hibernate直接用Spring的JDBC可以实现DAO的对象化封装么？

这个倒是没仔细想过
21 楼 xxxccc81 2009-08-11  
楼主，写的是基于Hibernate。如果要跳出Hibernate直接用Spring的JDBC可以实现DAO的对象化封装么？
20 楼 magus 2009-07-28  
hibernate只适合业务逻辑不复杂的项目，一些逻辑复杂的项目，表格设计的也很复杂，有的做了表格的设计技巧，不是通过简单的表连接就可以实现的。还有就是存储过程实现的业务逻辑，Hibernate也不适合。
19 楼 lovit 2009-07-27  
linliangyi2007 写道
虽然想法有点“幼稚”（因为无数的人都像楼主这样设想过），但精神还是值得鼓励的。

这样做不适合复杂逻辑的应用，尤其是性能上不好处理。具体为啥，楼主可以在今后的使用中感悟吧，一言难尽！！

能举几个简单的例子吗？谢谢！！
18 楼 java_xh 2009-07-27  
有泛型DAO的，觉得那个比较通用
17 楼 satanest 2009-07-27  
用泛型吧，Object转换来转换去的让人很不爽，
使用泛型还可以得到类型检查
16 楼 nomandia 2009-07-24  
其实你可以借鉴一下appfuse里面的genericDao的写法，貌似要DAO做到万能是一件很麻烦的事情。
发表评论

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

相关推荐

    DAO设计模式及源码

    DAO设计模式是属于J2EE数据层的操作，使用DAO设计模式可以简化大量代码，增强程序的可移植性。

    DAO源码最全的

    DAO（Data Access Object）模式是软件工程中一种用于封装对数据库操作的对象设计模式。它将数据访问层与业务逻辑层分离，使得业务代码不受数据库实现细节的影响，提高了代码的可复用性和可测试性。在Java开发中，DAO...

    万能javaDAO

    下面将详细介绍这个万能DAO的设计思想、实现方式以及可能涉及到的关键技术。 1. **设计思想** - **单一职责原则**：万能DAO的核心思想是将数据库操作的功能集中在一个类或一组类中，每个DAO类负责处理一种特定的...

    基于JavaScript的Vue前端框架DAO设计源码

    该项目的核心是一个基于Vue框架的前端设计源码，它使用JavaScript进行编写。Vue框架是一种流行的前端JavaScript框架，它主要负责构建用户界面并进行数据的双向绑定。DAO（Data Access Object）设计模式在该项目中...

    基于CSS、JavaScript和HTML的DAO设计源码分享

    DAO（数据访问对象）设计模式在软件工程中被广泛应用于分离数据访问逻辑和业务逻辑，通过定义接口来访问特定类型的数据，从而降低代码间的耦合度，提高系统的可维护性和复用性。本项目聚焦于前端开发领域，结合了CSS...

    基于MyBatis-Spring的通用单表增删改查DAO设计源码

    今天要讨论的是一个针对MyBatis-Spring框架的通用单表增删改查DAO（Data Access Object）设计源码。这个方案不仅仅是一个简单的代码示例，它提供了一套完整的通用解决方案，旨在简化单表操作的复杂性，提高开发效率...

    DAO设计模式 DAO 设计模式 JAVA设计模式

    DAO（Data Access Object）设计模式是软件开发中一种常见的用于处理数据访问的模式，它将业务逻辑与数据访问逻辑分离，使得代码结构更加清晰，更易于维护和测试。在Java开发中，DAO模式广泛应用于数据库操作，为应用...

    【Java高并】Java高并发秒杀API之业务分析与DAO层源码和整理的笔记seckill是项目源码note是整理的笔记.zip

    Java高并发秒杀API之业务分析与DAO层源码和整理的笔记seckill是项目源码note是整理的笔记.zip Java高并发秒杀API之业务分析与DAO层源码和整理的笔记seckill是项目源码note是整理的笔记.zip Java高并发秒杀API之业务...

    基于Java开发的简单DAO工具设计源码

    简单DAO工具的设计源码为Java开发人员提供了一种高效、简洁的数据访问层实现方式。通过使用该工具，开发者可以不必从零开始编写重复的数据访问代码，而是能够快速构建起数据访问层，专注于业务逻辑的实现，从而加快...

    利用Java反射实现万能DAO

    利用Java的反射机制实现的万能DAO工具类，包含对应的测试代码。具体功能包括：单表查询，多表查询，模糊查询，添加，修改，删除等。利用万能DAO可以对数据库中任意表进行操作，只需一个DAO类即可完成。阅读本代码...

    基于C语言的DAO设计模式实现源码

    该项目的标签“C语言”、“DAO设计模式”、“数据库访问对象”、“源码实现”和“数据库编程”揭示了它在数据库编程方面的应用，以及它作为教学或参考材料在学习C语言和数据访问层设计方面的潜力。 该项目为一个...

    基于Java语言的Dao封装设计源码

    本项目基于Java语言，对数据访问层进行了封装设计，提供了一套完整的源码，供开发者参考和使用。 项目文件结构合理，包含多种类型的文件，为理解项目的整体结构和功能提供了便利。项目包含了7个JAR包文件，这些文件...

    Dao设计模式教程

    DAO（Data Access Object）设计模式是一种软件设计模式，它用于封装对数据库的所有访问，从而将业务逻辑和数据访问逻辑分离开来。DAO模式的核心思想是创建一个接口或抽象类，代表一个特定的数据操作，然后创建该接口...

    SpringHibernate万能DAO组件

    总的来说，这个"SpringHibernate万能DAO组件"是一个为了简化Spring和Hibernate集成而设计的工具，通过反射和动态SQL构建，提高了开发效率，降低了SSH框架组合项目的复杂性。使用该组件，开发者可以更快速地实现数据...

    基于C语言的Dao编程语言设计源码

    在这个项目中，我们可以看到C语言在编程语言设计中的应用，以及Dao编程语言的设计和实现。Dao编程语言的设计和实现主要以C语言为主要开发语言，辅以C、C++、Shell和CSS等语言。这个项目文件总计225个，其中包含126个...

    DAO设计模式辅助资料

    DAO（Data Access Object）设计模式是一种在Java编程中常见的软件设计模式，主要目的是为了将业务逻辑与数据访问操作分离，从而提高代码的可重用性和可维护性。这个压缩包文件"DAO设计模式辅助资料"显然是为了帮助...

    基于Dao和servlet的Javaweb师生健康码管理系统源码(课程设计).zip

    基于Dao和servlet的Javaweb师生健康码管理系统源码(课程设计).zip基于Dao和servlet的Javaweb师生健康码管理系统源码(课程设计).zip基于Dao和servlet的Javaweb师生健康码管理系统源码(课程设计).zip基于Dao和servlet...

    DAO设计模式（工厂+代理）

    DAO（Data Access Object）设计模式是一种在软件工程中常见的用于处理数据访问的模式，它将业务逻辑和数据访问逻辑分离，使得系统更加模块化，提高了代码的可复用性和可测试性。在这个“DAO设计模式（工厂+代理）”...

    基于Java语言的demo0929 Dao包优化设计源码分享

    在当前的软件开发领域，Java...本项目通过分享Java语言的Dao包优化设计源码，为Java开发者提供了一个实践优化案例的参考，有助于提升开发者在实际项目中对Dao层的设计和优化能力，从而构建出更高效、更健壮的Java应用。

    DAO设计模式DAO设计模式

    ### DAO设计模式详解 #### 一、概述 数据访问对象（Data Access Object，简称DAO）设计模式是一种在软件工程特别是企业级应用开发中非常常见的设计模式。它的主要目的是分离业务逻辑与数据访问逻辑，使系统架构...

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