很nice的泛型dao父类

1.接口



package net.shopxx.dao;

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

import net.shopxx.bean.Pager;

import org.hibernate.criterion.DetachedCriteria;

/**
 * Dao接口 - Dao基接口
 * ============================================================================
 * 版权所有 2008-2010 长沙鼎诚软件有限公司，并保留所有权利。
 * ----------------------------------------------------------------------------
 * 提示：在未取得SHOP++商业授权之前，您不能将本软件应用于商业用途，否则SHOP++将保留追究的权力。
 * ----------------------------------------------------------------------------
 * 官方网站：http://www.shopxx.net
 * ----------------------------------------------------------------------------
 * KEY: SHOPXX0FF87D88DFDA50E4762E39A4625B158C
 * ============================================================================
 */

public interface BaseDao<T, PK extends Serializable> {

 /**
 * 根据ID获取实体对象.
 * 
 * @param id
 * 记录ID
 * @return 实体对象
 */
 public T get(PK id);

 /**
 * 根据ID获取实体对象.
 * 
 * @param id
 * 记录ID
 * @return 实体对象
 */
 public T load(PK id);

 /**
 * 根据ID数组获取实体对象集合.
 * 
 * @param ids
 * ID对象数组
 * 
 * @return 实体对象集合
 */
 public List<T> get(PK[] ids);

 /**
 * 根据属性名和属性值获取实体对象.
 * 
 * @param propertyName
 * 属性名称
 * @param value
 * 属性值
 * @return 实体对象
 */
 public T get(String propertyName, Object value);

 /**
 * 根据属性名和属性值获取实体对象集合.
 * 
 * @param propertyName
 * 属性名称
 * @param value
 * 属性值
 * @return 实体对象集合
 */
 public List<T> getList(String propertyName, Object value);

 /**
 * 获取所有实体对象集合.
 * 
 * @return 实体对象集合
 */
 public List<T> getAll();

 /**
 * 获取所有实体对象总数.
 * 
 * @return 实体对象总数
 */
 public Long getTotalCount();

 /**
 * 根据属性名、修改前后属性值判断在数据库中是否唯一(若新修改的值与原来值相等则直接返回true).
 * 
 * @param propertyName
 * 属性名称
 * @param oldValue
 * 修改前的属性值
 * @param oldValue
 * 修改后的属性值
 * @return boolean
 */
 public boolean isUnique(String propertyName, Object oldValue, Object newValue);

 /**
 * 根据属性名判断数据是否已存在.
 * 
 * @param propertyName
 * 属性名称
 * @param value
 * 值
 * @return boolean
 */
 public boolean isExist(String propertyName, Object value);

 /**
 * 保存实体对象.
 * 
 * @param entity
 * 对象
 * @return ID
 */
 public PK save(T entity);

 /**
 * 更新实体对象.
 * 
 * @param entity
 * 对象
 */
 public void update(T entity);

 /**
 * 删除实体对象.
 * 
 * @param entity
 * 对象
 * @return
 */
 public void delete(T entity);

 /**
 * 根据ID删除实体对象.
 * 
 * @param id
 * 记录ID
 */
 public void delete(PK id);

 /**
 * 根据ID数组删除实体对象.
 * 
 * @param ids
 * ID数组
 */
 public void delete(PK[] ids);

 /**
 * 刷新session.
 * 
 */
 public void flush();

 /**
 * 清除Session.
 * 
 */
 public void clear();

 /**
 * 清除某一对象.
 * 
 * @param object
 * 需要清除的对象
 */
 public void evict(Object object);

 /**
 * 根据Pager对象进行查询(提供分页、查找、排序功能).
 * 
 * @param pager
 * Pager对象
 * @return Pager对象
 */
 public Pager findByPager(Pager pager);

 /**
 * 根据Pager和DetachedCriteria对象进行查询(提供分页、查找、排序功能).
 * 
 * @param pager
 * Pager对象
 * @return Pager对象
 */
 public Pager findByPager(Pager pager, DetachedCriteria detachedCriteria);

}

 

 2，实现：

package net.shopxx.dao.impl;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import javax.annotation.Resource;

import net.shopxx.bean.Pager;
import net.shopxx.bean.Pager.OrderType;
import net.shopxx.dao.BaseDao;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import org.springframework.util.Assert;

/**
 * Dao实现类 - Dao实现类基类
 * ============================================================================
 * 版权所有 2008-2010 长沙鼎诚软件有限公司，并保留所有权利。
 * ----------------------------------------------------------------------------
 * 提示：在未取得SHOP++商业授权之前，您不能将本软件应用于商业用途，否则SHOP++将保留追究的权力。
 * ----------------------------------------------------------------------------
 * 官方网站：http://www.shopxx.net
 * ----------------------------------------------------------------------------
 * KEY: SHOPXXCED32589174C8D5905B5D0A02A2F33DF
 * ============================================================================
 */

@Repository
public class BaseDaoImpl<T, PK extends Serializable> implements BaseDao<T, PK> {

	private Class<T> entityClass;
	protected SessionFactory sessionFactory;

	@SuppressWarnings("unchecked")
	public BaseDaoImpl() {
		this.entityClass = null;
        Class c = getClass();
        Type type = c.getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
            this.entityClass = (Class<T>) parameterizedType[0];
        }
	}

	@Resource
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	protected Session getSession() {
		return sessionFactory.getCurrentSession();
	}

	@SuppressWarnings("unchecked")
	public T get(PK id) {
		Assert.notNull(id, "id is required");
		return (T) getSession().get(entityClass, id);
	}

	@SuppressWarnings("unchecked")
	public T load(PK id) {
		Assert.notNull(id, "id is required");
		return (T) getSession().load(entityClass, id);
	}

	@SuppressWarnings("unchecked")
	public List<T> get(PK[] ids) {
		Assert.notEmpty(ids, "ids must not be empty");
		String hql = "from " + entityClass.getName() + " as model where model.id in(:ids)";
		return getSession().createQuery(hql).setParameterList("ids", ids).list();
	}

	@SuppressWarnings("unchecked")
	public T get(String propertyName, Object value) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(value, "value is required");
		String hql = "from " + entityClass.getName() + " as model where model." + propertyName + " = ?";
		return (T) getSession().createQuery(hql).setParameter(0, value).uniqueResult();
	}
	
	@SuppressWarnings("unchecked")
	public List<T> getList(String propertyName, Object value) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(value, "value is required");
		String hql = "from " + entityClass.getName() + " as model where model." + propertyName + " = ?";
		return getSession().createQuery(hql).setParameter(0, value).list();
	}

	@SuppressWarnings("unchecked")
	public List<T> getAll() {
		String hql = "from " + entityClass.getName();
		return getSession().createQuery(hql).list();
	}
	
	public Long getTotalCount() {
		String hql = "select count(*) from " + entityClass.getName();
		return (Long) getSession().createQuery(hql).uniqueResult();
	}

	public boolean isUnique(String propertyName, Object oldValue, Object newValue) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(newValue, "newValue is required");
		if (newValue == oldValue || newValue.equals(oldValue)) {
			return true;
		}
		if (newValue instanceof String) {
			if (oldValue != null && StringUtils.equalsIgnoreCase((String) oldValue, (String) newValue)) {
				return true;
			}
		}
		T object = get(propertyName, newValue);
		return (object == null);
	}
	
	public boolean isExist(String propertyName, Object value) {
		Assert.hasText(propertyName, "propertyName must not be empty");
		Assert.notNull(value, "value is required");
		T object = get(propertyName, value);
		return (object != null);
	}

	@SuppressWarnings("unchecked")
	public PK save(T entity) {
		Assert.notNull(entity, "entity is required");
		return (PK) getSession().save(entity);
	}

	public void update(T entity) {
		Assert.notNull(entity, "entity is required");
		getSession().update(entity);
	}

	public void delete(T entity) {
		Assert.notNull(entity, "entity is required");
		getSession().delete(entity);
	}

	public void delete(PK id) {
		Assert.notNull(id, "id is required");
		T entity = load(id);
		getSession().delete(entity);
	}

	public void delete(PK[] ids) {
		Assert.notEmpty(ids, "ids must not be empty");
		for (PK id : ids) {
			T entity = load(id);
			getSession().delete(entity);
		}
	}

	public void flush() {
		getSession().flush();
	}

	public void clear() {
		getSession().clear();
	}

	public void evict(Object object) {
		Assert.notNull(object, "object is required");
		getSession().evict(object);
	}
	
	public Pager findByPager(Pager pager) {
		if (pager == null) {
			pager = new Pager();
		}
		DetachedCriteria detachedCriteria = DetachedCriteria.forClass(entityClass);
		return findByPager(pager, detachedCriteria);
	}

	public Pager findByPager(Pager pager, DetachedCriteria detachedCriteria) {
		if (pager == null) {
			pager = new Pager();
		}
		Integer pageNumber = pager.getPageNumber();
		Integer pageSize = pager.getPageSize();
		String property = pager.getProperty();
		String keyword = pager.getKeyword();
		String orderBy = pager.getOrderBy();
		OrderType orderType = pager.getOrderType();
		
		Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
		if (StringUtils.isNotEmpty(property) && StringUtils.isNotEmpty(keyword)) {
			String propertyString = "";
			if (property.contains(".")) {
				String propertyPrefix = StringUtils.substringBefore(property, ".");
				String propertySuffix = StringUtils.substringAfter(property, ".");
				criteria.createAlias(propertyPrefix, "model");
				propertyString = "model." + propertySuffix;
			} else {
				propertyString = property;
			}
			criteria.add(Restrictions.like(propertyString, "%" + keyword + "%"));
		}
		
		Integer totalCount = (Integer) criteria.setProjection(Projections.rowCount()).uniqueResult();
		
		criteria.setProjection(null);
		criteria.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
		criteria.setFirstResult((pageNumber - 1) * pageSize);
		criteria.setMaxResults(pageSize);
		if (StringUtils.isNotEmpty(orderBy) && orderType != null) {
			if (orderType == OrderType.asc) {
				criteria.addOrder(Order.asc(orderBy));
			} else {
				criteria.addOrder(Order.desc(orderBy));
			}
		}
		pager.setTotalCount(totalCount);
		pager.setList(criteria.list());
		return pager;
	}

}

 

3.继承

public class AdminDaoImpl extends BaseDaoImpl<Admin, int>{}