Hibernate封装通用数据操作基类DAO

相信大家,在项目中都曾自己或者组员一起封装过通用数据库操作基类.然后其他持久层类继承这个类.下面就贴出来我以前项目中用到的一个类吧,CommDao.多多指教. 下面提供下载.

 

package com.kechuang.xlw.commdao;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Expression;
import org.hibernate.criterion.Order;
import org.hibernate.type.DateType;
import org.hibernate.type.FloatType;
import org.hibernate.type.IntegerType;
import org.hibernate.type.StringType;
import org.hibernate.type.Type;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
 * 通用的操作类 dao
 * 
 * @author 谢晋
 * 
 */
public class CommDao<T> extends HibernateDaoSupport {
	// logger日志对象
	protected Logger log = Logger.getLogger(this.getClass());

	public CommDao() {

	}

	/**
	 * 添加一个对象
	 */
	public T addObject(T obj) {
		this.getHibernateTemplate().save(obj);
		return obj;
	}

	/**
	 * 删除一个对象
	 */
	public T deleteObject(T obj) {
		this.getHibernateTemplate().delete(obj);
		return obj;
	}

	/**
	 * 更新一个对象
	 */
	public T updateObject(T obj) {
		this.getHibernateTemplate().update(obj);
		return obj;
	}

	/**
	 * 排序+分页功能+条件查询
	 * 
	 * @param <E>
	 * @param cl
	 * @param map
	 *            条件参数
	 * @param orderstr
	 *            排序字段 如果为null不排序
	 * @param beginpos
	 *            分页起点 如果为null不分页
	 * @param count
	 *            每页的记录总数 如果为null不分页
	 * @return 返回List集合
	 */
	public <E> List<E> getOrderObjects(final Class cl, final Map map,
			final String orderstr, final Integer beginpos, final Integer count) {
		List<E> list = this.getHibernateTemplate().executeFind(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Criteria cri = session.createCriteria(cl);
						if (map != null) {
							Set keyset = map.keySet();
							for (Object key : keyset) {
								if (key == null || map.get(key) == null) {
									continue;
								}
								// 如果对应的值是字符串类型，我就是用like匹配
								if (map.get(key).getClass() == String.class) {
									cri.add(Expression.like(key.toString(), map
											.get(key)));
								} else {
									cri.add(Expression.eq(key.toString(), map
											.get(key)));
								}
							}
						}
						if (orderstr != null) {
							cri.addOrder(Order.desc(orderstr));
						}
						if (beginpos != null) {
							cri.setFirstResult(beginpos);
						} else {
							cri.setFirstResult(0);
						}
						if (count != null) {
							cri.setMaxResults(count);
						}
						return (List<E>) cri.list();
					}
				});
		return list;
	}

	/**
	 * 分页查询 ，传一个hql语句. 和一个参数数组.
	 * 
	 * @param hql
	 *            hql语句
	 * @param bindValue
	 *            数组参数
	 * @param first
	 *            分页起点
	 * @param count
	 *            每页的记录总数
	 * @return 返回List集合
	 */
	public List pageQuery(final String hql, final Object[] bindValue,
			final Integer first, final Integer count) {
		List list = this.getHibernateTemplate().executeFind(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Query query = session.createQuery(hql);

						if (bindValue != null && bindValue.length >= 1) {
							Type[] types = typesFactory(bindValue);
							query.setParameters(bindValue, types);
						}
						if (first != null && first.intValue() >= 0) {
							query.setFirstResult(first);
							if (count != null && count.intValue() >= 0)
								query.setMaxResults(count);
						}
						List result = query.list();
						return result;
					}
				});
		return list;
	}

	/**
	 * 获取对象对应参数的类型
	 * 
	 * @param bindValue
	 * @return
	 */
	private final Type[] typesFactory(Object[] bindValue) {
		int count = bindValue.length;
		Type[] types = new Type[count];
		for (int i = 0; i < count; i++) {
			if (bindValue[i].getClass().getName().endsWith("String")) {
				types[i] = new StringType();
			} else if (bindValue[i].getClass().getName().endsWith("Integer")) {
				types[i] = new IntegerType();
			} else if (bindValue[i].getClass().getName().endsWith("Float")) {
				types[i] = new FloatType();
			} else if (bindValue[i].getClass().getName().endsWith("Date")) {
				types[i] = new DateType();
			}
		}
		return types;
	}

	/**
	 * 查询某个类的全部对象
	 * 
	 * @param <E>
	 * @param c
	 *            查询类的class
	 * @return
	 */
	public <E> List<E> selectAllObject(final Class c) {
		List<E> list = this.getHibernateTemplate().executeFind(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Criteria cri = session.createCriteria(c);
						List<E> list = cri.list();
						return list;
					}
				});
		return list;
	}

	/**
	 * 根据 主键 查询某个对象
	 * 
	 * @param <E>
	 * @param c
	 * @param id
	 * @return
	 */
	public <E> E selectObjectById(final Class c, final Serializable id) {
		E e = (E) this.getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				E aa = (E) session.get(c, id);
				return aa;
			}
		});
		return e;
	}

	/**
	 * 根据条件,查询一个对象.
	 * 
	 * @param <E>
	 * @param c
	 * @param map
	 *            map放条件查询参数 调用的时候?: String username="xiejin" ;
	 *            map.put("username",username);
	 * @return
	 */
	public <E> E selectUniqueObject(final Class c, final Map map) {
		E e = (E) this.getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Criteria cri = session.createCriteria(c);
				cri.add(Expression.allEq(map));
				return (E) cri.uniqueResult();
			}
		});
		return e;
	}

	/**
	 * 带条件的查询.返回list集合
	 * 
	 * @param <E>
	 * @param c
	 * @param map
	 *            根据map里面放置的参数
	 * @return 返回一个list对象集合
	 */
	public <E> List<E> seletcObjectByMap(final Class c, final Map map) {
		List<E> list = this.getHibernateTemplate().executeFind(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Criteria cri = session.createCriteria(c);
						cri.add(Expression.allEq(map));
						List<E> e = cri.list();
						return e;
					}
				});
		return list;
	}

	/**
	 * 一个泛型方法:支持条件查询,排序,分页查询.
	 * 
	 * @param <E>
	 *            类别
	 * @param cl
	 *            需要查询的类
	 * @param map
	 *            map中put("uname","谢晋"); null or map
	 *            模糊查询用("uname","%"+uname+"%")
	 * @param orderStr
	 *            是否需要排序(升序) null or "属性字段"
	 * @param beginIndex
	 *            分页开始位置 null or Integer
	 * @param count
	 *            记录条数 null or Integer
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public <E> List<E> selectObjInfoByMapCondtionAndOrderAndPageQuery(
			final Class cl, final Map map, final String orderStr,
			final Integer beginIndex, final Integer count) {
		List e = this.getHibernateTemplate().executeFind(
				new HibernateCallback() {
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						// 使用 Criteria查询 代替复杂得hql语句;
						Criteria cri = session.createCriteria(cl);
						// 对map进行判断
						if (map != null) {
							Set keyset = map.keySet();
							for (Object key : keyset) {
								// 如果为空则继续遍历
								if (key == null || map.get(key) == null) {
									continue;
								}
								// 如果是参数值是字符串则用模糊查询. like 匹配
								if (map.get(key).getClass() == String.class) {
									cri.add(Expression.like(key.toString(), map
											.get(key)));
								} else {
									cri.add(Expression.eq(key.toString(), map
											.get(key)));
								}
							}
						}
						// 对orderStr 进行判断
						if (orderStr != null) {
							cri.addOrder(Order.asc(orderStr));// 升序
						}
						// 对分页 进行判断
						if (beginIndex != null && beginIndex.intValue() >= 0) {
							cri.setFirstResult(beginIndex.intValue());
							if (count != null && count.intValue() >= 0) {
								cri.setMaxResults(count.intValue());
							}
						}
						return (List<E>) cri.list();
					}
				});
		return e;
	}
}

 

 

 

 

方法太少了···你这种遇见多对多 的时候··泛型就挺郁闷的了··

感觉还行.我多对多的时候,也处理的蛮好的.

你都说了基类，还加类泛型做什么，必须书写其他dao 继承，不便于扩展和使用，方法泛型还是必要的