spring-hibernate 简单dao

	private HibernateTemplate hibernateTemplate = null;
	private SessionFactory sessionFactory = null;

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

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	@Autowired
	public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
		this.hibernateTemplate = hibernateTemplate;
	}

	public HibernateTemplate getHibernateTemplate() {
		return hibernateTemplate;
	}

	public void save(Object obj) {
		getHibernateTemplate().save(obj);
	}

	public void delete(Object obj) {
		getHibernateTemplate().delete(obj);
	}

	public void update(Object obj) {
		getHibernateTemplate().update(obj);
	}

	@SuppressWarnings("unchecked")
	public Object get(Class clazz, int id) {
		return getHibernateTemplate().get(clazz, id);
	}

	/**
	 * 通过完整的hql语句，将查询结果按pageSize分页，并返回第index页
	 * 
	 * @param hql
	 *            完整的hql语句
	 * @param pageSize
	 *            页面大小
	 * @param index
	 *            页码
	 * @return page 页面
	 */
	public <T> Page<T> queryPageByHQL(final String hql, final int pageSize,
			final int index) {
		List<Page<T>> pageList = hibernateTemplate
				.executeFind(new HibernateCallback() {
					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						List res = new ArrayList(1);
						Page<T> page = new Page<T>();
						Query query = session.createQuery(hql);
						int totalRecord = query.list().size();
						List<T> results = new ArrayList<T>();
						int tmpIndex = 0;
						if (totalRecord != 0) {
							page.setPageSize(pageSize);
							page.setTotalRecord(totalRecord);
							page.countTotalPage();
							if (index < 1) {
								tmpIndex = 1;
							}
							if (index > page.getTotalPage()) {
								tmpIndex = page.getTotalPage();
							}
							int firstResult = (tmpIndex - 1) * pageSize;
							query.setFirstResult(firstResult);
							query.setMaxResults(pageSize);
							results = (List<T>) query.list();
							page.setResults(results);
							page.setIndex(tmpIndex);
							page.setHasPreviousAndNext();
						}
						res.add(page);
						return res;
					}

				});

		return (Page<T>) pageList.get(0);
	}

	/**
	 * 通过带参数params的hql语句，将查询结果按pageSize分页，并返回第index页
	 * 
	 * @param hql
	 *            带参数的hql语句
	 * @param pageSize
	 *            页面大小
	 * @param index
	 *            页码
	 * @param params
	 *            参数
	 * @return page 页面
	 */
	public <T> Page<T> queryPageByHQL(final String hql, final int pageSize,
			final int index, final Map<String, Object> params) {

		List<Page<T>> pageList = hibernateTemplate
				.executeFind(new HibernateCallback() {

					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						List res = new ArrayList(1);
						Page<T> page = new Page<T>();
						Query query = session.createQuery(hql);
						Iterator<String> iterator = params.keySet().iterator();
						List<T> results = new ArrayList<T>();
						int tmpIndex = 0;
						while (iterator.hasNext()) {
							String key = iterator.next();
							query.setParameter(key, params.get(key));
						}
						int totalRecord = query.list().size();
						if (totalRecord != 0) {
							page.setPageSize(pageSize);
							page.setTotalRecord(totalRecord);
							page.countTotalPage();
							if (index < 1) {
								tmpIndex = 1;
							}
							if (index > page.getTotalPage()) {
								tmpIndex = page.getTotalPage();
							}
							int firstResult = (tmpIndex - 1) * pageSize;
							query.setFirstResult(firstResult);
							query.setMaxResults(pageSize);
							results = (List<T>) query.list();
							page.setResults(results);
							page.setIndex(tmpIndex);
							page.setHasPreviousAndNext();
						}
						res.add(page);
						return res;
					}
				});

		return (Page<T>) pageList.get(0);
	}

	/**
	 * 通过完整的sql语句，将查询结果封装为entityClass类，并按pageSize分页，返回第index页
	 * 
	 * @param entityClass
	 *            所要封装的类
	 * @param sql
	 *            完整的sql语句
	 * @param pageSize
	 *            页面大小
	 * @param index
	 *            页码
	 * @return page 页面
	 */
	public <T> Page<T> findPageBySQL(final Class<T> entityClass,
			final String sql, final int pageSize, final int index) {

		List<Page<T>> pageList = hibernateTemplate
				.executeFind(new HibernateCallback() {

					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						List res = new ArrayList(1);
						Page<T> page = new Page<T>();
						Query query = session.createSQLQuery(sql).addEntity(
								entityClass);
						List<T> results = new ArrayList<T>();
						int tmpIndex = 0;
						int totalRecord = query.list().size();
						if (totalRecord != 0) {
							page.setPageSize(pageSize);
							page.setTotalRecord(totalRecord);
							page.countTotalPage();
							// 设置第几页
							page.setIndex(index);
							if (index < 1) {
								tmpIndex = 1;
							}
							if (index > page.getTotalPage()) {
								tmpIndex = page.getTotalPage();
							}
							int firstResult = (tmpIndex - 1) * pageSize;
							query.setFirstResult(firstResult);
							query.setMaxResults(tmpIndex);
							results = (List<T>) query.list();
							page.setResults(results);
							page.setHasPreviousAndNext();
						}
						res.add(page);
						return res;
					}

				});
		return (Page<T>) pageList.get(0);
	}

	/**
	 * 通过带参数params的sql语句，将查询结果封装为entityClass类 并按pageSize分页，返回第index页
	 * 
	 * @param entityClass
	 *            所要封装的类
	 * @param sql
	 *            带参数的sql语句
	 * @param pageSize
	 *            页面大小
	 * @param index
	 *            页码
	 * @param params
	 *            参数
	 * @return page 页面
	 */
	public <T> Page<T> findPageBySQL(final Class<T> entityClass,
			final String sql, final int pageSize, final int index,
			final Map<String, Object> params) {
		List<Page<T>> pageList = hibernateTemplate
				.executeFind(new HibernateCallback() {

					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						List res = new ArrayList(1);
						Page<T> page = new Page<T>();
						Query query = session.createSQLQuery(sql).addEntity(
								entityClass);
						Iterator<String> iterator = params.keySet().iterator();
						List<T> results = new ArrayList<T>();
						int tmpIndex = 0;
						while (iterator.hasNext()) {
							String key = iterator.next();
							query.setParameter(key, params.get(key));
						}
						int totalRecord = query.list().size();
						if (totalRecord != 0) {
							page.setPageSize(pageSize);
							page.setTotalRecord(totalRecord);
							page.countTotalPage();
							if (index < 1) {
								tmpIndex = 1;
							}
							if (index > page.getTotalPage()) {
								tmpIndex = page.getTotalPage();
							}
							int firstResult = (tmpIndex - 1) * pageSize;
							query.setFirstResult(firstResult);
							query.setMaxResults(pageSize);
							results = (List<T>) query.list();
							page.setResults(results);
							page.setIndex(tmpIndex);
							page.setHasPreviousAndNext();
						}
						res.add(page);
						return res;
					}
				});

		return (Page<T>) pageList.get(0);
	}

	/**
	 * 通过完整的hql语句查询一条记录并返回
	 * 
	 * @param hql
	 *            完整的hql语句
	 * @return result 结果
	 */
	@Override
	public <T> T queryOneByHQL(final String hql) {
		T result = (T) hibernateTemplate.execute(new HibernateCallback() {

			@Override
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session.createQuery(hql);
				return (T) query.uniqueResult();
			}

		});
		return result;
	}

	/**
	 * 通过带参数params的hql语句查询一条记录并返回
	 * 
	 * @param hql
	 *            带参数的hql语句
	 * @param params
	 *            参数
	 * @return result 结果
	 */
	@Override
	public <T> T queryOneByHQL(final String hql,
			final Map<String, Object> params) {
		T result = (T) hibernateTemplate.execute(new HibernateCallback() {

			@Override
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session.createQuery(hql);
				Iterator<String> iterator = params.keySet().iterator();
				while (iterator.hasNext()) {
					String key = iterator.next();
					query.setParameter(key, params.get(key));
				}
				return (T) query.uniqueResult();
			}

		});
		return result;
	}

	/**
	 * 通过完整的sql语句查询一条记录，并封装成entityClass类返回
	 * 
	 * @param entityClass
	 *            所要封装的类
	 * @param sql
	 *            完整的sql语句
	 */
	@Override
	public <T> T queryOneBySQL(final Class<T> entityClass, final String sql) {
		T result = (T) hibernateTemplate.execute(new HibernateCallback() {

			@Override
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				return (T) session.createSQLQuery(sql).addEntity(entityClass)
						.uniqueResult();
			}

		});
		return result;
	}

	/**
	 * 通过带参数params的sql语句查询一条记录，并封装成entityClass类返回
	 * 
	 * @param entityClass
	 *            所要封装的类
	 * @param sql
	 *            带参数的sql语句
	 * @param params
	 *            参数
	 */
	@Override
	public <T> T queryOneBySQL(final Class<T> entityClass, final String sql,
			final Map<String, Object> params) {

		T result = (T) hibernateTemplate.execute(new HibernateCallback() {

			@Override
			public Object doInHibernate(Session session)
					throws HibernateException, SQLException {
				Query query = session.createSQLQuery(sql)
						.addEntity(entityClass);
				Iterator<String> iterator = params.keySet().iterator();
				int tempNum = 0;
				while (iterator.hasNext()) {
					String key = iterator.next();
					query.setParameter(tempNum, params.get(key));
					tempNum++;
				}
				return (T) query.uniqueResult();
			}

		});
		return result;
	}

	/**
	 * 通过完整的hql语句查询一组记录并返回
	 * 
	 * @param hql
	 *            完整的hql语句
	 * @return results 结果集
	 */
	@Override
	public <T> List<T> queryListByHQL(final String hql) {
		List<T> results = hibernateTemplate
				.executeFind(new HibernateCallback() {

					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Query query = session.createQuery(hql);
						return query.list();
					}

				});
		return results;
	}

	/**
	 * 通过带参数params的hql语句查询一组记录并返回
	 * 
	 * @param hql
	 *            带参数的hql语句
	 * @param params
	 *            参数
	 * @return results 结果集
	 */
	@Override
	public <T> List<T> queryListByHQL(final String hql,
			final Map<String, Object> params) {
		List<T> results = hibernateTemplate
				.executeFind(new HibernateCallback() {

					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Query query = session.createQuery(hql);
						Iterator<String> iterator = params.keySet().iterator();
						while (iterator.hasNext()) {
							String key = iterator.next();
							query.setParameter(key, params.get(key));
						}
						return query.list();
					}

				});
		return results;
	}

	/**
	 * 通过完整的sql语句查询一组记录，并封装成entityClass类返回
	 * 
	 * @param entityClass
	 *            所要封装的类
	 * @param sql
	 *            完整的sql语句
	 */
	@Override
	public <T> List<T> queryListBySQL(final Class<T> entityClass,
			final String sql) {
		List<T> results = hibernateTemplate
				.executeFind(new HibernateCallback() {

					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						return session.createSQLQuery(sql)
								.addEntity(entityClass).list();
					}

				});
		return results;
	}

	/**
	 * 通过带参数params的sql语句查询一组记录，并封装成entityClass类返回
	 * 
	 * @param entityClass
	 *            所要封装的类
	 * @param sql
	 *            完整的sql语句
	 * @param params
	 *            参数
	 */
	@Override
	public <T> List<T> queryListBySQL(final Class<T> entityClass,
			final String sql, final Map<String, Object> params) {
		List<T> results = hibernateTemplate
				.executeFind(new HibernateCallback() {

					@Override
					public Object doInHibernate(Session session)
							throws HibernateException, SQLException {
						Query query = session.createSQLQuery(sql).addEntity(
								entityClass);
						Iterator<String> iterator = params.keySet().iterator();
						int tempNum = 0;
						while (iterator.hasNext()) {
							String key = iterator.next();
							query.setParameter(tempNum, params.get(key));
							tempNum++;
						}
						return query.list();
					}

				});
		return results;
	}

	@Override
	public void saveOrUpdate(Object obj) {
		getHibernateTemplate().saveOrUpdate(obj);
	}

	@Override
	public void saveOrUpdateAll(List<Object> objs) {
		getHibernateTemplate().saveOrUpdateAll(objs);
	}

	@SuppressWarnings("unchecked")
	@Override
	public Object get(Class clazz, long id) {
		return getHibernateTemplate().get(clazz, id);
	}

Page对象：

import java.util.List;

public class Page<T> {
	private int index;//当前页码
	private int pageSize;//每页大小
	private int totalRecord;//总记录数
	private int totalPage;//总页数?
    private boolean hasNextPage;//是否有后一页
    private boolean hasPreviousPage;//是否有前一页
	List<T> results;//查询结果
	public Page(int index, int maxSize, int totalRecord, int totalPage,
			List<T> results) {
		super();
		this.index = index;
		this.pageSize = maxSize;
		this.totalRecord = totalRecord;
		this.totalPage = totalPage;
		this.results = results;
		if(this.index<2){
			hasPreviousPage=false;
		}else{
			hasPreviousPage=true;
		}
		if(this.index<totalPage){
			hasNextPage = true;
		}else{
			hasNextPage = false;
		}
	}
	public void setHasPreviousAndNext(){
		if(this.index<2){
			hasPreviousPage=false;
		}else{
			hasPreviousPage=true;
		}
		if(this.index<totalPage){
			hasNextPage = true;
		}else{
			hasNextPage = false;
		}
	}
	
	public Page() {
		super();
	}
	public int getIndex() {
		if (index == 0) {
			index = 1;
		}
		return index;
	}
	public void setIndex(int index) {
		this.index = index;
	}
	public int getPageSize() {
		return pageSize;
	}
	public void setPageSize(int maxSize) {
		this.pageSize = maxSize;
	}
	public int getTotalRecord() {
		return totalRecord;
	}
	public void setTotalRecord(int totalRecord) {
		this.totalRecord = totalRecord;
	}
	public int getTotalPage() {
		return totalPage;
	}
	public void setTotalPage(int totalPage) {
		this.totalPage = totalPage;
	}
	public List<T> getResults() {
		return results;
	}
	public void setResults(List<T> results) {
		this.results = results;
	}
	
	
	public boolean isHasNextPage() {
		return hasNextPage;
	}
	public void setHasNextPage(boolean hasNextPage) {
		this.hasNextPage = hasNextPage;
	}
	public boolean isHasPreviousPage() {
		return hasPreviousPage;
	}
	public void setHasPreviousPage(boolean hasPreviousPage) {
		this.hasPreviousPage = hasPreviousPage;
	}
	public int countTotalPage(){
		int total = totalRecord % pageSize == 0 ? totalRecord/pageSize : totalRecord/pageSize+1;
		this.setTotalPage(total);
	    return total;
	}
	public int getStartIndex() {
		return (getIndex()-1) * pageSize + 1;
	}
	public int getEndIndex() {
		if (getTotalRecord() > (getIndex() * pageSize)) {
			return getIndex() * pageSize;
		}else {
			return getTotalRecord();
		}
	}
}