`
zkgale
  • 浏览: 102000 次
  • 性别: Icon_minigender_1
  • 来自: 成都
文章分类
社区版块
存档分类
最新评论

这段代码能否做成通用DAO???

DAOHibernateSpringJPA框架 
阅读更多
前段时间在学习Hibernate,今天正式开始用,在用的过程中我为每个表(对象)做了一个DAO,主要用来实现增删改查,因为里面的很多的表(对象)需要写很多DAO,所以我就抽象了一个类,先前也没觉得怎么,不过到后来觉得我抽象出来的这个东西好象能通用吧... ...
现在拿出来让大家看看我这样抽象是否正确,是否对大家有点帮助...同时也希望它能完善...
自己只是简单的测了一下下 

package com.st.dao;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.st.hibernate.HibernateSessionFactory;


public abstract class abstractDAO
{
	private Object obj;
//	实现增加，删除，修改的功能
	public boolean idu(char t)
	{
		if(this.obj!=null)
		{
			Session session=HibernateSessionFactory.getSession();
			Transaction ts=session.beginTransaction();
			switch (t)
			{
			case 'i':
				insert(this.obj,session);
				break;
			case 'd':
				delete(this.obj,session);
				break;
			case 'u':
				update(this.obj,session);
				break;
			}	
			ts.commit();
			session.close();
			return true;
		}
		return false;
	}
	//查询
	public List select(char t)
	{
		Session session=HibernateSessionFactory.getSession();
		Transaction ts=session.beginTransaction();
		List list=null;
		switch (t)
		{
		case 'f':
			list=selectFactor(this.obj,session);
			break;
		case 'a':
			list=selectAll(session);
			break;
		}	
		ts.commit();
		session.close();
		return list;
	}
	//删除
	private void delete(Object obj,Session session)
	{
		session.delete(obj);
	}
	//更新
	private void update(Object obj,Session session)
	{
		session.update(obj);
	}
	//添加
	private void insert(Object obj,Session session)
	{
		session.save(obj);
	}
	//查询出所有的记录
	private List selectAll(Session session)
	{		
		Criteria criteria=session.createCriteria(this.obj.getClass());
		return criteria.list();
	}
	//查询,这个查询主要是用来进行模糊查询,或有条件的查询
	protected abstract List selectFactor(Object obj,Session session);
//	{
//		if(p!=null)
//		{
//			Products tempp=null;
////			Query qu=session.createQuery("from Products");
//			Criteria criteria=session.createCriteria(Products.class);
//			//得到一个Products的克隆版本
//			try
//			{
//				tempp=(Products) p.clone();
//			} catch (CloneNotSupportedException e)
//			{
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
//			criteria.add(Example.create(tempp));
//			if(this.products.getName()!=null && !this.products.getName().equals(""))
//				criteria.add(Restrictions.like("name", "%"+p.getName()+"%"));
//			return criteria.list();
//		}
//		else
//			return null;
//	}
	

	public Object getObj()
	{
		return obj;
	}
	public void setObj(Object obj)
	{
		this.obj = obj;
	}
	
}
分享到：
| java串口编程
评论
25 楼 slaser 2008-08-07  
其实有了hibernate,dao还有什么用？
24 楼 kjj 2008-08-06  
以前就是由于这种写法粘连性太强，为了清晰解耦才把方法清晰划分出来，你这 ....... 唉，我都不好意思说什么了，如果你才学习的话倒也情有可原.......
23 楼 CALM 2008-08-05  
魔力猫咪 写道
public boolean idu(char t)这个方法严重有问题。为什么要把增删改用这个间接实现？查询方法也一样。头一次看见这么写的。而且方法传入的那几个char也没有做静态属性，别人不知道你源代码的情况下谁知道应该往里头传什么。增删改方法如果一个请求内多次调用，每次都要提交一次，等于实际上没有事务控制。如果中间操作出错，事务原子性根本无法保证。建议你去看看Spring的HibernateSupper。

这是什么？
22 楼 liuxin0448 2008-04-17  
请问各位大侠
Constants.MAXRESULT
是那个包下的Class
在这里又起什么作用呢~！
21 楼 spiritfrog 2008-04-13  
魔力猫咪 写道
引用
至于public int executeUpdate(final String hql)这个还请你举个例子说明一下。
主要是你传入了HQL语句。HQL是Hibernate专有的语言，别的框架不支持这种语言。虽然JPA的查询语言和HQL基本差不多，但是还有可能在某些地方不一样。所以你这个方法就变成了只能Hibernate使用的专用方法。Service的使用者也就必须知道底层实现是Hibernate。造成了应用和持久化的紧耦合。
还有就是Update和Delete操作语句要小心，如果使用了Hibernate的二级缓存和查询缓存，那么Update和Delete使用的时候，必须清理缓存。你这里并没有缓存清理操作。除非你绝对不使用二级缓存，不然这么做是会出问题的。
我们封装的时候，对这些方面要考虑清楚。

public int executeUpdate(final String hql);对于这种方式，我觉得还是没问题的，不会又用hibernate又用jpa的吧;
对于这个方法对二级缓存的影响，确实需要注意。
lz的dao可以考虑用范型的，这样子类dao将明确知道对应的实体类型，返回时候也不必转型了。另外，不要将crud搞成一个方法，反倒迷惑了调用者。
再有lsk的那个通用dao确实挺全的，呵呵。

20 楼 ericxu131 2008-04-12  
应该说范型dao是最好的解决方案了吧。
hibernate官网上有的。
19 楼 smallboy2008 2008-04-12  
348105874 写道
c,,u,d等方法最好不要混在一起

这点我同意
可以防止混乱
18 楼 melin 2008-04-11  
在liferay中大部分增删改的action是相同的，通过常量来判断Constants.CMD。来判断执行什么操作，service也类似。
17 楼 flustar 2008-04-11  
这个是我写的泛型dao
看看对你是否有帮助
http://www.blogjava.net/flustar/archive/2007/12/26/ssha.html
16 楼 hysoft 2008-04-11  
DAO 不参杂业务 只管数据操作

事务啥的放在service
15 楼 terranhao 2008-04-11  
不好意思,我从来都是直接用hibernate的语句增删改
我想问的是这种DAO方法到底好在哪里,他一条语句delete
我用session一样是一个delete,这种方法哪里好了?
我真的从来没用过DAO,请大家指教
14 楼 魔力猫咪 2008-04-09  
引用
至于public int executeUpdate(final String hql)这个还请你举个例子说明一下。
主要是你传入了HQL语句。HQL是Hibernate专有的语言，别的框架不支持这种语言。虽然JPA的查询语言和HQL基本差不多，但是还有可能在某些地方不一样。所以你这个方法就变成了只能Hibernate使用的专用方法。Service的使用者也就必须知道底层实现是Hibernate。造成了应用和持久化的紧耦合。
还有就是Update和Delete操作语句要小心，如果使用了Hibernate的二级缓存和查询缓存，那么Update和Delete使用的时候，必须清理缓存。你这里并没有缓存清理操作。除非你绝对不使用二级缓存，不然这么做是会出问题的。
我们封装的时候，对这些方面要考虑清楚。封装的方法不合适，不但不能很好解藕，反而给变成带来了麻烦。
我看到过一个Hibernate封装。好像是因为怕别人不会用Hibernate，在Dao里把Hibernate全给封起来了。连Session也拿不出来。但是传入的参数都是Hibernate专有的HQL语句。你说这算什么封装。最后弄得大家都不好干。
13 楼 Joo 2008-04-09  
jolestar 写道
恩。不用范型类型转换太麻烦，用范型，基本就需要一个DAO，别的具体操作可以方在Service层里。


意思整个DAO层就一个DAO类就可以了
涉及到具体的不同类型查询操作一般写哪里？我原来的做法是每个EntityBean对应一个EntityDAO，有关她的持久层操作都在这里面，然后让他extends一个BaseDAO
12 楼 xzy_del 2008-04-09  
import java.io.Serializable;
public interface GenericDao<T,PK extends Serializable> {

PK create(T newInstance);

T read(PK id);

void update(T transientObject);

void delete(T persistentObject);
}
可以试试用泛型
11 楼 SoldierBandit 2008-04-09  
每个公司都不一样吧！像我们公司，就不用数据库的框架！呵呵
10 楼 lsk 2008-04-08  
魔力猫咪 写道

使用了Spring的Hibernate支持，怎么不用Spring的声明式事务管理？private Serializable save(Session session, Object p) 方法居然自己控制事务。但是其他方法又没有事务。到底事务控制是方应用层控制还是扔DAO里了？
还有public Serializable save2(final Object entity) throws DataAccessException 命名不科学。没人知道save2是什么意思。public int executeUpdate(final String hql)暴露了DAO实现，没有把领域层和持久化层隔离。而且这个方法会造成缓存失效，没有清理缓存的语句。


阁下果然眼明。 事务是在service层控制的.dao没有，至于哪个private Serializable save 和save2是是当初写这个dao的人加的。地层代码一般最好还是不要动。
至于public int executeUpdate(final String hql)这个还请你举个例子说明一下。
9 楼 jolestar 2008-04-08  
恩。不用范型类型转换太麻烦，用范型，基本就需要一个DAO，别的具体操作可以方在Service层里。
8 楼 star022 2008-04-08  
movingboy 写道
建议楼主搜索一下“泛型DAO”，或许会有收获

我做的项目重中，
就为公司写了一个泛型DAO，
所有表或者视图的基本操作全封装在里面了。
7 楼 魔力猫咪 2008-04-08  
lsk 写道
帖一段我们的baseDao给你看看 
public class BaseDaoHibernate extends HibernateDaoSupport implements BaseDao {

	private static Log log = LogFactory.getLog(BaseDaoHibernate.class);

	public void save(final Object obj) {
		getHibernateTemplate().save(obj);
		// save2(obj);
	}

	private Serializable save(Session session, Object p) {
		Transaction t = session.beginTransaction();
		Serializable o = session.save(p);
		t.commit();
		session.flush();
		session.close();
		return o;
	}

	public Serializable save2(final Object entity) throws DataAccessException {
		Object o = getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				return save(session, entity);
			}
		});
		return null;
	}

	public void deleteAll(final Object o) {
		String hql = "   delete from  " + o.getClass().getName() + "  ";
		executeUpdate(hql);
	}

	/**
	 * 根据查询语句，返回对象列表
	 * 
	 * @param hql
	 *            查询语句
	 * @return 符合查询语句的对象列表;最多返回 Constants.maxResults 条
	 */
	public List find(final String hql) {
		final int firstResult = 0;
		return find(hql, firstResult, Constants.MAXRESULTS);
	}

	/**
	 * 根据查询语句，返回对象列表
	 * 
	 * @param hql
	 *            查询语句
	 * @return 符合查询语句的对象列表;最多返回 Constants.maxResults 条
	 */
	public List find(final String hql, List tablesName) {
		final int firstResult = 0;
		return find(hql, firstResult, Constants.MAXRESULTS);
	}

	/**
	 * 返回指定起始位置，指定条数的对象
	 * 
	 * @param hql
	 *            查询语句
	 * @param firstResult
	 *            起始位置
	 * @param maxResults
	 *            最多纪录数
	 * @return list 结果列表
	 */
	public List find(final String hql, final int firstResult,
			final int maxResults) {
		if (log.isDebugEnabled()) {
			log.debug("hql=" + hql);
		}
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				try {
					session.connection().setReadOnly(true);
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				Query queryObject = session.createQuery(hql);
				queryObject.setReadOnly(true);
				queryObject.setFirstResult(firstResult);
				queryObject.setMaxResults(maxResults);
				return queryObject.list();
			}
		});
	}

	/**
	 * 返回指定起始位置，指定条数的对象
	 * 
	 * @param hql
	 *            查询语句
	 * @param firstResult
	 *            起始位置
	 * @param maxResults
	 *            最多纪录数
	 * @return list 结果列表
	 */
	public List findByIterate(final String hql) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				Query queryObject = session.createQuery(hql);
				queryObject.setCacheable(true);
				Iterator iter = queryObject.iterate();
				List ls = new ArrayList();
				while (iter.hasNext()) {
					ls.add(iter.next());
				}
				return ls;
			}
		});
	}

	/**
	 * 查询语句需要的条件参数。通过map传递
	 * 
	 * @param hql
	 *            查询语句
	 * @param map
	 *            参数
	 * @param firstResult
	 *            起始位置
	 * @param maxResults
	 *            最多纪录数
	 * @return list 结果列表
	 */
	public List find(final String hql, final Map map, final int firstResult,
			final int maxResults) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				Query queryObject = session.createQuery(hql);
				String[] params = queryObject.getNamedParameters();
				for (int i = 0, max = params.length; i < max; i++) {
					queryObject.setParameter(params[i], map.get(params[i]));
				}
				queryObject.setFirstResult(firstResult);
				queryObject.setMaxResults(maxResults);
				return queryObject.list();
			}
		});
	}

	/**
	 * 根据查询语句，返回对象列表
	 * 
	 * @param hql
	 *            查询语句
	 * @return 符合查询语句的对象列表;最多返回 Constants.maxResults 条
	 */
	public List find(final String hql, final Map map) {
		final int firstResult = 0;
		return find(hql, map, firstResult, Constants.MAXRESULTS);
	}

	/**
	 * 通过Hql 执行update/delete操作
	 * 
	 * @param hql
	 * @return
	 */
	public int executeUpdate(final String hql) {
		int result = 0;
		Object o = getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				int result = 0;
				Query queryObject = session.createQuery(hql);

				result = queryObject.executeUpdate();
				return result;

			}
		});
		Integer i = (Integer) o;
		result = i.intValue();
		return result;
	}

	public void deleteAllByObject(Object obj) {
		List l = null;
		String hql = "   from  " + obj.getClass().getName() + "  ";
		if (log.isDebugEnabled()) {
			log.debug("hql=" + hql);
		}
		l = find(hql);
		Iterator ait = l.iterator();
		while (ait != null && ait.hasNext()) {
			getHibernateTemplate().delete(ait.next());
		}
	}

	/**
	 * 通过 DetachedCriteria 进行查询
	 * 
	 * @param dc
	 * @return
	 */
	public List findByCriteria(final DetachedCriteria dc) {
		return (List) getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException {
				if (log.isDebugEnabled()) {
					log.debug("dc=" + dc);
				}
				Criteria criteria = dc.getExecutableCriteria(session);
				return criteria.list();
			}
		}, true);

	}

	/**
	 * 通过 DetachedCriteria 进行查询
	 * 
	 * @param dc
	 * @return
	 */
	public List findByCriteria(final DetachedCriteria dc,
			final int firstResult, final int maxResults) {
		return (List) getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				if (log.isDebugEnabled()) {
					log.debug("findByCriteria dc=" + dc);
				}
				Criteria criteria = dc.getExecutableCriteria(session);
				criteria.setFirstResult(firstResult);
				criteria.setMaxResults(maxResults);
				return criteria.list();
			}
		}, true);

	}

	public int countByCriteria(final DetachedCriteria dc) {
		Integer count = (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException {
						if (log.isDebugEnabled()) {
							log.debug("countByCriteria dc=" + dc);
						}
						Criteria criteria = dc.getExecutableCriteria(session);
						return criteria.setProjection(Projections.rowCount())
								.uniqueResult();
					}
				}, true);
		if (count != null) {
			return count.intValue();
		} else {
			return 0;
		}
	}

	/**
	 * 通过 DetachedCriteria 进行查询
	 * 
	 * @param dc
	 * @return
	 */
	public List findByCriteriaCache(final DetachedCriteria dc) {
		return (List) getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException {
				if (log.isDebugEnabled()) {
					log.debug("dc=" + dc);
				}
				Criteria criteria = dc.getExecutableCriteria(session);
				criteria.setCacheable(true);
				return criteria.list();
			}
		}, true);

	}

	/**
	 * 通过 DetachedCriteria 进行查询
	 * 
	 * @param dc
	 * @return
	 */
	public List findByCriteriaCache(final DetachedCriteria dc,
			final int firstResult, final int maxResults) {
		return (List) getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				if (log.isDebugEnabled()) {
					log.debug("dc=" + dc);
				}
				Criteria criteria = dc.getExecutableCriteria(session);
				criteria.setCacheable(true);
				criteria.setFirstResult(firstResult);
				criteria.setMaxResults(maxResults);
				return criteria.list();
			}
		}, true);

	}

	/**
	 * count search cache
	 */
	public int countByCriteriaCache(final DetachedCriteria dc) {
		Integer count = (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException {
						if (log.isDebugEnabled()) {
							log.debug("dc=" + dc);
						}
						Criteria criteria = dc.getExecutableCriteria(session);
						criteria.setCacheable(true);
						return criteria.setProjection(Projections.rowCount())
								.uniqueResult();
					}
				}, true);
		if (count != null) {
			return count.intValue();
		} else {
			return 0;
		}
	}

	public int executeUpdate(final String hql, final Map pMap) {
		int result = 0;
		Object o = getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				int result = 0;
				Query queryObject = session.createQuery(hql);
				String[] params = queryObject.getNamedParameters();
				for (int i = 0, max = params.length; i < max; i++) {
					queryObject.setParameter(params[i], pMap.get(params[i]));
				}
				result = queryObject.executeUpdate();
				return result;

			}
		});
		Integer i = (Integer) o;
		result = i.intValue();
		return result;
	}

	public void delete(Object obj) {
		getHibernateTemplate().delete(obj);
	}

	public Object load(Class aclass, Serializable id)
			throws DataAccessException {
		Object obj = getHibernateTemplate().load(aclass, id);
		return obj;
	}

	public Object get(Class aclass, Serializable id) {
		Object obj = getHibernateTemplate().get(aclass, id);
		return obj;
	}

	public void saveorUpdate(Object obj) {
		getHibernateTemplate().saveOrUpdate(obj);
		getHibernateTemplate().flush();
	}

	public void update(Object o) {
		getHibernateTemplate().update(o);
	}

	/**
	 * count hql 方法 .
	 */
	public int count(String hql, List ls) {
		String countQueryString = " select count (*) " + hql;
		List countlist = getHibernateTemplate().find(countQueryString);
		Long count = (Long) countlist.get(0);
		return count.intValue();
	}

	/**
	 * count hql 方法 .
	 */
	public int count(String hql, Map params) {
		String countQueryString = " select count (*) " + hql;
		List countlist = find(countQueryString, params);
		Object co = countlist.get(0);
		if (co instanceof Integer) {
			Integer count = (Integer) countlist.get(0);
			return count.intValue();
		} else {
			Long count = (Long) countlist.get(0);
			return count.intValue();
		}
	}

	/**
	 * TODO count hql 方法 .
	 */
	public int countCache(String hql, Map params) {
		String countQueryString = " select count (*) " + hql;
		List countlist = findCache(countQueryString, params);
		Object co = countlist.get(0);
		if (co instanceof Integer) {
			Integer count = (Integer) countlist.get(0);
			return count.intValue();
		} else {
			Long count = (Long) countlist.get(0);
			return count.intValue();
		}
	}

	/**
	 * 根据查询语句，返回对象列表 TODO
	 * 
	 * @param hql
	 *            查询语句
	 * @return 符合查询语句的对象列表;最多返回 Constants.maxResults 条
	 */
	public List findCache(final String hql, final Map map) {
		final int firstResult = 0;
		return findCache(hql, map, firstResult, Constants.MAXRESULTS);
	}

	/**
	 * 查询语句需要的条件参数。通过map传递 TODO
	 * 
	 * @param hql
	 *            查询语句
	 * @param map
	 *            参数
	 * @param firstResult
	 *            起始位置
	 * @param maxResults
	 *            最多纪录数
	 * @return list 结果列表
	 */
	public List findCache(final String hql, final Map map,
			final int firstResult, final int maxResults) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				Query queryObject = session.createQuery(hql);
				// 设置 查询cache
				queryObject.setCacheable(true);
				String[] params = queryObject.getNamedParameters();
				for (int i = 0, max = params.length; i < max; i++) {
					queryObject.setParameter(params[i], map.get(params[i]));
				}
				queryObject.setFirstResult(firstResult);
				queryObject.setMaxResults(maxResults);
				return queryObject.list();
			}
		});
	}

	public int count(String hql) {
		String countQueryString = " select count (*) " + hql;
		List countlist = find(countQueryString);
		Object co = countlist.get(0);
		if (co instanceof Integer) {
			Integer count = (Integer) countlist.get(0);
			return count.intValue();
		} else {
			Long count = (Long) countlist.get(0);
			return count.intValue();
		}
	}

	@Override
	public HibernateTemplate getTemplate() {
		return getHibernateTemplate();
	}

使用了Spring的Hibernate支持，怎么不用Spring的声明式事务管理？private Serializable save(Session session, Object p) 方法居然自己控制事务。但是其他方法又没有事务。到底事务控制是方应用层控制还是扔DAO里了？
还有public Serializable save2(final Object entity) throws DataAccessException 命名不科学。没人知道save2是什么意思。public int executeUpdate(final String hql)暴露了DAO实现，没有把领域层和持久化层隔离。而且这个方法会造成缓存失效，没有清理缓存的语句。
6 楼 lsk 2008-04-08  
帖一段我们的baseDao给你看看 
public class BaseDaoHibernate extends HibernateDaoSupport implements BaseDao {

	private static Log log = LogFactory.getLog(BaseDaoHibernate.class);

	public void save(final Object obj) {
		getHibernateTemplate().save(obj);
		// save2(obj);
	}

	private Serializable save(Session session, Object p) {
		Transaction t = session.beginTransaction();
		Serializable o = session.save(p);
		t.commit();
		session.flush();
		session.close();
		return o;
	}

	public Serializable save2(final Object entity) throws DataAccessException {
		Object o = getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				return save(session, entity);
			}
		});
		return null;
	}

	public void deleteAll(final Object o) {
		String hql = "   delete from  " + o.getClass().getName() + "  ";
		executeUpdate(hql);
	}

	/**
	 * 根据查询语句，返回对象列表
	 * 
	 * @param hql
	 *            查询语句
	 * @return 符合查询语句的对象列表;最多返回 Constants.maxResults 条
	 */
	public List find(final String hql) {
		final int firstResult = 0;
		return find(hql, firstResult, Constants.MAXRESULTS);
	}

	/**
	 * 根据查询语句，返回对象列表
	 * 
	 * @param hql
	 *            查询语句
	 * @return 符合查询语句的对象列表;最多返回 Constants.maxResults 条
	 */
	public List find(final String hql, List tablesName) {
		final int firstResult = 0;
		return find(hql, firstResult, Constants.MAXRESULTS);
	}

	/**
	 * 返回指定起始位置，指定条数的对象
	 * 
	 * @param hql
	 *            查询语句
	 * @param firstResult
	 *            起始位置
	 * @param maxResults
	 *            最多纪录数
	 * @return list 结果列表
	 */
	public List find(final String hql, final int firstResult,
			final int maxResults) {
		if (log.isDebugEnabled()) {
			log.debug("hql=" + hql);
		}
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				try {
					session.connection().setReadOnly(true);
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				Query queryObject = session.createQuery(hql);
				queryObject.setReadOnly(true);
				queryObject.setFirstResult(firstResult);
				queryObject.setMaxResults(maxResults);
				return queryObject.list();
			}
		});
	}

	/**
	 * 返回指定起始位置，指定条数的对象
	 * 
	 * @param hql
	 *            查询语句
	 * @param firstResult
	 *            起始位置
	 * @param maxResults
	 *            最多纪录数
	 * @return list 结果列表
	 */
	public List findByIterate(final String hql) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				Query queryObject = session.createQuery(hql);
				queryObject.setCacheable(true);
				Iterator iter = queryObject.iterate();
				List ls = new ArrayList();
				while (iter.hasNext()) {
					ls.add(iter.next());
				}
				return ls;
			}
		});
	}

	/**
	 * 查询语句需要的条件参数。通过map传递
	 * 
	 * @param hql
	 *            查询语句
	 * @param map
	 *            参数
	 * @param firstResult
	 *            起始位置
	 * @param maxResults
	 *            最多纪录数
	 * @return list 结果列表
	 */
	public List find(final String hql, final Map map, final int firstResult,
			final int maxResults) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				Query queryObject = session.createQuery(hql);
				String[] params = queryObject.getNamedParameters();
				for (int i = 0, max = params.length; i < max; i++) {
					queryObject.setParameter(params[i], map.get(params[i]));
				}
				queryObject.setFirstResult(firstResult);
				queryObject.setMaxResults(maxResults);
				return queryObject.list();
			}
		});
	}

	/**
	 * 根据查询语句，返回对象列表
	 * 
	 * @param hql
	 *            查询语句
	 * @return 符合查询语句的对象列表;最多返回 Constants.maxResults 条
	 */
	public List find(final String hql, final Map map) {
		final int firstResult = 0;
		return find(hql, map, firstResult, Constants.MAXRESULTS);
	}

	/**
	 * 通过Hql 执行update/delete操作
	 * 
	 * @param hql
	 * @return
	 */
	public int executeUpdate(final String hql) {
		int result = 0;
		Object o = getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				int result = 0;
				Query queryObject = session.createQuery(hql);

				result = queryObject.executeUpdate();
				return result;

			}
		});
		Integer i = (Integer) o;
		result = i.intValue();
		return result;
	}

	public void deleteAllByObject(Object obj) {
		List l = null;
		String hql = "   from  " + obj.getClass().getName() + "  ";
		if (log.isDebugEnabled()) {
			log.debug("hql=" + hql);
		}
		l = find(hql);
		Iterator ait = l.iterator();
		while (ait != null && ait.hasNext()) {
			getHibernateTemplate().delete(ait.next());
		}
	}

	/**
	 * 通过 DetachedCriteria 进行查询
	 * 
	 * @param dc
	 * @return
	 */
	public List findByCriteria(final DetachedCriteria dc) {
		return (List) getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException {
				if (log.isDebugEnabled()) {
					log.debug("dc=" + dc);
				}
				Criteria criteria = dc.getExecutableCriteria(session);
				return criteria.list();
			}
		}, true);

	}

	/**
	 * 通过 DetachedCriteria 进行查询
	 * 
	 * @param dc
	 * @return
	 */
	public List findByCriteria(final DetachedCriteria dc,
			final int firstResult, final int maxResults) {
		return (List) getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				if (log.isDebugEnabled()) {
					log.debug("findByCriteria dc=" + dc);
				}
				Criteria criteria = dc.getExecutableCriteria(session);
				criteria.setFirstResult(firstResult);
				criteria.setMaxResults(maxResults);
				return criteria.list();
			}
		}, true);

	}

	public int countByCriteria(final DetachedCriteria dc) {
		Integer count = (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException {
						if (log.isDebugEnabled()) {
							log.debug("countByCriteria dc=" + dc);
						}
						Criteria criteria = dc.getExecutableCriteria(session);
						return criteria.setProjection(Projections.rowCount())
								.uniqueResult();
					}
				}, true);
		if (count != null) {
			return count.intValue();
		} else {
			return 0;
		}
	}

	/**
	 * 通过 DetachedCriteria 进行查询
	 * 
	 * @param dc
	 * @return
	 */
	public List findByCriteriaCache(final DetachedCriteria dc) {
		return (List) getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException {
				if (log.isDebugEnabled()) {
					log.debug("dc=" + dc);
				}
				Criteria criteria = dc.getExecutableCriteria(session);
				criteria.setCacheable(true);
				return criteria.list();
			}
		}, true);

	}

	/**
	 * 通过 DetachedCriteria 进行查询
	 * 
	 * @param dc
	 * @return
	 */
	public List findByCriteriaCache(final DetachedCriteria dc,
			final int firstResult, final int maxResults) {
		return (List) getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				if (log.isDebugEnabled()) {
					log.debug("dc=" + dc);
				}
				Criteria criteria = dc.getExecutableCriteria(session);
				criteria.setCacheable(true);
				criteria.setFirstResult(firstResult);
				criteria.setMaxResults(maxResults);
				return criteria.list();
			}
		}, true);

	}

	/**
	 * count search cache
	 */
	public int countByCriteriaCache(final DetachedCriteria dc) {
		Integer count = (Integer) getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException {
						if (log.isDebugEnabled()) {
							log.debug("dc=" + dc);
						}
						Criteria criteria = dc.getExecutableCriteria(session);
						criteria.setCacheable(true);
						return criteria.setProjection(Projections.rowCount())
								.uniqueResult();
					}
				}, true);
		if (count != null) {
			return count.intValue();
		} else {
			return 0;
		}
	}

	public int executeUpdate(final String hql, final Map pMap) {
		int result = 0;
		Object o = getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				int result = 0;
				Query queryObject = session.createQuery(hql);
				String[] params = queryObject.getNamedParameters();
				for (int i = 0, max = params.length; i < max; i++) {
					queryObject.setParameter(params[i], pMap.get(params[i]));
				}
				result = queryObject.executeUpdate();
				return result;

			}
		});
		Integer i = (Integer) o;
		result = i.intValue();
		return result;
	}

	public void delete(Object obj) {
		getHibernateTemplate().delete(obj);
	}

	public Object load(Class aclass, Serializable id)
			throws DataAccessException {
		Object obj = getHibernateTemplate().load(aclass, id);
		return obj;
	}

	public Object get(Class aclass, Serializable id) {
		Object obj = getHibernateTemplate().get(aclass, id);
		return obj;
	}

	public void saveorUpdate(Object obj) {
		getHibernateTemplate().saveOrUpdate(obj);
		getHibernateTemplate().flush();
	}

	public void update(Object o) {
		getHibernateTemplate().update(o);
	}

	/**
	 * count hql 方法 .
	 */
	public int count(String hql, List ls) {
		String countQueryString = " select count (*) " + hql;
		List countlist = getHibernateTemplate().find(countQueryString);
		Long count = (Long) countlist.get(0);
		return count.intValue();
	}

	/**
	 * count hql 方法 .
	 */
	public int count(String hql, Map params) {
		String countQueryString = " select count (*) " + hql;
		List countlist = find(countQueryString, params);
		Object co = countlist.get(0);
		if (co instanceof Integer) {
			Integer count = (Integer) countlist.get(0);
			return count.intValue();
		} else {
			Long count = (Long) countlist.get(0);
			return count.intValue();
		}
	}

	/**
	 * TODO count hql 方法 .
	 */
	public int countCache(String hql, Map params) {
		String countQueryString = " select count (*) " + hql;
		List countlist = findCache(countQueryString, params);
		Object co = countlist.get(0);
		if (co instanceof Integer) {
			Integer count = (Integer) countlist.get(0);
			return count.intValue();
		} else {
			Long count = (Long) countlist.get(0);
			return count.intValue();
		}
	}

	/**
	 * 根据查询语句，返回对象列表 TODO
	 * 
	 * @param hql
	 *            查询语句
	 * @return 符合查询语句的对象列表;最多返回 Constants.maxResults 条
	 */
	public List findCache(final String hql, final Map map) {
		final int firstResult = 0;
		return findCache(hql, map, firstResult, Constants.MAXRESULTS);
	}

	/**
	 * 查询语句需要的条件参数。通过map传递 TODO
	 * 
	 * @param hql
	 *            查询语句
	 * @param map
	 *            参数
	 * @param firstResult
	 *            起始位置
	 * @param maxResults
	 *            最多纪录数
	 * @return list 结果列表
	 */
	public List findCache(final String hql, final Map map,
			final int firstResult, final int maxResults) {
		return getHibernateTemplate().executeFind(new HibernateCallback() {
			public Object doInHibernate(final Session session)
					throws HibernateException {
				Query queryObject = session.createQuery(hql);
				// 设置 查询cache
				queryObject.setCacheable(true);
				String[] params = queryObject.getNamedParameters();
				for (int i = 0, max = params.length; i < max; i++) {
					queryObject.setParameter(params[i], map.get(params[i]));
				}
				queryObject.setFirstResult(firstResult);
				queryObject.setMaxResults(maxResults);
				return queryObject.list();
			}
		});
	}

	public int count(String hql) {
		String countQueryString = " select count (*) " + hql;
		List countlist = find(countQueryString);
		Object co = countlist.get(0);
		if (co instanceof Integer) {
			Integer count = (Integer) countlist.get(0);
			return count.intValue();
		} else {
			Long count = (Long) countlist.get(0);
			return count.intValue();
		}
	}

	@Override
	public HibernateTemplate getTemplate() {
		return getHibernateTemplate();
	}
发表评论

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

相关推荐

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

    泛型通用DAO是这种模式的一种优化，它利用了Java 5.0引入的泛型和反射机制，大大简化了DAO层的编码工作，提高了代码的可复用性和可维护性。 泛型是Java中的一种类型系统扩展，它允许在编译时声明参数化的类型，从而...

    java 基于泛型与反射的通用 DAO

    通过这种方式，我们可以创建一个通用的DAO类，不指定具体的实体类，但在子类中指定时，编译器会进行类型检查，避免了类型转换的麻烦。 接着，我们讨论“反射”。反射是Java提供的一个强大的工具，允许程序在运行时...

    java ssh通用DAO另类实现示例

    总结：这个另类的Java SSH通用DAO实现利用了动态代理和Hibernate的特性，降低了代码复杂度，提高了代码复用性。它使得DAO层的维护变得更加简单，同时保持了良好的封装性和扩展性。在实际项目中，这样的设计可以显著...

    hibernate4 通用dao,service

    标签中的“源码”意味着这个资源可能包含了可以下载和学习的代码，而“工具”可能指这个通用DAO和Service可以作为开发工具来辅助项目开发。 由于没有具体的文件列表，我们无法详细讨论每个文件的内容，但根据标题和...

    Hibernate通用Dao设计。

    本篇文章将深入探讨Hibernate的通用Dao设计，帮助开发者理解如何利用Hibernate提高代码复用性和可维护性。 在传统的Java应用程序中，DAO（Data Access Object）层是用于封装数据库访问逻辑的地方，它隔离了业务逻辑...

    Java源代码一个简单的通用DAO实现（基于hibernate）

    Java源代码 一个简单的通用DAO实现 （基于hibernate）面向应用层按POJO类缓存hibernate的session对象.使用举例： DAO dao = DAOFactory.getDAO(POJO.class);//获得一个全局类单例的DAO实例 dao.save(pojo); 你也可以...

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

    在C#编程中，"通用Dao层"是一个常见的设计模式，用于封装数据库操作，使得业务逻辑层能够专注于处理业务规则，而无需关心底层数据访问的细节。本篇将重点探讨如何利用C#的特性（Attribute）标签来实现这一目标，同时...

    Hibernate_通用DAO模式，一个写好的dao层

    总的来说，这个资源为开发者提供了一个高效的工具，通过使用Hibernate和通用DAO模式，可以快速构建数据访问层，同时保持代码的整洁和可维护性。在开发Java Web应用程序时，正确理解和运用这种模式，能大大提高开发...

    JDBCTemplate+JavaPOJO实现通用DAO

    在这个"JDBCTemplate+JavaPOJO实现通用DAO"的项目中，我们将探讨如何利用这两者构建一个通用的DAO层。 首先，Java POJO（Plain Old Java Object）是指那些没有特殊约束的简单Java对象，通常用于表示数据库中的实体...

    高仿JPA自定义通用DAO

    自定义通用DAO实现基本的CRUD，比如： public interface BaseDao&lt;T&gt; { int insert(T obj) throws Exception; int update(T obj) throws Exception; int deleteByPrimaryKey(Object key) throws Exception; int ...

    Hibernate 原生通用DAO

    使用这类通用DAO的优点在于减少了代码冗余，提高了代码复用性，使得开发人员可以更专注于业务逻辑，而不是数据库操作。但同时，由于是通用化设计，可能无法满足所有特定业务场景的需求，需要在实际使用时进行适当的...

    ssm（Spring-springMVC-Mybatis）通用Dao框架

    SSM（Spring-SpringMVC-Mybatis）通用Dao框架是一个常见的Java Web开发架构，它整合了Spring、SpringMVC和Mybatis三个强大的开源框架，为开发者提供了便捷的数据访问和业务逻辑处理能力。这个框架的使用可以显著提高...

    Hibernate的通用dao

    通用DAO则是这一模式的扩展，提供了一套适用于多种数据实体的通用接口和实现，减少代码重复，提高代码复用性。 **三、Hibernate通用DAO实现** 1. **接口定义**：首先，定义一个通用的DAO接口，如`BaseDao&lt;T&gt;`，...

    通用DAO

    本文将深入探讨Java语言中如何使用反射机制实现通用DAO，并通过提供的"通用DAO源码及示例"来阐述这一概念。 首先，我们需要理解什么是DAO模式。DAO模式是一种软件设计模式，它的主要目标是为应用程序提供一个抽象层...

    Hibernate通用Dao

    通用dao,简单全面,所有dao都可以继承这个dao.

    JdbcTemplate通用泛型Dao实现

    本文将深入探讨`JdbcTemplate`通用泛型Dao实现的相关知识点，帮助开发者更好地理解和应用这一技术。 首先，让我们了解什么是`JdbcTemplate`。它是Spring框架的一部分，用于处理SQL操作。`JdbcTemplate`提供了一组...

    SSH中通用dao类

    在这个场景中，"SSH中通用DAO类"指的是在SSH框架下设计和实现的可以应用于多种业务场景的数据访问对象（Data Access Object）类。 DAO层是三层架构或MVC架构中的一个重要部分，主要负责与数据库进行交互，将业务...

    通用数据库访问模块，通用DAO类

    通用数据库访问模块（通常称为 DAO，Data Access Object）是一种软件设计模式，用于在应用程序和数据库之间提供一个抽象层。DAO 类的主要目标是隔离业务逻辑层与数据存储层，使得应用程序可以独立于特定的数据库实现...

    mybatis 通用DAO 简单实现

    总的来说，MyBatis的通用DAO简化了数据库操作，但并不能完全替代特定业务的DAO实现。对于复杂的业务逻辑和查询，仍然需要自定义DAO来满足需求。在开发过程中，结合通用DAO和特定DAO的使用，可以达到高效且灵活的持久...

    Java通用连接DAO

    Java通用连接DAO有JDBC连接和JNDI 两种，含源代码。

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