基于hibernate4的BaseDao接口

2018.9.17  由于项目备份丢失,仅存以下代码

接口类

 

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

import org.hibernate.criterion.DetachedCriteria;

import xxxxx.bean.Page;

public interface BaseDao {
	
	/**
	 * 是否存在指定条件数据。
	 * @param entityClass 映射类
	 * @param whereClause 条件
	 * @param values 条件值
	 * @return true:存在,false:不存在
	 */
	public boolean isExist(Class? entityClass,String whereClause, MapString, Object params );
	
	/**
	 * 执行update,delete,insert语句。
	 * @param hql
	 * 
	 * @return 执行影响的数量
	 */
	public int execute(final String hql, final MapString, Object params);
	
	/**
	 * 持久化
	 * @param entity
	 */
	public void save(Object entity);

	/**
	 * 更新
	 * @param entity
	 */
	public void update(Object entity);

	/**
	 * 保存或更新。
	 * @param entity
	 */
	public void saveOrUpdate(Object entity);
	
	/**
	 * 删除操作。
	 * @param entity
	 */
	public void delete(Object entity);
	
	/**
	 * 按照属性(id)条件查找数据。
	 * @param clasz 待查找的实体类
	 * @param id    根据条件id的值匹配实体类的id
	 * @return E 查找到的实体
	 */
	public E E getById(ClassE clasz, Serializable id);

	/**
	 * 查找某实体类的第一条记录。
	 * @param clasz 待查找的实体类
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz);

	/**
	 * 查找某实体类的第一条记录。
	 * @param clasz 待查找的实体类
	 * @param includes  条件参数
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String[] includes);
     
	/**
	 * 根据条件查找某实体类的第一条记录。
	 * @param clasz 待查找的实体类
	 * @param conditions 条件
	 * @return  E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions);
  
	/**
	 * 查找某实体类的第一条记录。 
	 * @param clasz 待查找的实体类
     * @param conditions    条件
     * @param includes   需要关联取出的外键对象
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, String[] includes);
     
	/**
	 * 查找某实体类的第一条记录。   
	 * @param clasz 待查找的实体类
     * @param conditions     条件
     * @param args    条件参数
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params);

	/**
	 * 查找某实体类的第一条记录。  
	 * @param clasz 待查找的实体类
     * @param conditions    条件
     * @param args    参数条件
     * @param includes   需要关联取出的外键对象
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params,
			String[] includes);
    
	/**
	 * 查找某实体类的第一条记录。 
	 * @param clasz 待查找的实体类
     * @param conditions   条件
     * @param args   参数
     * @param order  排序条件(如"id desc,code")
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params, String order);
    
	/**
	 *  查找某实体类的第一条记录。 
	 * @param clasz 待查找的实体类
     * @param conditions   条件
     * @param includes   需要关联取出的外键对象
     * @param args    参数
     * @param order  排序条件
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params,
			String order, String[] includes);
  
	/**
	 * 查找某实体类的第一条记录。 
	 * @param clasz 待查找的实体类
     * @param conditions    条件
     * @param includes    需要关联取出的外键对象
     * @param args    参数
     * @param order  排序条件(如"id desc,code")
     * @param start  分页开始条数
     * @param limit  分页每页显示条数
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params,
			String order, int start, String[] includes) ;
	/**
	 * 查找全部实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz) ;
	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 * @param includes     需要关联取出的外键对象
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String[] includes) ;
	/**
	 * 根据条件查找符合条件全部实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions    条件
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions);
	/**
	 * 根据条件查找符合条件全部实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions     条件
	 *  @param includes    需要关联取出的外键对象)
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			String[] includes) ;

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions    条件
	 *  @param args             参数
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions, MapString, Object params) ;

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions   条件
	 *  @param args            参数
	 *  @param includes     需要关联取出的外键对象
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			MapString, Object params, String[] includes);

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions   条件
	 *  @param args            参数
	 *  @param order           排序条件(如"id desc,code")
	 *  @return E                  查找到的实体
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			MapString, Object params, String order) ;

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions 条件
	 *  @param args          参数
	 *  @param order        排序条件(如"id desc,code")
	 *  @param includes    需要关联取出的外键对象)
	 *  @return E                查找到的实体
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			MapString, Object params, String order, String[] includes) ;
	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions    条件
	 *  @param args             参数
	 *  @param order            排序条件(如"id desc,code")
	 *  @param limit             分页每页显示条数
	 *  @return E                   查找到的实体
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			MapString, Object params, String order, int limit);

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions    条件
	 *  @param args             参数
	 *  @param order         排序条件 (如"id desc,code")
	 *  @param limit            分页每页显示条数
	 *  @param includes   需要关联取出的外键对象
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			MapString, Object params, String order, int limit, String[] includes);

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions  条件
	 *  @param args         参数
	 *  @param order       排序条件(如"id desc,code")
	 *  @param   start      分页开始条数
	 *  @param limit         分页每页显示条数
	 *   @param includes    需要关联取出的外键对象
	 *  @return E 查找到的实体
	 */
	public E ListE findAll(final ClassE clasz, final String conditions, final MapString, Object params, final String order, final int start, final int limit, final String[] includes);

	/**
	 * 根据条件查找第一个符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param hql  hql语句
	 *  @param args    参数
	 *  @return E 查找到的实体(List集合)
	 */
	public E E findFirstByHQL(ClassE clasz, final String hql, final MapString, Object params) ;

	/**
	 * HQL查询根据条件查找符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param hql  hql语句(必须完整写出 from Class)
	 *  @param args    hql 条件(Object数组)
	 *  @return E 查找到的实体(List集合)
	 */
	public  E ListE findByHQL(ClassE clasz, final String hql, final MapString, Object params) ;

	/**
	 * 标量
	 * HQL查询根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args   参数
	 *  @return Integer  标量值
	 */
	public Integer findInt(String hql, MapString, Object params);

	/**
	 * 标量
	 * HQL查询根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args   参数
	 *  @return Long  标量值
	 */
	public Long findLong(String hql, MapString, Object params);

	/**
	 * 标量
	 * 根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args    参数
	 *  @return Double 标量值
	 */
	public Double findDouble(String hql, MapString, Object params) ;

	/**
	 * 标量
	 * HQL查询根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args   参数
	 *  @return BigDecimal 标量值
	 */
	public BigDecimal findBigDecimal(String hql, MapString, Object params);
	/**
	 * 标量
	 * HQL查询根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args   参数
	 *  @return String 标量值
	 */
	public String findString(String hql, MapString, Object params);


	/**
	 * 分页条件查询 
	 *  @param DetachedCriteria  dc   条件
	 *  @param start    分页开始显示数
	 *  @param limit      分页每页显示条数
	 *  @return Page   分页对象
	 */
	public  E PageE findPage(final DetachedCriteria dc, final int start,
			final int limit) ;

	public T PageT findPageByHQL(ClassT clasz, final String hql, final MapString, Object params,
			final int start, final int limit) ;
	
	
	/**
	 * 根据hql语句查找实体信息
	 *  @param sql    createSQLQuery条件(hql语句)
	 *  @param args     参数
     *  @param start    分页开始显示数
	 *  @param limit      分页每页显示条数
	 *  @return  page   分页对象
	 */
	public T PageT findPageBySQL(final ClassT clasz,final String sql, final MapString, Object params,final int start, final int limit) ;
	
	/**
	 * 根据hql语句查找实体信息
	 *  @param sql    createSQLQuery条件(hql语句)
	 *  @param args    参数
	 *  @param count_sql
     *  @param start    分页开始显示数
	 *  @param limit      分页每页显示条数
	 *  @return  page  分页对象
	 */
	public T PageT findPageBySQL(final ClassT clasz,final String sql,String count_sql, final MapString, Object params,final int start, final int limit) ;
	
	/**
	 * 根据hql语句查找实体信息
	 *  @param sql    createSQLQuery条件(hql语句)
	 *  @param args    条件参数
	 *  @return List 集合
	 */
	public List? findListBySQL(final String sql,final MapString, Object params);
	
	
	/**
	 * 根据hql语句查找第一个实体信息
	 *  @param sql    createSQLQuery条件(hql语句)
	 *  @param args    条件 参数
	 *  @return Object
	 */
	public Object findFirstBySQL(final String sql, final MapString, Object params);
	
	
	/**
	 * SQL查询并将结果集自动转换成POJO的list
	 * @param clazz 最终转换成的类
	 * @param sql 查询条件
	 * @return
	 */
	public T ListT findObjListBySql(final ClassT clazz,final String sql);
	
	
	/**
	 * SQL查询并将结果集自动转换成POJO的list
	 * @param clazz 最终转换成的类
	 * @param sql 查询条件
	 * @return
	 */
	public T ListT findObjListBySql(final ClassT clazz,final String sql,final Integer start,final Integer limit);
}

 

实现类

 

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.internal.CriteriaImpl;
import org.hibernate.transform.Resu< Transformer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import xxxxx.bean.Page;
import xxxxx.dao.BaseDao;
import xxxxx.framework.constant.SystemConstant;
import xxxxx.util.CustomResu< Transformer;
import xxxxx.util.DaoHelper;
import xxxxx.util.ReflectionUtils;

@Repository
public class BaseDaoImpl implements BaseDao{
	
	@Autowired
	private SessionFactory sessionFactory;
	
	/**
	 * 获得当前事物的session
	 * 
	 * @return org.hibernate.Session
	 */
	
	public Session getCurrentSession() {
		return this.sessionFactory.getCurrentSession();
	}
	
	/**
	 * 是否存在指定条件数据。
	 * @param entityClass 映射类
	 * @param whereClause 条件
	 * @param values 条件值
	 * @return true:存在,false:不存在
	 */
	public boolean isExist(Class? entityClass,String whereClause, MapString, Object params ) {
		String selectHql = "select count(id) from "+ entityClass.getName() + "  where " + whereClause;
		return findLong(selectHql, params)  0;
	}
	
	
	/**
	 * 执行update,delete,insert语句。
	 * @param hql
	 * 
	 * @return 执行影响的数量
	 */
	public int execute(final String hql, final MapString, Object params) {		
		Query query = this.getCurrentSession().createQuery(hql);
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		return query.executeUpdate();
	}
	

	@Override
	public void delete(Object entity) {
		this.getCurrentSession().delete(entity);		
	}
	
	/**
	 * 持久化
	 * @param entity
	 */
	public void save(Object entity) {
		this.getCurrentSession().save(entity);
	}

	/**
	 * 更新
	 * @param entity
	 */
	public void update(Object entity) {
		this.getCurrentSession().update(entity);
	}

	/**
	 * 保存或更新。
	 * @param entity
	 */
	public void saveOrUpdate(Object entity) {
		this.getCurrentSession().saveOrUpdate(entity);
	}
    
	/**
	 * 按照属性(id)条件查找数据。
	 * @param clasz 待查找的实体类
	 * @param id    根据条件id的值匹配实体类的id
	 * @return E 查找到的实体
	 */
	public E E getById(ClassE clasz, Serializable id) {
		return (E) this.getCurrentSession().get(clasz, id);
	}

	/**
	 * 查找某实体类的第一条记录。
	 * @param clasz 待查找的实体类
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz) {
		return findFirst(clasz, null, null, null, 0, null);
	}

	/**
	 * 查找某实体类的第一条记录。
	 * @param clasz 待查找的实体类
	 * @param includes  条件参数
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String[] includes) {
		return findFirst(clasz, null, null, null, 0, includes);
	}
     
	/**
	 * 根据条件查找某实体类的第一条记录。
	 * @param clasz 待查找的实体类
	 * @param conditions 条件
	 * @return  E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions) {
		return findFirst(clasz, conditions, null, null, 0, null);
	}
  
	/**
	 * 查找某实体类的第一条记录。 
	 * @param clasz 待查找的实体类
     * @param conditions    条件
     * @param includes   需要关联取出的外键对象
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, String[] includes) {
		return findFirst(clasz, conditions, null, null, 0, includes);
	}
     
	/**
	 * 查找某实体类的第一条记录。   
	 * @param clasz 待查找的实体类
     * @param conditions     条件
     * @param args    条件参数
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params) {
		return findFirst(clasz, conditions, params, null, 0, null);
	}

	/**
	 * 查找某实体类的第一条记录。  
	 * @param clasz 待查找的实体类
     * @param conditions    条件
     * @param args    参数条件
     * @param includes   需要关联取出的外键对象
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params,
			String[] includes) {
		return findFirst(clasz, conditions, params, null, 0, includes);
	}
    
	/**
	 * 查找某实体类的第一条记录。 
	 * @param clasz 待查找的实体类
     * @param conditions   条件
     * @param args   参数
     * @param order  排序条件(如"id desc,code")
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params,
			String order) {
		return findFirst(clasz, conditions, params, order, 0, null);
	}
    
	/**
	 *  查找某实体类的第一条记录。 
	 * @param clasz 待查找的实体类
     * @param conditions   条件
     * @param includes   需要关联取出的外键对象
     * @param args    参数
     * @param order  排序条件
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params,
			String order, String[] includes) {
		return findFirst(clasz, conditions, params, order, 0, includes);
	}
  
	/**
	 * 查找某实体类的第一条记录。 
	 * @param clasz 待查找的实体类
     * @param conditions    条件
     * @param includes    需要关联取出的外键对象
     * @param args    参数
     * @param order  排序条件(如"id desc,code")
     * @param start  分页开始条数
     * @param limit  分页每页显示条数
	 * @return E 查找到的实体
	 */
	public E E findFirst(Class? clasz, String conditions, MapString, Object params,
			String order, int start, String[] includes) {
		ListE resu< s = (ListE) findAll(clasz, conditions, params, order, start, 1,includes);
		return resu< s.size() == 0 ? null : resu< s.get(0);
	}
    
	/**
	 * 查找全部实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz) {
		return findAll(clasz, null, null, null, 0, 0, null);
	}
   
	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 * @param includes     需要关联取出的外键对象
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String[] includes) {
		return findAll(clasz, null, null, null, 0, 0, includes);
	}
   
	/**
	 * 根据条件查找符合条件全部实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions    条件
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions) {
		return findAll(clasz, conditions, null, null, 0, 0, null);
	}
	
	/**
	 * 根据条件查找符合条件全部实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions     条件
	 *  @param includes    需要关联取出的外键对象)
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			String[] includes) {
		return findAll(clasz, conditions, null, null, 0, 0, includes);
	}

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions    条件
	 *  @param args             参数
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions, MapString, Object params) {
		return findAll(clasz, conditions, params, null, 0, 0, null);
	}

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions   条件
	 *  @param args            参数
	 *  @param includes     需要关联取出的外键对象
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			MapString, Object params, String[] includes) {
		return findAll(clasz, conditions, params, null, 0, 0, includes);
	}

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions   条件
	 *  @param args            参数
	 *  @param order           排序条件(如"id desc,code")
	 *  @return E                  查找到的实体
	 */
	public E ListE findAll(ClassE clasz, String conditions, MapString, Object params, String order) {
		return findAll(clasz, conditions, params, order, 0, 0, null);
	}

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions 条件
	 *  @param args          参数
	 *  @param order        排序条件(如"id desc,code")
	 *  @param includes    需要关联取出的外键对象)
	 *  @return E                查找到的实体
	 */
	public E ListE findAll(ClassE clasz, String conditions, MapString, Object params, String order, String[] includes) {
		return findAll(clasz, conditions, params, order, 0, 0, includes);
	}

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions    条件
	 *  @param args             参数
	 *  @param order            排序条件(如"id desc,code")
	 *  @param limit             分页每页显示条数
	 *  @return E                   查找到的实体
	 */
	public E ListE findAll(ClassE clasz, String conditions, MapString, Object params, String order, int limit) {
		return findAll(clasz, conditions, params, order, limit, 0, null);
	}

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions    条件
	 *  @param args             参数
	 *  @param order         排序条件 (如"id desc,code")
	 *  @param limit            分页每页显示条数
	 *  @param includes   需要关联取出的外键对象
	 *  @return E 查找到的实体(List集合)
	 */
	public E ListE findAll(ClassE clasz, String conditions,
			MapString, Object params, String order, int limit, String[] includes) {
		return findAll(clasz, conditions, params, order, 0, limit, includes);
	}

	/**
	 * 根据条件查找全部符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param conditions  条件
	 *  @param args         参数
	 *  @param order       排序条件(如"id desc,code")
	 *  @param   start      分页开始条数
	 *  @param limit         分页每页显示条数
	 *   @param includes    需要关联取出的外键对象
	 *  @return E 查找到的实体
	 */
	public E ListE findAll(final ClassE clasz, final String conditions, final MapString, Object params, final String order, final int start, final int limit, final String[] includes) {		
		String hql = "from " + clasz.getName() + " as e";
		if (includes != null  includes.len >h  0) {
			for (String je : includes) {
				hql += " left outer join  fetch e." + je + " as " + (je.replaceAll("\\.", "")) + " ";
			}
		}
		if (StringUtils.isNotEmpty(conditions)) {
			hql += " where (" + DaoHelper.insertAlias(conditions, clasz) + ")";
		}
		if (StringUtils.isNotEmpty(order))
			hql += " order by e." + order;
		
		Query query = this.getCurrentSession().createQuery(hql);
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		return query.setFirstResu< (start).setMaxResu< s((limit == 0 ? Integer.MAX_VALUE : limit)).list();
	}

	/**
	 * 根据条件查找第一个符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param hql  hql语句
	 *  @param args    参数
	 *  @return E 查找到的实体(List集合)
	 */
	public E E findFirstByHQL(ClassE clasz, final String hql, final MapString, Object params) {				
		Query query = this.getCurrentSession().createQuery(hql);		
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		List? list = query.setFirstResu< (0).setMaxResu< s(1).list();
		return (list != null  list.size()  0 )? (E)list.get(0) : null;
	}

	/**
	 * HQL查询根据条件查找符合条件实体类信息。  
	 * @param clasz 待查找的实体类
	 *  @param hql  hql语句(必须完整写出 from Class)
	 *  @param args    hql 条件(Object数组)
	 *  @return E 查找到的实体(List集合)
	 */
	public  E ListE findByHQL(ClassE clasz, final String hql, final MapString, Object params) {
		Query query = this.getCurrentSession().createQuery(hql);
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		return query.list();
	}

	/**
	 * 标量
	 * HQL查询根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args   参数
	 *  @return Integer  标量值
	 */
	public Integer findInt(String hql, MapString, Object params) {
		Integer intValue = findFirstByHQL(Integer.class, hql, params);
		return intValue == null ? 0 : intValue;
	}

	/**
	 * 标量
	 * HQL查询根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args   参数
	 *  @return Long  标量值
	 */
	public Long findLong(String hql, MapString, Object params) {
		Long longValue = findFirstByHQL(Long.class, hql, params);
		return longValue == null ? 0L : longValue;
	}

	/**
	 * 标量
	 * 根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args    参数
	 *  @return Double 标量值
	 */
	public Double findDouble(String hql, MapString, Object params) {
		Double doubleValue = findFirstByHQL(Double.class, hql, params);
		return doubleValue == null ? 0.00 : doubleValue;
	}

	/**
	 * 标量
	 * HQL查询根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args   参数
	 *  @return BigDecimal 标量值
	 */
	public BigDecimal findBigDecimal(String hql, MapString, Object params) {
		BigDecimal bigDecimalValue = findFirstByHQL(BigDecimal.class, hql, params);
		return bigDecimalValue == null ? new BigDecimal(0) : bigDecimalValue;
	}

	/**
	 * 标量
	 * HQL查询根据条件查找符合条件第一个标量值。  
	 *  @param hql  hql语句
	 *  @param args   参数
	 *  @return String 标量值
	 */
	public String findString(String hql, MapString, Object params) {
		String stringValue = findFirstByHQL(String.class, hql, params);
		return stringValue;
	}


	/**
	 * 分页条件查询 
	 *  @param DetachedCriteria  dc   条件
	 *  @param start    分页开始显示数
	 *  @param limit      分页每页显示条数
	 *  @return Page   分页对象
	 */
	public  E PageE findPage(final DetachedCriteria dc, final int start, final int limit) {
		
		Criteria c = dc.getExecutableCriteria(this.getCurrentSession());
		CriteriaImpl impl = (CriteriaImpl) c;
		Projection projection = impl.getProjection();
		Resu< Transformer transformer = impl.getResu< Transformer();

		
		ListCriteriaImpl.OrderEntry orderEntries = (ListCriteriaImpl.OrderEntry) ReflectionUtils.getFieldValue(impl, "orderEntries");
		ReflectionUtils.setFieldValue(impl, "orderEntries", new ArrayListCriteriaImpl.OrderEntry());
		
		
		// 执行Count查询
		c.setResu< Transformer(CriteriaImpl.DISTINCT_ROOT_ENTITY);
		long total = (Long) c.setProjection(Projections.countDistinct("id")).uniqueResu< ();
	
		// 将之前的Projection和OrderBy条件重新设回去
		c.setProjection(projection);
		c.setResu< Transformer(transformer);
		ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
		

		c.setFirstResu< (start);
		c.setMaxResu< s(limit);

		ListE list = c.list();
		return  new PageE(start, limit, Integer.parseInt(String.valueOf(total)),(list == null ? new ArrayList() : list));
	}
	
	public T PageT findPageByHQL(ClassT clasz, final String hql, final MapString, Object params, final int start, final int limit) {
		String countQueryString = "select count (*) " + DaoHelper.removeSelect(DaoHelper.removeOrders(hql));
		
		Long count = params ==null ? findLong(countQueryString, null):findLong(countQueryString, params);
		
		Query query = this.getCurrentSession().createQuery(hql);
		// 参数组装
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		List? list =  query.setFirstResu< (start).setMaxResu< s(limit).list();
		
		return new Page(start, limit,count.intValue(),list);
	}
	
	
	/**
	 * 根据hql语句查找实体信息
	 *  @param sql    createSQLQuery条件(hql语句)
	 *  @param args     参数
     *  @param start    分页开始显示数
	 *  @param limit      分页每页显示条数
	 *  @return  page   分页对象
	 */
	public T PageT findPageBySQL(final ClassT clasz,final String sql, final MapString, Object params,final int start, final int limit) {		
		Query query =  this.getCurrentSession().createSQLQuery(sql);
		// 参数组装
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		// 结果转换
		query.setResu< Transformer(new CustomResu< Transformer(clasz));
		
		List? list = query.setFirstResu< (start).setMaxResu< s(limit).list();
		
		String countQueryString = "select count (*) " + DaoHelper.removeSelect(DaoHelper.removeOrders(sql));
		Object o = findFirstBySQL(countQueryString,params);
		
		Long count = 0L;
		if(o!=nullo instanceof BigDecimal){
			count = ((BigDecimal)o).longValue();
		}else if(o!=null){
			count= Long.valueOf(String.valueOf(o));
		}
		else{
			count = 0L;
		}
		return new Page(start, limit,count.intValue(),list);
	}
	
	/**
	 * 根据hql语句查找实体信息
	 *  @param sql    createSQLQuery条件(hql语句)
	 *  @param args    参数
	 *  @param count_sql
     *  @param start    分页开始显示数
	 *  @param limit      分页每页显示条数
	 *  @return  page  分页对象
	 */
	public T PageT findPageBySQL(final ClassT clasz,final String sql,String count_sql, final MapString, Object params,final int start, final int limit) {
		Query query =  this.getCurrentSession().createSQLQuery(sql);
		// 参数组装
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		// 结果转换
		query.setResu< Transformer(new CustomResu< Transformer(clasz));
		
		ListT list = query.setFirstResu< (start).setMaxResu< s(limit).list();	
		
		Long count = (Long)findFirstBySQL(count_sql, params);		
	
		return new Page(start, limit,count.intValue(),list);
	}
	
	/**
	 * 根据hql语句查找实体信息
	 *  @param sql    createSQLQuery条件(hql语句)
	 *  @param args    条件参数
	 *  @return List 集合
	 */
	public List? findListBySQL(final String sql,final MapString, Object params) {
		Query query =  this.getCurrentSession().createSQLQuery(sql);
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		return  query.list();
	}	
	
	/**
	 * 根据hql语句查找第一个实体信息
	 *  @param sql    createSQLQuery条件(hql语句)
	 *  @param args    条件 参数
	 *  @return Object
	 */
	public Object findFirstBySQL(final String sql, final MapString, Object params) {
		 
		Query query = this.getCurrentSession().createSQLQuery(sql);
		if ((params != null)  !params.isEmpty()) {
			for (String key : params.keySet()) {
				query.setParameter(key, params.get(key));
			}
		}
		List? list =  query.setFirstResu< (0).setMaxResu< s(1).list();
		
		return (list != null  list.size()  0 ? list.get(0) : null);
	}
	
	
	/**
	 * SQL查询并将结果集自动转换成POJO的list
	 * @param clazz 最终转换成的类
	 * @param sql 查询条件
	 * @return
	 */
	public T ListT findObjListBySql(final ClassT clazz,final String sql){
		Query query = this.getCurrentSession().createSQLQuery(sql);
		query.setResu< Transformer(new CustomResu< Transformer(clazz));
		return  query.list();
	}
		
	/**
	 * SQL查询并将结果集自动转换成POJO的list
	 * @param clazz 最终转换成的类
	 * @param sql 查询条件	
	 * @return
	 */
	public T ListT findObjListBySql(final ClassT clazz,final String sql,final Integer start,final Integer limit){
		Query query =  this.getCurrentSession().createSQLQuery(sql).setFirstResu< (start==null?0:start).setMaxResu< s(limit==null?SystemConstant.DEFAULT_PAGE_SIZE:limit);
		query.setResu< Transformer(new CustomResu< Transformer(clazz));
		return query.list();
	}

 

 

 

 

 

最新回复(0)
/jishuWap5K3WK7j6N8Zp04SwqRXXx6hknFwZcGEzUBhXm_2BcE_3D4858568
8 简首页