SSH1整合下的通用泛型DAO+分页,基于HibernateTemplate

个人也是初学SSH,这也是对以前我发布的通用泛型DAO的一个升级(J2EE学习笔记——初试SSH之泛型通用DAO

 

共包含3个类:BaseHibernateDAO,Page,QueryParameter

 

BaseHibernateDAO.java

 

Java代码 复制代码
  1. /**  
  2.  * DAO操作基类<br>  
  3.  * 本DAO层实现了通用的数据操作  
  4.  *   
  5.  * @author 黄磊  
  6.  *   
  7.  * @param <T>  
  8.  *            POJO实体对象  
  9.  * @param <ID>  
  10.  *            ID  
  11.  */  
  12. @SuppressWarnings("unchecked")   
  13. public class BaseHibernateDAO<T, ID extends Serializable> extends  
  14.         HibernateDaoSupport {   
  15.   
  16.     private static final Logger logger = Logger   
  17.             .getLogger(BaseHibernateDAO.class);   
  18.   
  19.     /**  
  20.      * 保存指定实体类  
  21.      *   
  22.      * @param entityobj  
  23.      *            实体类  
  24.      */  
  25.     public void save(T entity) {   
  26.         try {   
  27.             getHibernateTemplate().save(entity);   
  28.             if (logger.isDebugEnabled()) {   
  29.                 logger.debug("保存实体类成功," + entity.getClass().getName());   
  30.             }   
  31.         } catch (RuntimeException e) {   
  32.             logger.error("保存实体异常," + entity.getClass().getName(), e);   
  33.             throw e;   
  34.         }   
  35.     }   
  36.   
  37.     /**  
  38.      * 删除指定实体  
  39.      *   
  40.      * @param entityobj  
  41.      *            实体类  
  42.      */  
  43.     public void delete(T entity) {   
  44.         try {   
  45.             getHibernateTemplate().delete(entity);   
  46.             if (logger.isDebugEnabled()) {   
  47.                 logger.debug("删除实体类成功," + entity.getClass().getName());   
  48.             }   
  49.         } catch (RuntimeException e) {   
  50.             logger.error("删除实体异常", e);   
  51.             throw e;   
  52.         }   
  53.     }   
  54.   
  55.     /**  
  56.      * 获取所有实体集合  
  57.      *   
  58.      * @param entityClass  
  59.      *            实体  
  60.      * @return 集合  
  61.      */  
  62.     public List<T> findAll(Class<T> entityClass) {   
  63.         try {   
  64.             if (logger.isDebugEnabled()) {   
  65.                 logger.debug("开始删除实体:" + entityClass.getName());   
  66.             }   
  67.             return getHibernateTemplate().find("from " + entityClass.getName());   
  68.         } catch (RuntimeException e) {   
  69.             logger.error("查找指定实体集合异常,实体:" + entityClass.getName(), e);   
  70.             throw e;   
  71.         }   
  72.     }   
  73.   
  74.     /**  
  75.      * 更新或保存指定实体  
  76.      *   
  77.      * @param entity  
  78.      *            实体类  
  79.      */  
  80.     public void saveOrUpdate(T entity) {   
  81.         try {   
  82.             getHibernateTemplate().saveOrUpdate(entity);   
  83.             if (logger.isDebugEnabled()) {   
  84.                 logger.debug("更新或者保存实体成功," + entity.getClass().getName());   
  85.             }   
  86.         } catch (RuntimeException e) {   
  87.             logger.error("更新或保存实体异常", e);   
  88.             throw e;   
  89.         }   
  90.     }   
  91.   
  92.     /**  
  93.      * 查找指定ID实体类对象  
  94.      *   
  95.      * @param entityClass  
  96.      *            实体Class  
  97.      * @param id  
  98.      *            实体ID  
  99.      * @return 实体对象  
  100.      */  
  101.     public T findById(Class<T> entityClass, ID id) {   
  102.         try {   
  103.             if (logger.isDebugEnabled()) {   
  104.                 logger.debug("开始查找ID为" + id + "的实体:" + entityClass.getName());   
  105.             }   
  106.             return (T) getHibernateTemplate().get(entityClass, id);   
  107.         } catch (RuntimeException e) {   
  108.             logger.error("查找指定ID实体异常,ID:" + id, e);   
  109.             throw e;   
  110.         }   
  111.     }   
  112.   
  113.     /**  
  114.      * 查询指定HQL,并返回集合  
  115.      *   
  116.      * @param hql  
  117.      *            HQL语句  
  118.      * @param values  
  119.      *            可变的参数列表  
  120.      * @return 集合  
  121.      */  
  122.     public List<Object> find(String hql, Object... values) {   
  123.         try {   
  124.             if (logger.isDebugEnabled()) {   
  125.                 logger.debug("开始查询指定HQL语句," + hql);   
  126.             }   
  127.             return getHibernateTemplate().find(hql, values);   
  128.         } catch (RuntimeException e) {   
  129.             logger.error("查询指定HQL异常,HQL:" + hql, e);   
  130.             throw e;   
  131.         }   
  132.     }   
  133.   
  134.     /**  
  135.      * 按照HQL语句查询唯一对象.  
  136.      *   
  137.      * @param hql  
  138.      *            HQL语句  
  139.      * @param values  
  140.      *            可变参数集合  
  141.      * @return OBJECT对象  
  142.      */  
  143.     public Object findUnique(final String hql, final Object... values) {   
  144.         try {   
  145.             if (logger.isDebugEnabled()) {   
  146.                 logger.debug("开始查询返回唯一结果的HQL语句," + hql);   
  147.             }   
  148.             return getHibernateTemplate().execute(new HibernateCallback() {   
  149.                 public Object doInHibernate(Session s)   
  150.                         throws HibernateException, SQLException {   
  151.                     Query query = createQuery(s, hql, values);   
  152.                     return query.uniqueResult();   
  153.                 }   
  154.             });   
  155.         } catch (RuntimeException e) {   
  156.             logger.error("查询指定HQL异常,HQL:" + hql, e);   
  157.             throw e;   
  158.         }   
  159.     }   
  160.   
  161.     /**  
  162.      * 查找指定HQL并返回INT型  
  163.      *   
  164.      * @param hql  
  165.      *            HQL语句  
  166.      * @param values  
  167.      *            可变参数列表  
  168.      * @return INT  
  169.      */  
  170.     public int findInt(final String hql, final Object... values) {   
  171.         return Tools.null2Int(findUnique(hql, values));   
  172.     }   
  173.   
  174.     /**  
  175.      * 获取指定实体Class指定条件的记录总数  
  176.      *   
  177.      * @param entityClass  
  178.      *            实体Class  
  179.      * @param where  
  180.      *            HQL的查询条件,支持参数列表  
  181.      * @param values  
  182.      *            可变参数列表  
  183.      * @return 记录总数  
  184.      */  
  185.     public int findTotalCount(Class<T> entityClass, final String where,   
  186.             final Object... values) {   
  187.         String hql = "select count(e) from " + entityClass.getName() + " as e "  
  188.                 + where;   
  189.         return findInt(hql, values);   
  190.     }   
  191.   
  192.     /**  
  193.      * 获取指定实体Class的记录总数  
  194.      *   
  195.      * @param entityClass  
  196.      *            实体Class  
  197.      * @return 记录总数  
  198.      */  
  199.     public int findTotalCount(Class<T> entityClass) {   
  200.         return findTotalCount(entityClass, "");   
  201.     }   
  202.   
  203.     /**  
  204.      * 查找指定属性的实体集合  
  205.      *   
  206.      * @param entityClass  
  207.      *            实体  
  208.      * @param propertyName  
  209.      *            属性名  
  210.      * @param value  
  211.      *            条件  
  212.      * @return 实体集合  
  213.      */  
  214.     public List<T> findByProperty(Class<T> entityClass, String propertyName,   
  215.             Object value) {   
  216.         try {   
  217.             if (logger.isDebugEnabled()) {   
  218.                 logger.debug("开始查找指定属性:" + propertyName + "为" + value + "的实体"  
  219.                         + entityClass.getName());   
  220.             }   
  221.             String queryStr = "from " + entityClass.getName()   
  222.                     + " as model where model." + propertyName + "=?";   
  223.             return getHibernateTemplate().find(queryStr, value);   
  224.         } catch (RuntimeException e) {   
  225.             logger.error("查找指定条件实体集合异常,条件:" + propertyName, e);   
  226.             throw e;   
  227.         }   
  228.     }   
  229.   
  230.     /**  
  231.      * 模糊查询指定条件对象集合 <br>  
  232.      * 用法:可以实例化一个空的T对象,需要查询某个字段,就set该字段的条件然后调用本方法<br>  
  233.      * 缺点:目前测试貌似只能支持String的模糊查询,虽然有办法重写,但没必要,其他用HQL<br>  
  234.      *   
  235.      * @param entity  
  236.      *            条件实体  
  237.      * @return 结合  
  238.      */  
  239.     public List<T> findByExample(T entity) {   
  240.         try {   
  241.             List<T> results = getHibernateTemplate().findByExample(entity);   
  242.             return results;   
  243.         } catch (RuntimeException re) {   
  244.             logger.error("查找指定条件实体集合异常", re);   
  245.             throw re;   
  246.         }   
  247.     }   
  248.   
  249.     /**  
  250.      * 补充方法(未测) 据说可以无视session的状态持久化对象  
  251.      *   
  252.      * @param entity  
  253.      *            实体类  
  254.      * @return 持久后的实体类  
  255.      */  
  256.     public T merge(T entity) {   
  257.         try {   
  258.             T result = (T) getHibernateTemplate().merge(entity);   
  259.             return result;   
  260.         } catch (RuntimeException re) {   
  261.             logger.error("merge异常", re);   
  262.             throw re;   
  263.         }   
  264.     }   
  265.   
  266.     /**  
  267.      * 清除实体的锁定状态<br>  
  268.      * 方法未测  
  269.      *   
  270.      * @param entity  
  271.      *            实体  
  272.      */  
  273.     public void attachClean(T entity) {   
  274.         try {   
  275.             getHibernateTemplate().lock(entity, LockMode.NONE);   
  276.         } catch (RuntimeException re) {   
  277.             logger.error("实体解锁异常", re);   
  278.             throw re;   
  279.         }   
  280.     }   
  281.   
  282.     /**  
  283.      * 按HQL分页查询.  
  284.      *   
  285.      * @param page  
  286.      *            页面对象  
  287.      * @param hql  
  288.      *            HQL语句  
  289.      * @param values  
  290.      *            可变参数列表  
  291.      * @return 分页数据  
  292.      */  
  293.     public Page<T> findByPage(final Page<T> page, final String hql,   
  294.             final Object... values) {   
  295.         try {   
  296.             if (logger.isDebugEnabled()) {   
  297.                 logger.debug("开始查找指定HQL分页数据," + hql);   
  298.             }   
  299.             return (Page<T>) getHibernateTemplate().execute(   
  300.                     new HibernateCallback() {   
  301.                         public Object doInHibernate(Session s)   
  302.                                 throws HibernateException, SQLException {   
  303.                             Query query = createQuery(s, hql, values);   
  304.                             if (page.isFirstSetted()) {   
  305.                                 query.setFirstResult(page.getFirst());   
  306.                             }   
  307.                             if (page.isPageSizeSetted()) {   
  308.                                 query.setMaxResults(page.getPageSize());   
  309.                             }   
  310.                             page.setResult(query.list());   
  311.                             if (logger.isDebugEnabled()) {   
  312.                                 logger.debug("查找指定HQL分页数据成功," + hql);   
  313.                             }   
  314.                             return page;   
  315.                         }   
  316.                     });   
  317.         } catch (RuntimeException e) {   
  318.             logger.error("分页查询异常,HQL:" + hql, e);   
  319.             throw e;   
  320.         }   
  321.     }   
  322.   
  323.     /**  
  324.      * 根据查询条件与参数列表创建Query对象  
  325.      *   
  326.      * @param session  
  327.      *            Hibernate会话  
  328.      * @param hql  
  329.      *            HQL语句  
  330.      * @param objects  
  331.      *            参数列表  
  332.      * @return Query对象  
  333.      */  
  334.     public Query createQuery(Session session, String hql, Object... objects) {   
  335.         Query query = session.createQuery(hql);   
  336.         if (objects != null) {   
  337.             for (int i = 0; i < objects.length; i++) {   
  338.                 query.setParameter(i, objects[i]);   
  339.             }   
  340.         }   
  341.         return query;   
  342.     }   
  343.   
  344.     /**  
  345.      * 从Spring上下文中获取本类对象<br>  
  346.      * 此方法可能存在线程并发问题(待测)  
  347.      *   
  348.      * @param context  
  349.      *            Spring上下文  
  350.      * @return 本类对象  
  351.      */  
  352.     public static BaseHibernateDAO getFromApplicationContext(   
  353.             WebApplicationContext context) {   
  354.         return (BaseHibernateDAO) context.getBean("BaseHibernateDAO");   
  355.     }   
  356.   
  357. }  
/**
 * DAO操作基类<br>
 * 本DAO层实现了通用的数据操作
 * 
 * @author 黄磊
 * 
 * @param <T>
 *            POJO实体对象
 * @param <ID>
 *            ID
 */
@SuppressWarnings("unchecked")
public class BaseHibernateDAO<T, ID extends Serializable> extends
		HibernateDaoSupport {

	private static final Logger logger = Logger
			.getLogger(BaseHibernateDAO.class);

	/**
	 * 保存指定实体类
	 * 
	 * @param entityobj
	 *            实体类
	 */
	public void save(T entity) {
		try {
			getHibernateTemplate().save(entity);
			if (logger.isDebugEnabled()) {
				logger.debug("保存实体类成功," + entity.getClass().getName());
			}
		} catch (RuntimeException e) {
			logger.error("保存实体异常," + entity.getClass().getName(), e);
			throw e;
		}
	}

	/**
	 * 删除指定实体
	 * 
	 * @param entityobj
	 *            实体类
	 */
	public void delete(T entity) {
		try {
			getHibernateTemplate().delete(entity);
			if (logger.isDebugEnabled()) {
				logger.debug("删除实体类成功," + entity.getClass().getName());
			}
		} catch (RuntimeException e) {
			logger.error("删除实体异常", e);
			throw e;
		}
	}

	/**
	 * 获取所有实体集合
	 * 
	 * @param entityClass
	 *            实体
	 * @return 集合
	 */
	public List<T> findAll(Class<T> entityClass) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始删除实体:" + entityClass.getName());
			}
			return getHibernateTemplate().find("from " + entityClass.getName());
		} catch (RuntimeException e) {
			logger.error("查找指定实体集合异常,实体:" + entityClass.getName(), e);
			throw e;
		}
	}

	/**
	 * 更新或保存指定实体
	 * 
	 * @param entity
	 *            实体类
	 */
	public void saveOrUpdate(T entity) {
		try {
			getHibernateTemplate().saveOrUpdate(entity);
			if (logger.isDebugEnabled()) {
				logger.debug("更新或者保存实体成功," + entity.getClass().getName());
			}
		} catch (RuntimeException e) {
			logger.error("更新或保存实体异常", e);
			throw e;
		}
	}

	/**
	 * 查找指定ID实体类对象
	 * 
	 * @param entityClass
	 *            实体Class
	 * @param id
	 *            实体ID
	 * @return 实体对象
	 */
	public T findById(Class<T> entityClass, ID id) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查找ID为" + id + "的实体:" + entityClass.getName());
			}
			return (T) getHibernateTemplate().get(entityClass, id);
		} catch (RuntimeException e) {
			logger.error("查找指定ID实体异常,ID:" + id, e);
			throw e;
		}
	}

	/**
	 * 查询指定HQL,并返回集合
	 * 
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            可变的参数列表
	 * @return 集合
	 */
	public List<Object> find(String hql, Object... values) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查询指定HQL语句," + hql);
			}
			return getHibernateTemplate().find(hql, values);
		} catch (RuntimeException e) {
			logger.error("查询指定HQL异常,HQL:" + hql, e);
			throw e;
		}
	}

	/**
	 * 按照HQL语句查询唯一对象.
	 * 
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            可变参数集合
	 * @return OBJECT对象
	 */
	public Object findUnique(final String hql, final Object... values) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查询返回唯一结果的HQL语句," + hql);
			}
			return getHibernateTemplate().execute(new HibernateCallback() {
				public Object doInHibernate(Session s)
						throws HibernateException, SQLException {
					Query query = createQuery(s, hql, values);
					return query.uniqueResult();
				}
			});
		} catch (RuntimeException e) {
			logger.error("查询指定HQL异常,HQL:" + hql, e);
			throw e;
		}
	}

	/**
	 * 查找指定HQL并返回INT型
	 * 
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            可变参数列表
	 * @return INT
	 */
	public int findInt(final String hql, final Object... values) {
		return Tools.null2Int(findUnique(hql, values));
	}

	/**
	 * 获取指定实体Class指定条件的记录总数
	 * 
	 * @param entityClass
	 *            实体Class
	 * @param where
	 *            HQL的查询条件,支持参数列表
	 * @param values
	 *            可变参数列表
	 * @return 记录总数
	 */
	public int findTotalCount(Class<T> entityClass, final String where,
			final Object... values) {
		String hql = "select count(e) from " + entityClass.getName() + " as e "
				+ where;
		return findInt(hql, values);
	}

	/**
	 * 获取指定实体Class的记录总数
	 * 
	 * @param entityClass
	 *            实体Class
	 * @return 记录总数
	 */
	public int findTotalCount(Class<T> entityClass) {
		return findTotalCount(entityClass, "");
	}

	/**
	 * 查找指定属性的实体集合
	 * 
	 * @param entityClass
	 *            实体
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            条件
	 * @return 实体集合
	 */
	public List<T> findByProperty(Class<T> entityClass, String propertyName,
			Object value) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查找指定属性:" + propertyName + "为" + value + "的实体"
						+ entityClass.getName());
			}
			String queryStr = "from " + entityClass.getName()
					+ " as model where model." + propertyName + "=?";
			return getHibernateTemplate().find(queryStr, value);
		} catch (RuntimeException e) {
			logger.error("查找指定条件实体集合异常,条件:" + propertyName, e);
			throw e;
		}
	}

	/**
	 * 模糊查询指定条件对象集合 <br>
	 * 用法:可以实例化一个空的T对象,需要查询某个字段,就set该字段的条件然后调用本方法<br>
	 * 缺点:目前测试貌似只能支持String的模糊查询,虽然有办法重写,但没必要,其他用HQL<br>
	 * 
	 * @param entity
	 *            条件实体
	 * @return 结合
	 */
	public List<T> findByExample(T entity) {
		try {
			List<T> results = getHibernateTemplate().findByExample(entity);
			return results;
		} catch (RuntimeException re) {
			logger.error("查找指定条件实体集合异常", re);
			throw re;
		}
	}

	/**
	 * 补充方法(未测) 据说可以无视session的状态持久化对象
	 * 
	 * @param entity
	 *            实体类
	 * @return 持久后的实体类
	 */
	public T merge(T entity) {
		try {
			T result = (T) getHibernateTemplate().merge(entity);
			return result;
		} catch (RuntimeException re) {
			logger.error("merge异常", re);
			throw re;
		}
	}

	/**
	 * 清除实体的锁定状态<br>
	 * 方法未测
	 * 
	 * @param entity
	 *            实体
	 */
	public void attachClean(T entity) {
		try {
			getHibernateTemplate().lock(entity, LockMode.NONE);
		} catch (RuntimeException re) {
			logger.error("实体解锁异常", re);
			throw re;
		}
	}

	/**
	 * 按HQL分页查询.
	 * 
	 * @param page
	 *            页面对象
	 * @param hql
	 *            HQL语句
	 * @param values
	 *            可变参数列表
	 * @return 分页数据
	 */
	public Page<T> findByPage(final Page<T> page, final String hql,
			final Object... values) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("开始查找指定HQL分页数据," + hql);
			}
			return (Page<T>) getHibernateTemplate().execute(
					new HibernateCallback() {
						public Object doInHibernate(Session s)
								throws HibernateException, SQLException {
							Query query = createQuery(s, hql, values);
							if (page.isFirstSetted()) {
								query.setFirstResult(page.getFirst());
							}
							if (page.isPageSizeSetted()) {
								query.setMaxResults(page.getPageSize());
							}
							page.setResult(query.list());
							if (logger.isDebugEnabled()) {
								logger.debug("查找指定HQL分页数据成功," + hql);
							}
							return page;
						}
					});
		} catch (RuntimeException e) {
			logger.error("分页查询异常,HQL:" + hql, e);
			throw e;
		}
	}

	/**
	 * 根据查询条件与参数列表创建Query对象
	 * 
	 * @param session
	 *            Hibernate会话
	 * @param hql
	 *            HQL语句
	 * @param objects
	 *            参数列表
	 * @return Query对象
	 */
	public Query createQuery(Session session, String hql, Object... objects) {
		Query query = session.createQuery(hql);
		if (objects != null) {
			for (int i = 0; i < objects.length; i++) {
				query.setParameter(i, objects[i]);
			}
		}
		return query;
	}

	/**
	 * 从Spring上下文中获取本类对象<br>
	 * 此方法可能存在线程并发问题(待测)
	 * 
	 * @param context
	 *            Spring上下文
	 * @return 本类对象
	 */
	public static BaseHibernateDAO getFromApplicationContext(
			WebApplicationContext context) {
		return (BaseHibernateDAO) context.getBean("BaseHibernateDAO");
	}

}

  

QueryParameter.java

 

Java代码 复制代码
  1. /**  
  2.  * 本类封装分页和排序查询请求参数.  
  3.  * 本类参考自springside的ORM封装设计  
  4.  *   
  5.  *   
  6.  *   
  7.  */  
  8. public class QueryParameter {   
  9.        
  10.     public static final String ASC = "asc";   
  11.     public static final String DESC = "desc";   
  12.   
  13.     protected int pageNo = 1;   
  14.     protected int pageSize = -1;   
  15.     protected String orderBy = null;   
  16.     protected String order = ASC;   
  17.     protected boolean autoCount = false;   
  18.   
  19.     /**  
  20.      * 获得每页的记录数量,无默认值.  
  21.      */  
  22.     public int getPageSize() {   
  23.         return pageSize;   
  24.     }   
  25.   
  26.     public void setPageSize(int pageSize) {   
  27.         this.pageSize = pageSize;   
  28.     }   
  29.   
  30.     /**  
  31.      * 是否已设置每页的记录数量.  
  32.      */  
  33.     public boolean isPageSizeSetted() {   
  34.         return pageSize > -1;   
  35.     }   
  36.   
  37.     /**  
  38.      * 获得当前页的页号,序号从1开始,默认为1.  
  39.      */  
  40.     public int getPageNo() {   
  41.         return pageNo;   
  42.     }   
  43.   
  44.     public void setPageNo(int pageNo) {   
  45.         this.pageNo = pageNo;   
  46.     }   
  47.   
  48.     /**  
  49.      * 根据pageNo和pageSize计算当前页第一条记录在总结果集中的位置,序号从0开始.  
  50.      */  
  51.     public int getFirst() {   
  52.         if (pageNo < 1 || pageSize < 1)   
  53.             return -1;   
  54.         else  
  55.             return ((pageNo - <span styl
分享到:
评论

你可能感兴趣的:(DAO,spring,Hibernate,orm,ssh)