Hibernate 通用操作类 BaseHibernateDao

package cn.util;

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

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import cn.util.HibernateSessionFactory;//session工厂类
import cn.util.PageBean;//分页包装类

/**
* BaseHibernateDao 定义DAO的通用操作的实现
*
* @author hezhao
*
*/
@SuppressWarnings("unchecked")
public abstract class BaseHibernateDao<T> {

private Class<T> clazz;

/**
* 反射 通过构造方法指定DAO的具体实现类
*/
public BaseHibernateDao() {
ParameterizedType type = (ParameterizedType) this.getClass()
.getGenericSuperclass();
clazz = (Class<T>) type.getActualTypeArguments()[0];
// System.out.println("DAO的真实实现类是：" + this.clazz.getName());
}

/**
* 查询返回集合
*
* @param hql
* @param params
* @return List
*/
public List<T> queryList(String hql, Object... params) {
return prepareQuery(hql, params).list();
}

/**
* 查询返回集合
*
* @param hql
* @param params
* @return List
*/
public List<T> queryList(String hql, Map<Object, Object> params) {
return prepareQuery(hql, params).list();
}

/**
* 查询返回集合
*
* @param hql
* @param params
*            封装条件的Map集合
*
* @return List
*/
public List<T> queryListByProperties(String hql, Map<String, Object> params) {
return HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params).list();
}

/**
* 查询返回集合
*
* @param hql
* @param params
*            封装条件的对象
*
* @return List
*/
public List<T> queryListByProperties(String hql, Object params) {
return HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params).list();
}

/**
* 查询返回单个对象
*
* @param hql
* @param params
* @return
*/
public T queryFirst(String hql, Object... params) {
return (T) prepareQuery(hql, params).setMaxResults(1).uniqueResult();
}

/**
* 查询返回单个对象
*
* @param hql
* @param params
* @return
*/
public T queryFirst(String hql, Map<Object, Object> params) {
return (T) prepareQuery(hql, params).setMaxResults(1).uniqueResult();
}

/**
* 查询返回单个对象
*
* @param hql
* @param params
*            封装条件的Map集合
*
* @return
*/
public T queryFirstByProperties(String hql, Map<String, Object> params) {
return (T) HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params).setMaxResults(1).uniqueResult();
}

/**
* 查询返回单个对象
*
* @param hql
* @param params
*            封装条件的对象
*
* @return
*/
public T queryFirstByProperties(String hql, Object params) {
return (T) HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params).setMaxResults(1).uniqueResult();
}

/**
* 根据主键查询一条数据，立即查询， 若加载的数据不存在，返回NULL
*
* @param id
*
* @return
*/
public T get(Serializable id) {
return (T) HibernateSessionFactory.getSession().get(this.clazz, id);
}

/**
* 根据主键查询一条数据，延时加载， 若加载的数据不存在，返回NULL
*
* @param id
*
* @return
*/
public T load(Serializable id) {
try {
return (T) HibernateSessionFactory.getSession()
.load(this.clazz, id);
} catch (HibernateException e) {
e.printStackTrace();
return null;
}
}

/**
* 获取数据的数量
*
* @param hql
* @param params
* @return Integer
*/
public Integer getCount(String hql, Object... params) {
long count = (Long) prepareQuery(hql, params).setMaxResults(1)
.uniqueResult();
return (int) count;
}

/**
* 获取数据的数量
*
* @param hql
* @param params
* @return Integer
*/
public Integer getCount(String hql, Map<Object, Object> params) {
long count = (Long) prepareQuery(hql, params).setMaxResults(1)
.uniqueResult();
return (int) count;
}

/**
* 获取数据的数量
*
* @param hql
* @param params
*            封装条件的Map集合
* @return Integer
*/
public Integer getCountByProperties(String hql, Map<String, Object> params) {
Query query = HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params);
long count = (Long) query.setMaxResults(1).uniqueResult();
return (int) count;
}

/**
* 获取数据的数量
*
* @param hql
* @param params
*
13dce
封装条件的对象
* @return Integer
*/
public Integer getCountByProperties(String hql, Object params) {
Query query = HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params);
long count = (Long) query.setMaxResults(1).uniqueResult();
return (int) count;
}

/**
* 投影查询
*
* @param hql
* @param params
* @return
*/
public List Projection(String hql, Object... params) {
return prepareQuery(hql, params).list();
}

/**
* 投影查询
*
* @param hql
* @param params
* @return
*/
public List Projection(String hql, Map<Object, Object> params) {
return prepareQuery(hql, params).list();
}

/**
* 投影查询
*
* @param hql
* @param params
*            封装条件的Map集合
* @return
*/
public List ProjectionByProperties(String hql, Map<String, Object> params) {
return HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params).list();
}

/**
* 投影查询
*
* @param hql
* @param params
*            封装条件的对象
* @return
*/
public List ProjectionByProperties(String hql, Object params) {
return HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params).list();
}

/**
* 获得唯一结果
*
* @param hql
* @param params
* @return Object
*/
public Object Single(String hql, Object... params) {
return prepareQuery(hql, params).setMaxResults(1).uniqueResult();
}

/**
* 获得唯一结果
*
* @param hql
* @param params
* @return Object
*/
public Object Single(String hql, Map<Object, Object> params) {
return prepareQuery(hql, params).setMaxResults(1).uniqueResult();
}

/**
* 获得唯一结果
*
* @param hql
* @param params
*            封装条件的Map集合
* @return Object
*/
public Object SingleByProperties(String hql, Map<String, Object> params) {
return HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params).setMaxResults(1).uniqueResult();
}

/**
* 获得唯一结果
*
* @param hql
* @param params
*            封装条件的对象
* @return Object
*/
public Object SingleByProperties(String hql, Object params) {
return HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params).setMaxResults(1).uniqueResult();
}

/**
* 使用hql 语句进行分页查询操作
*
* @param hql
*            需要查询的hql语句
* @param params
*            如果hql有多个参数需要传入，params就是传入的参数数组
* @param pageIndex
*            当前页码
* @param pageSize
*            每页需要显示的记录数
* @return 当前页的所有记录
*/
public List<T> queryForPage(String hql, int pageIndex, int pageSize,
Object... params) {
return prepareQuery(hql, params)
.setFirstResult((pageIndex - 1) * pageSize)
.setMaxResults(pageSize).list();
}

/**
* 使用hql 语句进行分页查询操作
*
* @param hql
*            需要查询的hql语句
* @param params
*            如果hql有多个参数需要传入，params就是传入的Map集合
* @param pageIndex
*            当前页码
* @param pageSize
*            每页需要显示的记录数
* @return 当前页的所有记录
*/
public List<T> queryForPage(String hql, int pageIndex, int pageSize,
Map<Object, Object> params) {
return prepareQuery(hql, params)
.setFirstResult((pageIndex - 1) * pageSize)
.setMaxResults(pageSize).list();
}

/**
* 使用hql 语句进行分页查询操作 参数绑定为条件集合（Map）
*
* @param hql
*            需要查询的hql语句
* @param params
*            封装条件的Map集合
* @param pageIndex
*            当前页码
* @param pageSize
*            每页需要显示的记录数
* @return 当前页的所有记录
*/
public List<T> queryForPageByProperties(String hql, int pageIndex,
int pageSize, Map<String, Object> params) {
return HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params)
.setFirstResult((pageIndex - 1) * pageSize)
.setMaxResults(pageSize).list();
}

/**
* 使用hql 语句进行分页查询操作 参数绑定为条件对象
*
* @param hql
*            需要查询的hql语句
* @param params
*            封装条件的对象
* @param pageIndex
*            当前页码
* @param pageSize
*            每页需要显示的记录数
* @return 当前页的所有记录
*/
public List<T> queryForPageByProperties(String hql, int pageIndex,
int pageSize, Object params) {
return HibernateSessionFactory.getSession().createQuery(hql)
.setProperties(params)
.setFirstResult((pageIndex - 1) * pageSize)
.setMaxResults(pageSize).list();
}

/**
* 获取分页对象
*
* @param hql
* @param params
* @param pageIndex
*            当前页码
* @param pageSize
*            每页显示的数量
* @return PageBean
*/
public PageBean<T> findForPage(String hql, int pageIndex, int pageSize,
Object... params) {
int totalCount = queryList(hql, params).size(); // 总记录数
List<T> list = queryForPage(hql, pageIndex, pageSize, params);
// 把分页信息保存到pageBean中
return new PageBean<T>(list, pageSize, pageIndex, totalCount);
}

/**
* 获取分页对象
*
* @param hql
* @param params
* @param pageIndex
*            当前页码
* @param pageSize
*            每页显示的数量
* @return PageBean
*/
public PageBean<T> findForPage(String hql, int pageIndex, int pageSize,
Map<Object, Object> params) {
int totalCount = queryList(hql, params).size(); // 总记录数
List<T> list = queryForPage(hql, pageIndex, pageSize, params);
// 把分页信息保存到pageBean中
return new PageBean<T>(list, pageSize, pageIndex, totalCount);
}

/**
* 获取分页对象
*
* @param hql
* @param params
*            封装条件的Map集合
* @param pageIndex
*            当前页码
* @param pageSize
*            每页显示的数量
* @return PageBean
*/
public PageBean<T> findForPageByProperties(String hql, int pageIndex,
int pageSize, Map<String, Object> params) {
int totalCount = queryListByProperties(hql, params).size(); // 总记录数
List<T> list = queryForPageByProperties(hql, pageIndex, pageSize,
params);
// 把分页信息保存到pageBean中
return new PageBean<T>(list, pageSize, pageIndex, totalCount);
}

/**
* 获取分页对象 参数绑定为条件对象
*
* @param hql
* @param params
*            封装条件的对象
* @param pageIndex
*            当前页码
* @param pageSize
*            每页显示的数量
* @return PageBean
*/
public PageBean<T> findForPageByProperties(String hql, int pageIndex,
int pageSize, Object params) {
int totalCount = queryListByProperties(hql, params).size(); // 总记录数
List<T> list = queryForPageByProperties(hql, pageIndex, pageSize,
params);
// 把分页信息保存到pageBean中
return new PageBean<T>(list, pageSize, pageIndex, totalCount);
}

/**
* 新增
*
* @param entity
* @return boolean
*/
public boolean save(T entity) {
Transaction tx = null;
try {
Session session = HibernateSessionFactory.getSession();
tx = session.beginTransaction();
session.save(entity);
tx.commit();
return true;
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null) {
tx.rollback();
}
return false;
}
}

/**
* 修改
*
* @param entity
* @return boolean
*/
public boolean update(T entity) {
Transaction tx = null;
try {
Session session = HibernateSessionFactory.getSession();
tx = session.beginTransaction();
session.update(entity);
tx.commit();
return true;
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null) {
tx.rollback();
}
return false;
}
}

/**
* 增加或修改
*
* @param entity
* @return boolean
*/
public boolean saveOrUpdate(T entity) {
Transaction tx = null;
try {
Session session = HibernateSessionFactory.getSession();
tx = session.beginTransaction();
session.saveOrUpdate(entity);
tx.commit();
return true;
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null) {
tx.rollback();
}
return false;
}
}

/**
* 把一个游离态对象的属性复制到一个持久化对象中，执行更新或插入操作并返回持久化的对像，若传入的是瞬时态对象则保存并返回其副本
*
* @param entity
* @return
*/
public T merge(T entity) {
Transaction tx = null;
try {
Session session = HibernateSessionFactory.getSession();
tx = session.beginTransaction();
T result = (T) session.merge(entity);
tx.commit();
return result;
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null) {
tx.rollback();
}
return null;
}
}

/**
* 删除
*
* @param entity
* @return boolean
*/
public boolean delete(T entity) {
Transaction tx = null;
try {
Session session = HibernateSessionFactory.getSession();
tx = session.beginTransaction();
session.delete(entity);
tx.commit();
return true;
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null) {
tx.rollback();
}
return false;
}
}

/**
* 删除
*
* @param id
* @return boolean
*/
public boolean delete(Serializable id) {
Transaction tx = null;
try {
Session session = HibernateSessionFactory.getSession();
tx = session.beginTransaction();
T entity = get(id);
session.delete(entity);
tx.commit();
return true;
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null) {
tx.rollback();
}
return false;
}
}

/**
* 准备query对象 内部调用
*
* @param hql
* @param params
* @return Query
*/
private Query prepareQuery(String hql, Object... params) {
Session session = HibernateSessionFactory.getSession();
Query query = session.createQuery(hql);
if (params != null && params.length > 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
return query;
}

/**
* 准备query对象 内部调用
*
* @param hql
* @param params
* @return QueryS
*/
private Query prepareQuery(String hql, Map<Object, Object> params) {
Session session = HibernateSessionFactory.getSession();
Query query = session.createQuery(hql);
if (params != null && params.size() > 0) {
for (Object key : params.keySet()) {
if (key instanceof Integer) {
query.setParameter((Integer) key, params.get(key));
} else if (key instanceof String) {
query.setParameter((String) key, params.get(key));
}
}
}
return query;
}
}

package cn.util;

import java.util.List;

/**
* 分页包装对象(包装分页常用属性)
*
* @author Administrator
*
*/
public class PageBean<T> {
private List<T> list;// 当前页列表数据
private int totalCount;// 总记录数
private int totalPages;// 总页数
private int pageSize = 5;// 每页显示多少条
private int pageIndex = 1;// 当前页码
private int prePageIndex;// 上一页码
private int nextPageIndex;// 下一页码
private int firstPageIndex = 1;// 第一页码
private int lastPageIndex;// 最后一页码
private boolean hasPreviousPage;// 是否有上一页
private boolean hasNextPage;// 是否有下一页
private String pagerString;// 分页导航条

/*
* 分页包装对象
*/
public PageBean() {

}

/**
* PageBean 分页包装对象
*
* @param list
*            当前页列表数据
* @param pageSize
*            每页显示的数量
* @param pageIndex
*            当前页码
* @param totalCount
*            总记录数
*/
public PageBean(List<T> list, int pageSize, int pageIndex, int totalCount) {
this.setList(list);
this.setPageSize(pageSize);
this.setPageIndex(pageIndex);
this.setTotalCount(totalCount);
}

/**
* 获得当前页列表数据
*
* @return List
*/
public List<T> getList() {
return this.list;
}

/**
* 设置当前页列表数据
*
* @param list
* @return PageBean
*/
public PageBean<T> setList(List<T> list) {
this.list = list;
return this;

}

/**
* 获得总记录数
*
* @return int
*/
public int getTotalCount() {
return this.totalCount;
}

/**
* 设置总记录数
*
* @param totalCount
* @return PageBean
*/
public PageBean<T> setTotalCount(int totalCount) {
this.totalCount = totalCount;
return this;
}

/**
* 总页数
*
* @return int
*/
public int getTotalPages() {
// 计算出总页数
this.totalPages = (this.totalCount % this.pageSize == 0 ? (this.totalCount / this.pageSize)
: (this.totalCount / this.pageSize) + 1);
if (this.totalPages < 1) {
this.totalPages = 1;
}
return this.totalPages;
}

/**
* 获得每页显示的数量
*
* @return int
*/
public int getPageSize() {
return this.pageSize;
}

/**
* 设置每页显示的数量
*
* @param pageSize
* @return PageBean
*/
public PageBean<T> setPageSize(int pageSize) {
this.pageSize = pageSize;
return this;
}

/**
* 获得当前页码
*
* @return int
*/
public int getPageIndex() {
if (this.pageIndex < 1) {
this.pageIndex = 1;
}
if (this.pageIndex > getTotalPages()) {
this.pageIndex = getTotalPages();
}
return this.pageIndex;
}

/**
* 设置当前页码
*
* @param pageIndex
* @return PageBean
*/
public PageBean<T> setPageIndex(int pageIndex) {
this.pageIndex = pageIndex;
return this;
}

/**
* 上一页
*
* @return int
*/
public int getPrePageIndex() {
this.prePageIndex = this.getPageIndex() - 1;
if (this.prePageIndex < 1) {
this.prePageIndex = getFirstPageIndex();
}
return this.prePageIndex;
}

/**
* 下一页
*
* @return int
*/
public int getNextPageIndex() {
this.nextPageIndex = this.getPageIndex() + 1;
if (this.nextPageIndex > getTotalPages()) {
this.nextPageIndex = getTotalPages();
}
return this.nextPageIndex;
}

/**
* 首页
*
* @return int
*/
public int getFirstPageIndex() {
return this.firstPageIndex;
}

/**
* 尾页
*
* @return int
*/
public int getLastPageIndex() {
this.lastPageIndex = this.getTotalPages();
return this.lastPageIndex;
}

/**
* 是否有上一页
*
* @return boolean
*/
public boolean getHasPreviousPage() {
this.hasPreviousPage = this.getPageIndex() > 1 ? true : false;
return this.hasPreviousPage;
}

/**
* 是否有下一页
*
* @return boolean
*/
public boolean getHasNextPage() {
this.hasNextPage = this.getPageIndex() < this.getTotalPages() ? true
: false;
return this.hasNextPage;
}

/**
* 分页导航条
* @return String
*/
public String getPagerString() {
// 起始数字
int start = this.getPageIndex() - 5 >= 1 ? this.getPageIndex() - 5 : 1;
// 结束数字
int end = this.getTotalPages() - start > 10 ? start + 10 : this
.getTotalPages();
StringBuffer sbf = new StringBuffer();
sbf.append("<ul class='pager'>");
// 显示首页和上一页
if (this.getHasPreviousPage()) {
sbf.append("<li><a href='javascript:ChangePageIndex("
+ this.getFirstPageIndex() + ");'>首页</a></li>");
sbf.append("<li><a href='javascript:ChangePageIndex("
+ this.getPrePageIndex() + ");'>上一页</a></li>");
}
// 显示数字页码
for (int i = start; i <= end; i++) {
if (i == this.getPageIndex()) {
sbf.append("<li><font class='currentPageIndex'>" + i + "</font></li>");
} else {
sbf.append("<li><a href='javascript:ChangePageIndex(" + i
+ ");'>" + i + "</a></li>");
}
}
// 显示下一页和尾页
if (this.getHasNextPage()) {
sbf.append("<li><a href='javascript:ChangePageIndex("
+ this.getNextPageIndex() + ");'>下一页</a></li>");
sbf.append("<li><a href='javascript:ChangePageIndex("
+ this.getLastPageIndex() + ");'>尾页</a></li>");
}
sbf.append("</ul>");
this.pagerString = sbf.toString();
return pagerString;
}

}

package cn.util;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;

/**
*
* Session工厂类
*/
public class HibernateSessionFactory {

private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
//使用 AnnotationConfiguration 建立会话工厂
private  static Configuration configuration = new AnnotationConfiguration();
private static org.hibernate.SessionFactory sessionFactory;
private static String configFile = CONFIG_FILE_LOCATION;

static {
try {
configuration.configure(configFile);
sessionFactory = configuration.buildSessionFactory();
} catch (Exception e) {
System.err
.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}
private HibernateSessionFactory() {
}

/**
* 获得session
*/
public static Session getSession() throws HibernateException {
Session session = (Session) threadLocal.get();

if (session == null || !session.isOpen()) {
if (sessionFactory == null) {
rebuildSessionFactory();
}
session = (sessionFactory != null) ? sessionFactory.openSession()
: null;
threadLocal.set(session);
}

return session;
}

/**
*  重新获得session
*
*/
public static void rebuildSessionFactory() {
try {
configuration.configure(configFile);
sessionFactory = configuration.buildSessionFactory();
} catch (Exception e) {
System.err
.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}

/**
* 关闭session
*
*  @throws HibernateException
*/
public static void closeSession() throws HibernateException {
Session session = (Session) threadLocal.get();
threadLocal.set(null);

if (session != null) {
session.close();
}
}

/**
*  获得sessionfactory
*
*/
public static org.hibernate.SessionFactory getSessionFactory() {
return sessionFactory;
}

/**
*  设置配置文件
*/
public static void setConfigFile(String configFile) {
HibernateSessionFactory.configFile = configFile;
sessionFactory = null;
}

/**
*  获得Configuration
*
*/
public static Configuration getConfiguration() {
return configuration;
}

}