使用Hibernate的SessionFactory自封装统一的DAO实现_经过测试_可以直接参考使用

Bertha 。 2021-12-05 14:41 175阅读 0赞

使用Hibernate的SessionFactory自封装统一的DAO实现，使用泛型，减少重复代码，提升开发效率。

### 1、dao实现类：BaseDaoImpl ###

import java.io.Serializable;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    
    import javax.annotation.Resource;
    
    
    import org.hibernate.Query;
    import org.hibernate.SessionFactory;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.util.CollectionUtils;
    import com.kou.dao.BaseDao;
    import com.kou.exception.MultipleResultException;
    import com.kou.util.vo.ListVO;
    import com.kou.util.vo.PageVO;
    
    /**
     * dao基类实现
     */
    public class BaseDaoImpl<T> implements BaseDao<T> {
        private static final Logger log = LoggerFactory.getLogger(BaseDaoImpl.class);
        @Resource(name = "sessionFactory")
        private SessionFactory sf;
        private final Class<T> clazz;
    
        public BaseDaoImpl() {
    		ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
    		clazz = (Class<T>) type.getActualTypeArguments()[0];
        }
    
        public String save(T t) {
            Object object = sf.getCurrentSession().save(t);
    
            return String.valueOf(object);
        }
    
    
        public void update(T t) {
            sf.getCurrentSession().update(t);
        }
    
        @Deprecated
        public void saveOrUpdate(T t) {
            sf.getCurrentSession().saveOrUpdate(t);
        }
    
    
        public void delete(T t) {
            sf.getCurrentSession().delete(t);
        }
    
        /**
         * 修改和批处理
         */
        public void batchByHQL(String hql, Object... objects) {
            Query q = sf.getCurrentSession().createQuery(hql);
            for (int i = 0; i < objects.length; i++) {
                q.setParameter(i, objects[i]);
            }
            q.executeUpdate();
        }
    
        public void batchBySQL(String sql, Object... objects) {
            Query q = sf.getCurrentSession().createSQLQuery(sql);
            for (int i = 0; i < objects.length; i++) {
                q.setParameter(i, objects[i]);
            }
            q.executeUpdate();
        }
    
    
        public T get(Serializable id) {
            return (T) sf.getCurrentSession().get(clazz, id);
        }
    
        //load
        public T load(Serializable id) {
            return (T) sf.getCurrentSession().load(clazz, id);
        }
    
    
        public List<T> findByHQL(String hql, Object... objects) {
            Query q = sf.getCurrentSession().createQuery(hql);
            for (int i = 0; i < objects.length; i++) {
                q.setParameter(i, objects[i]);
            }
            return q.list();
        }
    
    
        public ListVO<T> findModels(PageVO pageModel,
                                    Map<String, Object> condition, Boolean isDesc, String orderBy) {
            return findModels(pageModel, condition, new Object[][]{
       {orderBy, isDesc}});
        }
    
    
        public ListVO<T> findByHQLPage(String hql, Object[] objects, PageVO pageModel) {
    
            pageModel = findCountByHQLPage(hql, objects, pageModel);
    
            Query q = findListByHQLPage(hql, objects, pageModel);
    
            return new ListVO<>(pageModel, q.list());
        }
    
        public <E> ListVO<E> findModelsByHQLPage(String hql, Object[] objects, PageVO pageModel) {
    
            pageModel = findCountByHQLPage(hql, objects, pageModel);
            Query q = findListByHQLPage(hql, objects, pageModel);
            return new ListVO<>(pageModel, q.list());
        }
    
        private Query findListByHQLPage(String hql, Object[] objects,
                                        PageVO pageModel) {
            Query q = sf.getCurrentSession().createQuery(hql);
            initPageQuery(objects, pageModel, q);
            return q;
        }
    
        private void initPageQuery(Object[] objects, PageVO pageModel, Query q) {
            q.setMaxResults(pageModel.getPageSize());
    
            q.setFirstResult((pageModel.getPageNo() <= 0 ? 0 : pageModel.getPageNo() - 1) * pageModel.getPageSize());
    
            if (objects != null && objects.length > 0) {
                for (int i = 0; i < objects.length; i++) {
                    if (objects[i] instanceof String[]) {
    
                    } else {
                        q.setParameter(i, objects[i]);
                    }
                }
            }
        }
    
        public ListVO<Object[]> findBySQLPage(String sql, Object[] objects, PageVO pageModel) {
    
            pageModel = findCountBySQLPage(sql, objects, pageModel);
    
            Query q = sf.getCurrentSession().createSQLQuery(sql);
            initPageQuery(objects, pageModel, q);
    
            return new ListVO<Object[]>(pageModel, q.list());
        }
    
        public ListVO<T> findByHQLPage(String hql, PageVO pageModel, Object... objects) {
            return findByHQLPage(hql, objects, pageModel);
        }
    
        //单值检索(查询结果有且仅有一条记录)
        public Object uniqueResult(String hql, Object... objects) {
            Query q = sf.getCurrentSession().createQuery(hql);
            for (int i = 0; i < objects.length; i++) {
                q.setParameter(i, objects[i]);
            }
            return q.uniqueResult();
        }
    
        //单值检索(查询结果有且仅有一条记录)
        public Object uniqueSQLResult(String sql, Object... objects) {
            Query q = sf.getCurrentSession().createSQLQuery(sql);
            for (int i = 0; i < objects.length; i++) {
                q.setParameter(i, objects[i]);
            }
            return q.uniqueResult();
        }
    
    
        public ListVO<T> findByHQLPage(String hql, PageVO pageModel, Map<String, Object> condition, Boolean isDesc, String orderBy) {
            return findByHQLPage(hql, pageModel, condition, new Object[]{orderBy, isDesc});
        }
    
        /**
         * 拼接查询条件
         * <p>
         * 包含 字符串、数字、日期
         *
         * @param map
         * @return
         */
        public List<Object> getCondition(Map<String, Object> map, StringBuffer whereSql) {
    
            List<Object> list = new ArrayList<Object>();
    
            if (map == null || map.size() <= 0) {
                return list;
            }
    
            whereSql.append(" where ");
    
            Iterator<Map.Entry<String, Object>> it = map.entrySet().iterator();
            while (it.hasNext()) {
    
                Map.Entry<String, Object> entry = it.next();
                String key = entry.getKey();
                Object value = entry.getValue();
    
                if (value == null) {
                    log.warn("condition value is null, removed , key: {}", key);
                    it.remove();
                    continue;
                }
                if (whereSql.length() > 7) {
                    whereSql.append(" and ");
                }
                if (key.contains("Id") || key.contains("id")) {
                    whereSql.append(key).append(" = ? ");
                    list.add(value);
                    continue;
                }
    
                if (value instanceof String) {
                    String string = ((String) value).trim();
                    if (key.startsWith("#no_")) {
                        whereSql.append(key.substring(4)).append(" = ? ");
                        list.add(value);
    
                    } else if (key.startsWith("#left_")) {
                        whereSql.append(key.substring(6)).append(" like ? ");
                        list.add("%" + value);
    
                    } else if (key.startsWith("#right_")) {
                        whereSql.append(key.substring(7)).append(" like ? ");
                        list.add(value + "%");
    
                    } else if (key.startsWith("#all_")) {
                        whereSql.append(key.substring(5)).append(" like ? ");
                        list.add("%" + value + "%");
    
                    } else if (key.startsWith("#noEqual_")) {
                        whereSql.append(key.substring(9)).append(" != ? ");
                        list.add(value);
    
                    } else if (string.contains(",")) {
                        String[] values = string.split(",");
                        whereSql.append( key);
                        whereSql.append(" in ( ");
                        for (int i = 0; i < values.length - 1; i++) {
                            whereSql.append("?, ");
                            list.add(values[i]);
                        }
                        whereSql.append("? ) ");
                        list.add(values[values.length - 1]);
                    }else {
                        if ("".equals(string)){
                            log.warn("condition value is '' , key: {} \tvalue: {} ", key, value);
                        }
    
                        whereSql.append(key).append(" = ? ");
    
                        list.add(value);
                    }
                } else if (value instanceof Number || value instanceof Date) {
                    if (key.contains("#start_")) {
                        whereSql.append(key.substring(7)).append(" >= ? ");
                    } else if (key.contains("#end_")) {
                        whereSql.append(key.substring(5)).append(" <= ? ");
                    } else {
                        whereSql.append(key).append(" = ? ");
                    }
                    list.add(value);
                } else if (value instanceof Boolean) {
                    whereSql.append(key).append(" = ? ");
                    list.add(value);
                } else {
                    log.warn(" unknown type of the condition, ignored ,key: {} \tvalue: {} ", key, value);
                }
    
            }
            if (whereSql.length() == 7){
                whereSql.setLength(0);
            }
            return list;
        }
    
    
        //	排序暂只支持单个
        public String getOrderBy(Object[]... orderBy) {
    
            if (orderBy == null || orderBy.length == 0) {
                return null;
            }
    
            StringBuilder orderSql = new StringBuilder(" order by ");
    
            for (int i = 0; i < orderBy.length - 1; i++) {
                orderSql.append(orderBy[i][0]);
    
                if (orderBy[i][1].equals(true)) {
                    orderSql.append(" desc, ");
                } else {
                    orderSql.append(" asc, ");
                }
            }
            orderSql.append(orderBy[orderBy.length - 1][0]);
    
            if (orderBy[orderBy.length - 1][1].equals(true)) {
                orderSql.append(" desc ");
            } else {
                orderSql.append(" asc ");
            }
            return orderSql.toString();
        }
    
        public PageVO findCountBySQLPage(String sql, Object[] objects, PageVO pageModel) {
            if (pageModel == null) {
                pageModel = new PageVO();
            }
    
            if (pageModel.getRecordCount() <= 0) {
    //			如果是第一次，则先查询结果总数
                String hql1 = " select count(*) from (" + sql + ") test";
                Query q = sf.getCurrentSession().createSQLQuery(hql1);
                if (objects != null && objects.length > 0) {
                    for (int i = 0; i < objects.length; i++) {
                        q.setParameter(i, objects[i]);
                    }
                }
    
                pageModel.setRecordCount(Long.valueOf(q.uniqueResult().toString()));
            }
            return pageModel;
        }
    
        public PageVO findCountByHQLPage(String hql, Object[] objects, PageVO pageModel) {
            if (pageModel == null) {
                pageModel = new PageVO();
            }
    
            if (pageModel.getRecordCount() <= 0) {
    //			如果是第一次，则先查询结果总数
                String hql1 = " select count(*) " + hql;
                Query q = sf.getCurrentSession().createQuery(hql1);
                if (objects != null && objects.length > 0) {
                    for (int i = 0; i < objects.length; i++) {
                        q.setParameter(i, objects[i]);
                    }
                }
                pageModel.setRecordCount(Long.valueOf(q.uniqueResult().toString()));
            }
            return pageModel;
        }
    
        public PageVO findCountByHQLPage(String hql, PageVO pageModel, Object... objects) {
            return findCountByHQLPage(hql, objects, pageModel);
        }
    
        public PageVO findCountByHQLPage(String hql, PageVO pageModel, Map<String, Object> condition) {
    
            StringBuffer whereSql = new StringBuffer();
            List<Object> conditions = getCondition(condition, whereSql);
            StringBuffer sql = new StringBuffer(hql);
    
            if (whereSql != null) {
                sql.append(whereSql);
            }
    
            log.debug(" hql: " + sql.toString());
    
            return findCountByHQLPage(sql.toString(), conditions.toArray(), pageModel);
        }
    
        @Override
        public PageVO findModelsCount(PageVO pageModel,
                                      Map<String, Object> condition) {
            String hql = " from " + clazz.getName();
            return findCountByHQLPage(hql, pageModel, condition);
        }
    
        public SessionFactory getSf() {
            return sf;
        }
    
        public void setSf(SessionFactory sf) {
            this.sf = sf;
        }
    
        public List<T> findModels(Map<String, Object> condition) {
            return findModels(condition, null);
        }
    
    
        public List<T> findModels(Map<String, Object> condition, Boolean isDesc, String orderBy) {
            return findModels(condition, new Object[][]{
       {orderBy, isDesc}});
        }
    
        public List<T> findModels(Object[][] condition) {
            return findModels(condition, null);
        }
    
    
        public List<T> findModels(Object[][] condition, Boolean isDesc,
                                  String orderBy) {
    
            Map<String, Object> map = new HashMap<String, Object>(condition.length);
    
            for (Object[] aCondition : condition) {
                map.put((String) aCondition[0], aCondition[1]);
            }
    
            return findModels(map, isDesc, orderBy);
        }
    
        @Override
        public T findOne(Map<String, Object> condition) {
    
            List<T> list = findModels(condition);
    
            if (list == null || list.size() == 0) {
                return null;
            }
            return list.get(0);
        }
    
        @Override
        public T findOne(Object[][] condition) {
    //		TODO 使用分页查询
            List<T> list = findModels(condition);
    
            if (list == null || list.size() == 0) {
                return null;
            }
    
    //		TODO 如果有多条，抛出异常
            return list.get(0);
        }
    
        @Override
        public <E> ListVO<E> findBySQLPage(String sql, Object[] objects,
                                           PageVO pageModel, Class<E> clazz) {
    
            ListVO<Object[]> listVO = findBySQLPage(sql, objects, pageModel);
    
            if (CollectionUtils.isEmpty(listVO.getList())) {
                return new ListVO<>(listVO.getPageVO(), new ArrayList<E>(0));
            }
    
            List<Object[]> list = listVO.getList();
    
            List<E> list2 = new ArrayList<>(0);
            try {
                list2 = findBySQL(clazz, list);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return new ListVO<>(listVO.getPageVO(), list2);
        }
    
        @SuppressWarnings("rawtypes")
        private <E> List<E> findBySQL(Class<E> clazz, List<Object[]> list) throws Exception {
    
    
            if (CollectionUtils.isEmpty(list)) {
                return new ArrayList<>(0);
            }
    
            List<E> list2 = new ArrayList<>(list.size());
    //      TODO 获取list对应的存储的对象类型  不要根据存储的对象获取类型  有可能为null 不准确
    
            Object data = null;
            for (Object objects : list) {
                if (objects != null) {
                    data = objects;
                    break;
                }
            }
    
            if (!(data instanceof Object[])) {
    
                if (clazz.isInstance(data)) {
    
                    List<E> list1 = new ArrayList<>(list.size());
                    for (Object objects : list) {
                        list1.add((E) objects);
                    }
                    return list1;
                } else {
                    log.warn("数据初始化出错，没有对应的类型");
                    throw new Exception("数据初始化出错，没有对应的类型");
                }
    
            }
    
            Object[] param = list.get(0);
    
            Constructor<E>[] constructors = (Constructor<E>[]) clazz.getConstructors();
    
            Constructor<E> constructorFind = null;
            for (Constructor<E> constructor : constructors) {
                int len = constructor.getGenericParameterTypes().length;
    
                if (len == param.length) {
    
                    boolean result = true;
    
                    for (int i = 0; i < len; i++) {
                        Type type = constructor.getGenericParameterTypes()[i];
    
                        if (param[i] == null || param[i].getClass().equals(type)) {
                            continue;
                        } else {
                            log.debug("第{}个参数，实体类型为{}，对应{}构造函数参数类型为{}", i + 1, param[i].getClass().getName(), clazz.getName(), ((Class) type).getName());
                            result = false;
                            break;
                        }
    
                    }
    
                    if (result) {
                        constructorFind = constructor;
                        break;
                    }
                }
    
            }
    
            if (constructorFind == null) {
                log.warn("数据初始化出错，没有对应的构造函数");
                throw new Exception("数据初始化出错，没有对应的构造函数");
            }
            /**
             * 存在一个问题，如果数据第一条的字段为null，没有对应的格式，则后续数据有可能报错，
             * 因此需要在报错时查看数据字段的具体类型，然后添加对应的构造函数
             */
            for (Object[] objectArray : list) {
    
                try {
                    E e1 = constructorFind.newInstance(objectArray);
                    list2.add(e1);
                } catch (Exception e) {
                    e.printStackTrace();
                }
    
            }
            return list2;
        }
    
        public void deleteById(Serializable ids) {
    
            String hql = " delete from " +
                    clazz.getName() +
                    " where id = ? ";
    
            batchByHQL(hql, ids);
        }
    
        @Override
        public <E> List<E> findBySQL(String sql, Class<E> clazz, Object... objects) {
            Query q = sf.getCurrentSession().createSQLQuery(sql);
            for (int i = 0; i < objects.length; i++) {
                q.setParameter(i, objects[i]);
            }
            try {
                return findBySQL(clazz, q.list());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        @Override
        public T findOneSQL(String sql, Object... objects) {
            List<T> list = findBySQL(sql, objects);
    
            if (list == null || list.size() == 0) {
                return null;
            }
    
            if (list.size() > 1) {
                throw new MultipleResultException("结果异常，请求期望结果为一条，实际为多个");
            }
    
            return list.get(0);
        }
    
        @Override
        public <E> E findOneSQL(String sql, Class<E> clazz, Object... objects) {
            List<E> list = findBySQL(sql, clazz, objects);
    
            if (list == null || list.size() == 0) {
                return null;
            }
    
            if (list.size() > 1) {
                throw new MultipleResultException("结果异常，请求期望结果为一条，实际为多个");
            }
    
            return list.get(0);
        }
    
        @Override
        public List<T> findBySQL(String sql, Object... objects) {
    
            Query q = sf.getCurrentSession().createSQLQuery(sql).addEntity(clazz);
            for (int i = 0; i < objects.length; i++) {
                q.setParameter(i, objects[i]);
            }
            return q.list();
        }
    
        public List<T> findModels(Map<String, Object> condition, Object[][] orderBy) {
            String hql = " from " + clazz.getName();
            StringBuffer sql = new StringBuffer(hql);
    
            StringBuffer whereSql = new StringBuffer();
            List<Object> conditions = getCondition(condition, whereSql);
    
            if (whereSql != null) {
                sql.append(whereSql);
            }
    
            String orderSql = getOrderBy(orderBy);
    
            if (orderSql != null) {
                sql.append(orderSql);
            }
    
            log.debug(" hql: " + sql.toString());
    
    
            Query q = sf.getCurrentSession().createQuery(sql.toString());
    
            if (conditions != null && conditions.size() > 0) {
                for (int i = 0; i < conditions.size(); i++) {
                    q.setParameter(i, conditions.get(i));
                }
            }
    
            if (q.list().size() == 0) {
                return null;
            }
    
            return q.list();
        }
    
        public List<T> findModels(Object[][] condition, Object[][] orderBy) {
            Map<String, Object> map = new HashMap<String, Object>(condition.length);
    
            for (Object[] aCondition : condition) {
                map.put((String) aCondition[0], aCondition[1]);
            }
    
            return findModels(map, orderBy);
        }
    
        @Override
        public ListVO<T> findByHQLPage(String hql, PageVO pageModel, Map<String, Object> condition, Object[][] orderBy) {
            StringBuffer whereSql = new StringBuffer();
            List<Object> conditions = getCondition(condition, whereSql);
            StringBuffer sql = new StringBuffer(hql);
    
            if (whereSql != null) {
                sql.append(whereSql);
            }
    
            String orderSql = getOrderBy(orderBy);
    
            if (orderSql != null) {
                sql.append(orderSql);
            }
    
            log.debug(" hql: " + sql.toString());
    
            return findByHQLPage(sql.toString(), conditions.toArray(), pageModel);
        }
    
        @Override
        public ListVO<T> findModels(PageVO pageModel, Map<String, Object> condition, Object[][] orderBy) {
            String hql = " from " + clazz.getName();
            return findByHQLPage(hql, pageModel, condition, orderBy);
        }
    
    //    public static void main(String[] args) {
    //        BaseDaoImpl baseDao = new BaseDaoImpl();
    //        Map<String, Object> map = new HashMap<>();
    		baseDao.findOne(new Object[][]{
       {"showId", ""}});
    //        StringBuffer whereSql = new StringBuffer();
    //        map.put("companyCode", "2");
    //        map.put("xxx", "2");
    //        map.put("ddffgg", 2);
    //        map.put("fg", true);
    		map.put("#no_channelCode","11111");
    //
    //        List<Object> list = baseDao.getCondition(map, whereSql);
    //
    //        System.out.print(list);
    //    }
    }

### `2、dao接口:BaseDao` ###

import java.io.Serializable;
    import java.util.List;
    import java.util.Map;
    
    import com.kou.util.vo.ListVO;
    import com.kou.util.vo.PageVO;
    
    /**
     * dao接口
     * 
     * 查询多条用find
     * 查询单条用get
     * 
     * HQL查询时，最好加上包名
     * 
     */
    public interface BaseDao<T> {
    	//写操作
    	public String save(T t);
    	
    	public void update(T t);
    	
    	@Deprecated
    	public void saveOrUpdate(T t);
    	
    	public void delete(T t);
    	
    	public void deleteById(Serializable ids);
    	
    	public T get(Serializable id);
    	
    	@Deprecated
    	public T load(Serializable id);
    	
    	/**
    	 * 按照hql批处理实体,可执行更新和删除
    	 * 
    	 * 批量操作，如果使用缓存，不建议使用，如果使用 需要手动清除对应缓存
    	 * 
    	 * @param hql
    	 * @param objects
    	 */
    	public void batchByHQL(String hql,Object...objects);
    	
    	/**
    	 * 按照sql批处理实体,可执行更新和删除
    	 * 
    	 * 批量操作，如果使用缓存，不建议使用，如果使用 需要手动清除对应缓存
    	 * 
    	 * @param sql
    	 * @param objects
    	 */
    	public void batchBySQL(String Sql,Object...objects);
    	/**
    	 * HQL查询集合
    	 * @param hql
    	 * @param objects
    	 * @return
    	 */
    	public List<T> findByHQL(String hql,Object...objects);
    	/**
    	 * SQL查询集合
    	 * @param hql
    	 * @param objects
    	 * @return
    	 */
    	public <E> List<E> findBySQL(String sql,Class<E> clazz, Object...objects);
    	
    	/**
    	 * SQL查询集合
    	 * @param hql
    	 * @param objects
    	 * @return
    	 */
    	public List<T> findBySQL(String sql, Object...objects);
    
    	/**
    	 * HQL条件查询（一条结果）
    	 * 
    	 * @param condition
    	 * @return
    	 */
    	public T findOne(Map<String, Object> condition);
    	/**
    	 * HQL条件查询（一条结果）
    	 * 
    	 * @param condition
    	 * @return
    	 */
    	public T findOne(Object[][] condition);
    	/**
    	 * SQL条件查询
    	 * 
    	 * @param condition
    	 * @return
    	 */
    	public List<T> findModels(Map<String, Object> condition);
    	/**
    	 * SQL条件查询
    	 * 
    	 * @param condition
    	 * @return
    	 */
    	public List<T> findModels(Object[][] condition);
    	/**
    	 * SQL条件查询、排序
    	 * 
    	 * @param condition
    	 * @param isDesc
    	 * @param orderBy
    	 * @return
    	 */
    	public List<T> findModels(Map<String, Object> condition, Boolean isDesc, String orderBy);
    	/**
    	 * SQL条件查询、排序
    	 * 
    	 * @param condition
    	 * @param isDesc
    	 * @param orderBy
    	 * @return
    	 */
    	public List<T> findModels(Map<String, Object> condition, Object[][] orderBy);
    	/**
    	 * SQL条件查询、排序
    	 * 
    	 * @param condition
    	 * @param isDesc
    	 * @param orderBy
    	 * @return
    	 */
    	public List<T> findModels(Object[][] condition,  Object[][] orderBy);
    	/**
    	 * SQL条件查询、排序
    	 * 
    	 * @param condition
    	 * @param isDesc
    	 * @param orderBy
    	 * @return
    	 */
    	public List<T> findModels(Object[][] condition, Boolean isDesc, String orderBy);
    	
    	/**
    	 * 一般HQL分页查询
    	 * @param hql
    	 * @param pageModel
    	 * @param objects
    	 * @return
    	 */
    	public ListVO<T> findByHQLPage(String hql, PageVO pageModel, Object... objects);
    	
    	public <E> ListVO<E> findModelsByHQLPage(String hql, Object[] objects, PageVO pageModel);
    	
    	/**
    	 * 一般SQL分页查询(查询出来的需要自行组装)
    	 * TODO 有歧义
    	 * 
    	 * @param hql
    	 * @param pageModel
    	 * @param objects
    	 * @return
    	 */
    	public ListVO<Object[]> findBySQLPage(String sql, Object[] objects, PageVO pageModel);
    	
    	/**
    	 * 一般SQL分页查询
    	 * @param hql
    	 * @param pageModel
    	 * @param objects
    	 * @return
    	 */
    	public <E> ListVO<E> findBySQLPage(String sql, Object[] objects, PageVO pageModel, Class<E> clazz);
    	/**
    	 * 查询总记录条数
    	 * 
    	 * @param sql
    	 * @param pageModel
    	 * @param condition
    	 * @return
    	 */
    	public PageVO findCountBySQLPage(String sql, Object[] objects, PageVO pageModel);
    	/**
    	 * 复杂SQL分页查询
    	 * 
    	 * @param hql
    	 * @param pageModel		分页
    	 * @param condition		where条件
    	 * @param isDesc   		是否是降序（由大到小）
    	 * @param orderBy		排序列
    	 * @return
    	 */
    	public ListVO<T> findByHQLPage(String hql, PageVO pageModel, Map<String, Object> condition, Object[][] orderBy);
    
    	/**
    	 * 复杂SQL分页查询
    	 *
    	 * @param hql
    	 * @param pageModel		分页
    	 * @param condition		where条件
    	 * @param isDesc   		是否是降序（由大到小）
    	 * @param orderBy		排序列
    	 * @return
    	 */
    	public ListVO<T> findByHQLPage(String hql, PageVO pageModel, Map<String, Object> condition, Boolean isDesc, String orderBy);
    
    	public ListVO<T> findByHQLPage(String hql, Object[] objects, PageVO pageModel);
    	/**
    	 * 单值检索(查询结果有且仅有一条记录)
    	 * 
    	 * @param hql
    	 * @param objects
    	 * @return
    	 */
    	public Object uniqueResult(String hql,Object...objects);
    	/**
    	 * 单值检索(查询结果有且仅有一条记录)
    	 * 
    	 * @param hql
    	 * @param objects
    	 * @return
    	 */
    	public Object uniqueSQLResult(String sql,Object...objects);
    	
    	/**
    	 * @param pageModel 分页
    	 * @param condition 查询条件
    	 * @param isDesc	是否按由大到小顺序
    	 * @param orderBy	排序列
    	 * @return
    	 */
    	public ListVO<T> findModels(PageVO pageModel, Map<String, Object> condition, Object[][] orderBy);
    
    	/**
    	 * @param pageModel 分页
    	 * @param condition 查询条件
    	 * @param isDesc	是否按由大到小顺序
    	 * @param orderBy	排序列
    	 * @return
    	 */
    	public ListVO<T> findModels(PageVO pageModel, Map<String, Object> condition, Boolean isDesc, String orderBy);
    	/**
    	 * 查询总记录条数
    	 * 
    	 * @param hql
    	 * @param pageModel
    	 * @param condition
    	 * @return
    	 */
    	public PageVO findCountByHQLPage(String hql, PageVO pageModel, Map<String, Object> condition);
    	/**
    	 * 查询总记录条数
    	 * 
    	 * @param pageModel
    	 * @param condition
    	 * @return
    	 */
    	public PageVO findModelsCount(PageVO pageModel, Map<String, Object> condition);
    	
    	/**
    	 * SQL条件查询（一条结果）
    	 * 
    	 * @param condition
    	 * @return
    	 */
    	public T findOneSQL(String sql, Object... object);
    	/**
    	 * SQL条件查询（一条结果）
    	 * 
    	 * @param condition
    	 * @return
    	 */
    	public <E> E findOneSQL(String sql, Class<E> clazz, Object... object);
    }

### 3、其他类引用 ###

3.1、分页信息VO:ListVO

import java.io.Serializable;
    import java.util.List;
    
    public class ListVO<T>  implements Serializable {
    	
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = -5391206473178621952L;
    	private PageVO pageVO;
    	private List<T> list;
    	
    	public ListVO() {
    	}
    	
    	public ListVO(PageVO pageVO, List<T> list) {
    		super();
    		this.pageVO = pageVO;
    		this.list = list;
    	}
    	public PageVO getPageVO() {
    		return pageVO;
    	}
    	public void setPageVO(PageVO pageVO) {
    		this.pageVO = pageVO;
    	}
    	public List<T> getList() {
    		return list;
    	}
    	public void setList(List<T> list) {
    		this.list = list;
    	}
    	
    }

3.2、分写VO:PageVO

import java.io.Serializable;
    
    public class PageVO implements Serializable{
    	
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 2259332203650205810L;
    	private Integer pageSize = 10;  
    	private Integer pageNo = 1;     
    	private Long recordCount = 0l;
    	
    	
    	public PageVO() {
    	}
    	
    	public PageVO(Integer pageSize, Long recordCount) {
    		super();
    		this.pageSize = pageSize;
    		this.recordCount = recordCount;
    	}
    	
    	public Integer getPageSize() {
    		return pageSize;
    	}
    	public void setPageSize(Integer pageSize) {
    		this.pageSize = pageSize;
    	}
    	public Integer getPageNo() {
    		return pageNo;
    	}
    	public void setPageNo(Integer pageNo) {
    		this.pageNo = pageNo;
    	}
    	public long getRecordCount() {
    		return recordCount;
    	}
    	public void setRecordCount(Long recordCount) {
    		this.recordCount = recordCount;
    	}
    
    }

3.3、自定义运行时异常类：MultipleResultException

/**
     * 
     * 	异常情况，结果不该有多个
     *
     *
     */
    public class MultipleResultException extends RuntimeException{
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1095889541166583401L;
    	
    	public MultipleResultException() {
    	}
    	
        public MultipleResultException(String message) {
            super(message);
        }
    
    }