关于dao层的封装和前端分页的结合（文章有点长，耐心点哦）

任何一个封装讲究的是，实用，多状态。
Action：

　　　任何一个Action继承分页有关参数类PageManage，自然考虑的到分页效果，我们必须定义下几个分页的参数。并根据这个参数进行查值。

　　　　然后在继承ServiceManage，ServiceManage类是用来存放共用的东西：response，重要的是Service的get set

具体讲一下PageManage，

totalPages;//总页数

totalRecord;//总记录数

showRecordNum=DEFAULT_PAGE_NUM;//每页显示记录数

showPageNum;//当前页显示的记录数量

public class PageManage extends ServiceManage{

/**
 * 分页的一些参数
 * @author sl
 */
private static final long serialVersionUID = 1L;

// 以下三个参数是分页需返回
// protected int currentPage = 1; // 当前页数
protected int totalPages; // 总页数
protected int totalRecord; // 总记录数
protected int pageNum = 1; // 当前页数

//默认每页的数量
protected int numPerPage = 20; 

protected PageUtil pageUtil(int totalRecord_) {
return new PageUtil(pageNum, totalRecord_, numPerPage);
}

        //一些getset方法
public int getTotalPages() {
return totalPages;
}
public void setTotalPages(int totalPages) {
this.totalPages = totalPages;
}
public int getTotalRecord() {
return totalRecord;
}
public void setTotalRecord(int totalRecord) {
this.totalRecord = totalRecord;
}
public int getPageNum() {
return pageNum;
}
public void setPageNum(int pageNum) {
this.pageNum = pageNum;
}
public int getNumPerPage() {
return numPerPage;
}
public void setNumPerPage(int numPerPage) {
this.numPerPage = numPerPage;
}

}

public class PageManage extends ServiceManage{

/**
 * 分页的一些参数
 * @author sl
 */
private static final long serialVersionUID = 1L;

// 以下三个参数是分页需返回
// protected int currentPage = 1; // 当前页数
protected int totalPages; // 总页数
protected int totalRecord; // 总记录数
protected int pageNum = 1; // 当前页数

//默认每页的数量
protected int numPerPage = 20; 

protected PageUtil pageUtil(int totalRecord_) {
return new PageUtil(pageNum, totalRecord_, numPerPage);
}

        //一些getset方法
public int getTotalPages() {
return totalPages;
}
public void setTotalPages(int totalPages) {
this.totalPages = totalPages;
}
public int getTotalRecord() {
return totalRecord;
}
public void setTotalRecord(int totalRecord) {
this.totalRecord = totalRecord;
}
public int getPageNum() {
return pageNum;
}
public void setPageNum(int pageNum) {
this.pageNum = pageNum;
}
public int getNumPerPage() {
return numPerPage;
}
public void setNumPerPage(int numPerPage) {
this.numPerPage = numPerPage;
}

}

其中涉及到的 PageUtil，这就分页的参数设置，和进行分页功能的一些逻辑判断，逻辑变动。

PageUtil：

PageUtil(Integer currentPage,Integer totalRecord,int showRecordNum)这个定义了一个page 以后调用就这个。

//分页用到的基本两个参数：1.总的记录条数 2.每页的记录条数

DEFAULT_CURRENT=1; //默认显示第一页

DEFAULT_PAGE_NUM=20;//默认显示20条记录

pageFirRecord=0;//当前页第一条记录

currentPage=1;//当前页数

totalPages;//总页数

totalRecord;//总记录数

showRecordNum=DEFAULT_PAGE_NUM;//每页显示记录数

showPageNum;//当前页显示的记录数量

prePage=1;

nexePage=1;

public class PageUtil{
//分页用到的基本两个参数：1.总的记录条数  2.每页的记录条数
//public static final Integer DEFAULT_CURRENT=1; //默认显示第一页
public static final Integer DEFAULT_PAGE_NUM=20;//默认显示20条记录

protected Integer pageFirRecord=0;//当前页第一条记录
protected Integer currentPage=1;//当前页数
protected Integer totalPages;//总页数
protected Integer totalRecord;//总记录数
protected Integer showRecordNum=DEFAULT_PAGE_NUM;//每页显示记录数
protected Integer showPageNum;//当前页显示的记录数量
protected Integer prePage=1;
protected Integer nexePage=1;
public PageUtil(){

}

public PageUtil(Integer currentPage,Integer totalRecord){//两个参数，一个是当前页数，一个是总页数

this.setTotalRecord(totalRecord);//调用set()方法来将参数赋值
this.setTotalPages();
this.setCurrentPage(currentPage);

this.setShowPageNum();
this.setPageFirRecord();
this.setPrePage();
this.setNexePage();
}
/**
 * 重载
 * @param currentPage
 * @param totalRecord
 * @param showRecordNum
 */
public PageUtil(Integer currentPage,Integer totalRecord,int showRecordNum){   //showRecordNum：为当前页的总记录条数

this.setTotalRecord(totalRecord);
this.setShowRecordNum(showRecordNum);
this.setTotalPages();
this.setCurrentPage(currentPage);

this.setShowPageNum();
this.setPageFirRecord();

this.setPrePage();//计算前一页页码
this.setNexePage();//计算下一页页码
}
public Integer getPrePage() {
return prePage;
}
public void setPrePage() {//设置前一页的页码
this.prePage = currentPage-1;//为当前页数减1
}

public Integer getNexePage() {
return nexePage;
}
public void setNexePage() {

if(currentPage==totalPages){  //如果当前页码为总页码，即最后一页
this.nexePage = 0;//返回0
}else{
this.nexePage = currentPage+1;//当前页加1
}
if(totalPages==0){//如果总页数为0，怎么返回0；
this.nexePage = 0;
}
}

public Integer getShowPageNum() {//返回当前页显示的记录数量
return showPageNum;
}
public void setShowPageNum() {//当前页显示的记录数量
if(currentPage*showRecordNum-totalRecord>0){//当前页数*每页显示的条数—总的记录条数>0 表示现在已经是最后一页了
this.showPageNum = totalRecord-(currentPage-1)*showRecordNum;
}else{
this.showPageNum=showRecordNum;
}

}

public Integer getShowRecordNum() {//返回每页的记录条数
return showRecordNum;
}
public void setShowRecordNum(Integer showRecordNum) {
this.showRecordNum = showRecordNum;
}

public Integer getTotalPages() {//返回总的页数
return totalPages;
}
public void setTotalPages() {//计算总页数
if(totalRecord%showRecordNum==0){
this.totalPages = totalRecord/showRecordNum;
}else{
this.totalPages = totalRecord/showRecordNum+1;
}

}

public Integer getTotalRecord() {//返回总的记录条数
return totalRecord;
}
public void setTotalRecord(Integer totalRecord) {
this.totalRecord = totalRecord;
}

public Integer getCurrentPage() {//返回当前的页数
return currentPage;
}
public void setCurrentPage(Integer currentPage) {

if(currentPage==0||currentPage<0){
currentPage=1;
}
if(currentPage>totalPages&&totalPages!=0){
this.currentPage=totalPages;//当前页大于总页数时为总页数,并且保证不存在记录时不出错，即totalPages!=0
}else if(totalPages==0){
this.currentPage=1;
}else{
this.currentPage = currentPage;
}
}

public void setPageFirRecord() {//第一条记录所在集合的标号，比实际排数少一
this.pageFirRecord = (getCurrentPage()-1)*showRecordNum;//第一条记录为当前页的前一页*每页显示的记录数
}
public Integer getPageFirRecord() {//返回第一条记录
return pageFirRecord;
}

}

public class PageUtil{
//分页用到的基本两个参数：1.总的记录条数  2.每页的记录条数
//public static final Integer DEFAULT_CURRENT=1; //默认显示第一页
public static final Integer DEFAULT_PAGE_NUM=20;//默认显示20条记录

protected Integer pageFirRecord=0;//当前页第一条记录
protected Integer currentPage=1;//当前页数
protected Integer totalPages;//总页数
protected Integer totalRecord;//总记录数
protected Integer showRecordNum=DEFAULT_PAGE_NUM;//每页显示记录数
protected Integer showPageNum;//当前页显示的记录数量
protected Integer prePage=1;
protected Integer nexePage=1;
public PageUtil(){

}

public PageUtil(Integer currentPage,Integer totalRecord){//两个参数，一个是当前页数，一个是总页数

this.setTotalRecord(totalRecord);//调用set()方法来将参数赋值
this.setTotalPages();
this.setCurrentPage(currentPage);

this.setShowPageNum();
this.setPageFirRecord();
this.setPrePage();
this.setNexePage();
}
/**
 * 重载
 * @param currentPage
 * @param totalRecord
 * @param showRecordNum
 */
public PageUtil(Integer currentPage,Integer totalRecord,int showRecordNum){   //showRecordNum：为当前页的总记录条数

this.setTotalRecord(totalRecord);
this.setShowRecordNum(showRecordNum);
this.setTotalPages();
this.setCurrentPage(currentPage);

this.setShowPageNum();
this.setPageFirRecord();

this.setPrePage();//计算前一页页码
this.setNexePage();//计算下一页页码
}
public Integer getPrePage() {
return prePage;
}
public void setPrePage() {//设置前一页的页码
this.prePage = currentPage-1;//为当前页数减1
}

public Integer getNexePage() {
return nexePage;
}
public void setNexePage() {

if(currentPage==totalPages){  //如果当前页码为总页码，即最后一页
this.nexePage = 0;//返回0
}else{
this.nexePage = currentPage+1;//当前页加1
}
if(totalPages==0){//如果总页数为0，怎么返回0；
this.nexePage = 0;
}
}

public Integer getShowPageNum() {//返回当前页显示的记录数量
return showPageNum;
}
public void setShowPageNum() {//当前页显示的记录数量
if(currentPage*showRecordNum-totalRecord>0){//当前页数*每页显示的条数—总的记录条数>0 表示现在已经是最后一页了
this.showPageNum = totalRecord-(currentPage-1)*showRecordNum;
}else{
this.showPageNum=showRecordNum;
}

}

public Integer getShowRecordNum() {//返回每页的记录条数
return showRecordNum;
}
public void setShowRecordNum(Integer showRecordNum) {
this.showRecordNum = showRecordNum;
}

public Integer getTotalPages() {//返回总的页数
return totalPages;
}
public void setTotalPages() {//计算总页数
if(totalRecord%showRecordNum==0){
this.totalPages = totalRecord/showRecordNum;
}else{
this.totalPages = totalRecord/showRecordNum+1;
}

}

public Integer getTotalRecord() {//返回总的记录条数
return totalRecord;
}
public void setTotalRecord(Integer totalRecord) {
this.totalRecord = totalRecord;
}

public Integer getCurrentPage() {//返回当前的页数
return currentPage;
}
public void setCurrentPage(Integer currentPage) {

if(currentPage==0||currentPage<0){
currentPage=1;
}
if(currentPage>totalPages&&totalPages!=0){
this.currentPage=totalPages;//当前页大于总页数时为总页数,并且保证不存在记录时不出错，即totalPages!=0
}else if(totalPages==0){
this.currentPage=1;
}else{
this.currentPage = currentPage;
}
}

public void setPageFirRecord() {//第一条记录所在集合的标号，比实际排数少一
this.pageFirRecord = (getCurrentPage()-1)*showRecordNum;//第一条记录为当前页的前一页*每页显示的记录数
}
public Integer getPageFirRecord() {//返回第一条记录
return pageFirRecord;
}

}

然后讲Service层：

只要继承一个父类CURDS；CURDS类里面的方法和封装好的DAO层hibernate带分页的分装方法一致

随便一个service层接口：

一般的方法自然都在CURDS有了。以下是写一个特殊的方法

　　List<AuthApply> getApplie():

所以一般来说，CURDS里面的方法够用了。

public interface AuthApplyS extends CURDS<AuthApply>{

/**
 * 根据认证的类型与状态获取相应的认证申请
 * */
public List<AuthApply> getApplie(String type, String status, Integer memberId);
}

CURDS：里面的方法是Service共用的方法

/**

* 根据条件集合大小,这里使用java 1.5引入的新特性：可变参数

* */

public int getNums(Object ...args);

/**

* 根据条件集合

* */

public List<T> getList(PageUtil pageUtil, Object ...args);

/**

* 保存对象

* */

public T makePersitent(T entity);

/**

* 根本编号获得对象

* */

　　　　public T findById(Integer id);

public interface CURDS<T> {
/**
 * 根据条件集合大小,这里使用java 1.5引入的新特性：可变参数
 * */
public int getNums(Object ...args);
/**
 * 根据条件集合
 * */
public List<T> getList(PageUtil pageUtil, Object ...args);
/**
 * 保存对象
 * */
public T makePersitent(T entity);
/**
 * 根本编号获得对象
 * */
public T findById(Integer id);
}

public interface CURDS<T> {
/**
 * 根据条件集合大小,这里使用java 1.5引入的新特性：可变参数
 * */
public int getNums(Object ...args);
/**
 * 根据条件集合
 * */
public List<T> getList(PageUtil pageUtil, Object ...args);
/**
 * 保存对象
 * */
public T makePersitent(T entity);
/**
 * 根本编号获得对象
 * */
public T findById(Integer id);
}

service层实现：

共用的CURDS接口里面的方法里面如果要用就实现，不用不需要

　DAOManage：只是DAO接口的注入

public class AuthApplySI extends DAOManage implements AuthApplyS{

public AuthApply findById(Integer id) {
return authApplyD.findById(id);
}

public List<AuthApply> getList(PageUtil pageUtil, Object... args) {
return authApplyD.findByPage(getHQL((String)args[0]), pageUtil.getPageFirRecord(), pageUtil.getShowRecordNum());
}

public int getNums(Object... args) {
return authApplyD.findByPage(getHQL((String)args[0]), 0, 0).size();
}

private String getHQL(String type){
StringBuffer hql = new StringBuffer("from AuthApply as auth where auth.authType = '"+type+"'");
hql.append(" and auth.status = '"+AuthCon.SUBMIT_AUTH+"'");
return hql.toString();
}

public AuthApply makePersitent(AuthApply entity) {
return authApplyD.makePersitent(entity);
}

public List<AuthApply> getApplie(String type, String status, Integer memberId) {
StringBuffer hql = new StringBuffer("from AuthApply as auth where auth.authType = '"+type+"' and auth.status = '"+status+"'");
if(memberId != null){
hql.append(" and auth.member.memberId = "+memberId);
}
return authApplyD.findByPage(hql.toString(), 0, 0).size() == 0? null: authApplyD.findByPage(hql.toString(), 0, 0);
}

}

public class AuthApplySI extends DAOManage implements AuthApplyS{

public AuthApply findById(Integer id) {
return authApplyD.findById(id);
}

public List<AuthApply> getList(PageUtil pageUtil, Object... args) {
return authApplyD.findByPage(getHQL((String)args[0]), pageUtil.getPageFirRecord(), pageUtil.getShowRecordNum());
}

public int getNums(Object... args) {
return authApplyD.findByPage(getHQL((String)args[0]), 0, 0).size();
}

private String getHQL(String type){
StringBuffer hql = new StringBuffer("from AuthApply as auth where auth.authType = '"+type+"'");
hql.append(" and auth.status = '"+AuthCon.SUBMIT_AUTH+"'");
return hql.toString();
}

public AuthApply makePersitent(AuthApply entity) {
return authApplyD.makePersitent(entity);
}

public List<AuthApply> getApplie(String type, String status, Integer memberId) {
StringBuffer hql = new StringBuffer("from AuthApply as auth where auth.authType = '"+type+"' and auth.status = '"+status+"'");
if(memberId != null){
hql.append(" and auth.member.memberId = "+memberId);
}
return authApplyD.findByPage(hql.toString(), 0, 0).size() == 0? null: authApplyD.findByPage(hql.toString(), 0, 0);
}

}

下面看一下 DAO层的封装吧。

经典的终于来了。前面注意分页的那些类：

首先因为有一些是特殊的方法，所以我们也要定义

AuthApplyD接口：很简单吧。

AuthApply 是bean类

GenericDAO 这继承的父类就是我们的封装。



public interface AuthApplyD extends GenericDAO<AuthApply>{

}

AuthApplyD实现类：

　　super(AuthApply.class);这个方法很重要，调用的是GenericHibernateDAO的方法，而将Bean类传到DAO层。

public class AuthApplyDI extends GenericHibernateDAO<AuthApply> implements
AuthApplyD{

public AuthApplyDI() {
super(AuthApply.class);//这super，就是调用父类的构造方法
}

}

public class AuthApplyDI extends GenericHibernateDAO<AuthApply> implements
AuthApplyD{

public AuthApplyDI() {
super(AuthApply.class);//这super，就是调用父类的构造方法
}

}

GenericDAO接口封装：

这才是我想说的经典

　　

/**

* 通过ID获得实体对象

* @param id实体对象的标识符

* @return 该主键值对应的实体对象

T findById(Integer id);

T findById(Long id);

/**

* 将实体对象持久化

* @param entity 需要进行持久化操作的实体对象

* @return 持久化的实体对象

T makePersitent(T entity);

/**

* 将实体变为瞬态

* @param entity需要转变为瞬态的实体对象

void makeTransient(T entity);

/**

* 将一系列的实体变为瞬态，使用本地sql

* @param hql

void makeTransientByIds(String sql);

/**

* 使用hql语句进行分页操作

* @param hql

* @param offset第一条记录索引

* @param pageSize每页需要显示的记录数

* @return查询的记录

List<T> findByPage(final String hql,final int offset,final int pageSize);

/**

* 使用hql 语句进行分页查询操作

* @param hql 需要查询的hql语句

* @param value 如果hql有一个参数需要传入，value就是传入的参数

* @param offset 第一条记录索引

* @param pageSize 每页需要显示的记录数

* @return 当前页的所有记录

List<T> findByPage(final String hql , final Object value ,

final int offset, final int pageSize);

/**

* 使用hql 语句进行分页查询操作

* @param hql 需要查询的hql语句

* @param values 如果hql有一个参数需要传入，value就是传入的参数

* @param offset 第一条记录索引

* @param pageSize 每页需要显示的记录数

* @return 当前页的所有记录

List<T> findByPage(final String hql, final Object[] values,

final int offset, final int pageSize);

/**

* 使用sql 语句进行分页查询操作

* @param sql

* @param offset

* @param pageSize

* @return

List<T> findByPageSQL(final String sql,

final int offset, final int pageSize);

/**

* 根据语句查找总数

* @param hql hql语句

* @return 对应的数目

Integer getCount(String hql);

void updateObj(final String hql,final Object[] values);

/**

* 更新

* */

void updateEntity(T entity);

/**

* 返回list集合

* */

@SuppressWarnings("unchecked")

public List getListDataByHQL(String hql);

/**

* hql查询单个字段

* */

public List<Object> findSingleDataByHQL(String hql);

/**

* hql查询多个字段

* */

public List<Object[]> findSomeDataByHQL(String hql);

}

/**
 *
 * @param <T>
 */

public interface GenericDAO <T>{
/**
 * 通过ID获得实体对象
 *
 * @param id实体对象的标识符
 * @return 该主键值对应的实体对象
 */
T findById(Integer id);
T findById(Long id);
/**
 * 将实体对象持久化
 *
 * @param entity 需要进行持久化操作的实体对象
 * @return 持久化的实体对象
 */
T makePersitent(T entity); 

/**
 * 将实体变为瞬态
 *
 * @param entity需要转变为瞬态的实体对象
 */
void makeTransient(T entity);

/**
 * 将一系列的实体变为瞬态，使用本地sql
 *
 * @param hql
 */
void makeTransientByIds(String sql);

/**
 *
 * 使用hql语句进行分页操作
 *
 * @param hql
 * @param offset第一条记录索引
 * @param pageSize每页需要显示的记录数
 * @return查询的记录
 */
List<T> findByPage(final String hql,final int offset,final int pageSize);

/**
 * 使用hql 语句进行分页查询操作
 *
 * @param hql 需要查询的hql语句
 * @param value 如果hql有一个参数需要传入，value就是传入的参数
 * @param offset 第一条记录索引
 * @param pageSize 每页需要显示的记录数
 * @return 当前页的所有记录
 */
List<T> findByPage(final String hql , final Object value ,
 final int offset, final int pageSize);

/**
 * 使用hql 语句进行分页查询操作
 *
 * @param hql 需要查询的hql语句
 * @param values 如果hql有一个参数需要传入，value就是传入的参数
 * @param offset 第一条记录索引
 * @param pageSize 每页需要显示的记录数
 * @return 当前页的所有记录
 */
List<T> findByPage(final String hql, final Object[] values,
 final int offset, final int pageSize);

/**
 * 使用sql 语句进行分页查询操作
 *
 * @param sql
 * @param offset
 * @param pageSize
 * @return
 */
List<T> findByPageSQL(final String sql,
 final int offset, final int pageSize);

/**
 * 根据语句查找总数
 * @param hql hql语句
 * @return 对应的数目
 */
Integer getCount(String hql);

void updateObj(final String hql,final Object[] values);
/**
 * 更新
 * */
void updateEntity(T entity);
/**
 * 返回list集合
 * */
@SuppressWarnings("unchecked")
public List getListDataByHQL(String hql);
/**
 * hql查询单个字段
 * */
public List<Object> findSingleDataByHQL(String hql);
/**
 * hql查询多个字段
 * */
public List<Object[]> findSomeDataByHQL(String hql);
}

/**
 *
 * @param <T>
 */

public interface GenericDAO <T>{
/**
 * 通过ID获得实体对象
 *
 * @param id实体对象的标识符
 * @return 该主键值对应的实体对象
 */
T findById(Integer id);
T findById(Long id);
/**
 * 将实体对象持久化
 *
 * @param entity 需要进行持久化操作的实体对象
 * @return 持久化的实体对象
 */
T makePersitent(T entity); 

/**
 * 将实体变为瞬态
 *
 * @param entity需要转变为瞬态的实体对象
 */
void makeTransient(T entity);

/**
 * 将一系列的实体变为瞬态，使用本地sql
 *
 * @param hql
 */
void makeTransientByIds(String sql);

/**
 *
 * 使用hql语句进行分页操作
 *
 * @param hql
 * @param offset第一条记录索引
 * @param pageSize每页需要显示的记录数
 * @return查询的记录
 */
List<T> findByPage(final String hql,final int offset,final int pageSize);

/**
 * 使用hql 语句进行分页查询操作
 *
 * @param hql 需要查询的hql语句
 * @param value 如果hql有一个参数需要传入，value就是传入的参数
 * @param offset 第一条记录索引
 * @param pageSize 每页需要显示的记录数
 * @return 当前页的所有记录
 */
List<T> findByPage(final String hql , final Object value ,
 final int offset, final int pageSize);

/**
 * 使用hql 语句进行分页查询操作
 *
 * @param hql 需要查询的hql语句
 * @param values 如果hql有一个参数需要传入，value就是传入的参数
 * @param offset 第一条记录索引
 * @param pageSize 每页需要显示的记录数
 * @return 当前页的所有记录
 */
List<T> findByPage(final String hql, final Object[] values,
 final int offset, final int pageSize);

/**
 * 使用sql 语句进行分页查询操作
 *
 * @param sql
 * @param offset
 * @param pageSize
 * @return
 */
List<T> findByPageSQL(final String sql,
 final int offset, final int pageSize);

/**
 * 根据语句查找总数
 * @param hql hql语句
 * @return 对应的数目
 */
Integer getCount(String hql);

void updateObj(final String hql,final Object[] values);
/**
 * 更新
 * */
void updateEntity(T entity);
/**
 * 返回list集合
 * */
@SuppressWarnings("unchecked")
public List getListDataByHQL(String hql);
/**
 * hql查询单个字段
 * */
public List<Object> findSingleDataByHQL(String hql);
/**
 * hql查询多个字段
 * */
public List<Object[]> findSomeDataByHQL(String hql);
}

GenericHibernateDAO实现类：

public class GenericHibernateDAO<T> extends HibernateDaoSupport
implements GenericDAO<T>{

private Class<T> persistentClass;

public GenericHibernateDAO(Class<T> persistentClass){
this.persistentClass=persistentClass;
}

public Class<T> getPersistentClass(){
return persistentClass;
}

public T findById(Integer id) {
return (T)getHibernateTemplate().get(getPersistentClass(), id);
}

@SuppressWarnings("unchecked")
public List<T> findByPage(final String hql,
 final int offset, final int pageSize){
if(hql == null){
return new ArrayList<T>();
}
List<T> list= getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(final Session session)
throws HibernateException, SQLException{
Query query=session.createQuery(hql);
if(!(offset==0 && pageSize==0)){
query.setFirstResult(offset).setMaxResults(pageSize);
}
List<T> result = query.list();
return result;
}
});
return list;
}

@SuppressWarnings("unchecked")
public List findByPageSQL(final String sql,
 final int offset, final int pageSize){
List list= getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(final Session session)
throws HibernateException, SQLException{
Query query=session.createSQLQuery(sql);
if(!(offset==0 && pageSize==0)){
query.setFirstResult(offset).setMaxResults(pageSize);
}
List result = query.list();
return result;
}
});
return list;
}

@SuppressWarnings("unchecked")
public List<T> findByPage(final String hql, final Object value,
final int offset, final int pageSize) {
List<T> list = getHibernateTemplate().executeFind(new HibernateCallback()
{
public Object doInHibernate(Session session)
throws HibernateException, SQLException
{
Query query=session.createQuery(hql).setParameter(0, value);
if(!(offset==0 && pageSize==0)){
query.setFirstResult(offset).setMaxResults(pageSize);
}
List<T> result = query.list();
return result;
}
});
return list;
}

@SuppressWarnings("unchecked")
public List<T> findByPage(final String hql, final Object[] values, final int offset,
final int pageSize) {
List<T> list = getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(Session session)
throws HibernateException, SQLException{
Query query=session.createQuery(hql);
for (int i = 0 ; i < values.length ; i++){
query.setParameter( i, values[i]);
}
if(!(offset==0 && pageSize==0)){
query.setFirstResult(offset).setMaxResults(pageSize);
}
List<T> result = query.list();
return result;
}
});
return list;
}

@SuppressWarnings("unchecked")
public void updateObj(final String hql, final Object[] values) {
getHibernateTemplate().execute(new HibernateCallback(){
public Object doInHibernate(Session session)
throws HibernateException, SQLException{
Query query=session.createQuery(hql);
for(int i=0;i<values.length;i++){
query.setParameter( i, values[i]);
}
query.executeUpdate();
return null;
}
});
}

public Integer getCount(String hql) {
Integer count;
//iterate方法与list方法的区别是list取出全部，iterator取出主键，迭代的时候才取出数据
count = ((Long)getHibernateTemplate().iterate(hql).next()).intValue();
System.out.println("大小"+ count);
return count;
}

public T makePersitent(T entity) {
getHibernateTemplate().saveOrUpdate(entity);
return entity;
}

public void makeTransient(T entity) {
getHibernateTemplate().delete(entity);
}

@SuppressWarnings("unchecked")
public void makeTransientByIds(final String sql) {
getHibernateTemplate().execute(new HibernateCallback(){
public Object doInHibernate(Session session)
throws HibernateException, SQLException{
Query query=session.createQuery(sql);
query.executeUpdate();
return null;
}
});
}

public T findById(Long id) {
return (T) getHibernateTemplate().get(getPersistentClass(), id);
}

public void updateEntity(T entity) {
this.getHibernateTemplate().update(entity);
}
@SuppressWarnings("unchecked")
public List getListDataByHQL(String hql) {
return getHibernateTemplate().find(hql);
}

/**
 * hql查询单个字段
 * */
@SuppressWarnings("unchecked")
public List<Object> findSingleDataByHQL(String hql) {
return getHibernateTemplate().find(hql);
}
/**
 * hql查询多个字段
 * */
@SuppressWarnings("unchecked")
public List<Object[]> findSomeDataByHQL(String hql) {
return getHibernateTemplate().find(hql);
}
}

public class GenericHibernateDAO<T> extends HibernateDaoSupport
implements GenericDAO<T>{

private Class<T> persistentClass;

public GenericHibernateDAO(Class<T> persistentClass){
this.persistentClass=persistentClass;
}

public Class<T> getPersistentClass(){
return persistentClass;
}

public T findById(Integer id) {
return (T)getHibernateTemplate().get(getPersistentClass(), id);
}

@SuppressWarnings("unchecked")
public List<T> findByPage(final String hql,
 final int offset, final int pageSize){
if(hql == null){
return new ArrayList<T>();
}
List<T> list= getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(final Session session)
throws HibernateException, SQLException{
Query query=session.createQuery(hql);
if(!(offset==0 && pageSize==0)){
query.setFirstResult(offset).setMaxResults(pageSize);
}
List<T> result = query.list();
return result;
}
});
return list;
}

@SuppressWarnings("unchecked")
public List findByPageSQL(final String sql,
 final int offset, final int pageSize){
List list= getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(final Session session)
throws HibernateException, SQLException{
Query query=session.createSQLQuery(sql);
if(!(offset==0 && pageSize==0)){
query.setFirstResult(offset).setMaxResults(pageSize);
}
List result = query.list();
return result;
}
});
return list;
}

@SuppressWarnings("unchecked")
public List<T> findByPage(final String hql, final Object value,
final int offset, final int pageSize) {
List<T> list = getHibernateTemplate().executeFind(new HibernateCallback()
{
public Object doInHibernate(Session session)
throws HibernateException, SQLException
{
Query query=session.createQuery(hql).setParameter(0, value);
if(!(offset==0 && pageSize==0)){
query.setFirstResult(offset).setMaxResults(pageSize);
}
List<T> result = query.list();
return result;
}
});
return list;
}

@SuppressWarnings("unchecked")
public List<T> findByPage(final String hql, final Object[] values, final int offset,
final int pageSize) {
List<T> list = getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(Session session)
throws HibernateException, SQLException{
Query query=session.createQuery(hql);
for (int i = 0 ; i < values.length ; i++){
query.setParameter( i, values[i]);
}
if(!(offset==0 && pageSize==0)){
query.setFirstResult(offset).setMaxResults(pageSize);
}
List<T> result = query.list();
return result;
}
});
return list;
}

@SuppressWarnings("unchecked")
public void updateObj(final String hql, final Object[] values) {
getHibernateTemplate().execute(new HibernateCallback(){
public Object doInHibernate(Session session)
throws HibernateException, SQLException{
Query query=session.createQuery(hql);
for(int i=0;i<values.length;i++){
query.setParameter( i, values[i]);
}
query.executeUpdate();
return null;
}
});
}

public Integer getCount(String hql) {
Integer count;
//iterate方法与list方法的区别是list取出全部，iterator取出主键，迭代的时候才取出数据
count = ((Long)getHibernateTemplate().iterate(hql).next()).intValue();
System.out.println("大小"+ count);
return count;
}

public T makePersitent(T entity) {
getHibernateTemplate().saveOrUpdate(entity);
return entity;
}

public void makeTransient(T entity) {
getHibernateTemplate().delete(entity);
}

@SuppressWarnings("unchecked")
public void makeTransientByIds(final String sql) {
getHibernateTemplate().execute(new HibernateCallback(){
public Object doInHibernate(Session session)
throws HibernateException, SQLException{
Query query=session.createQuery(sql);
query.executeUpdate();
return null;
}
});
}

public T findById(Long id) {
return (T) getHibernateTemplate().get(getPersistentClass(), id);
}

public void updateEntity(T entity) {
this.getHibernateTemplate().update(entity);
}
@SuppressWarnings("unchecked")
public List getListDataByHQL(String hql) {
return getHibernateTemplate().find(hql);
}

/**
 * hql查询单个字段
 * */
@SuppressWarnings("unchecked")
public List<Object> findSingleDataByHQL(String hql) {
return getHibernateTemplate().find(hql);
}
/**
 * hql查询多个字段
 * */
@SuppressWarnings("unchecked")
public List<Object[]> findSomeDataByHQL(String hql) {
return getHibernateTemplate().find(hql);
}
}

希望首页能再次通过，我修改下。

总结：带分页功能的SSH整合，DAO层经典封装

　　考虑前台，一条线的传到后台，然后分工必须明确。

　　DAO层的封装，可见java底层的魅力。

时间： 2024-08-30 17:52:27

关于dao层的封装和前端分页的结合（文章有点长，耐心点哦）的相关文章

带分页功能的SSH整合，DAO层经典封装

任何一个封装讲究的是,使用,多状态.Action: 任何一个Action继承分页有关参数类PageManage,自然考虑的到分页效果,我们必须定义下几个分页的参数.并根据这个参数进行查值. 然后在继承ServiceManage,ServiceManage类是用来存放共用的东西:response,重要的是Service的get set 具体讲一下PageManage, totalPages;//总页数 totalRecord;//总记录数 showRecordNum=D

封装好的javascript前端分页插件pagination_javascript技巧

摘要: 最近在开发项目中又用到了前端分页,以前也做过,为了方便以后使用所以将他封装成第三方插件,不依赖任何库.网上已经有很多插件,问什么还要自己造轮子? 自己写的扩展性高不依赖任何库作为一次技术沉淀先看下效果图安装方法首先在页面中要载入css及js <link rel="stylesheet" href="dist/pagination.css"> <script src="dist/pagination.js"

Spring+Hibernate实现的DAO层公共类

此EntityDao接口与EntityDaoImpl实现类,可取代了我们平时写的UserDao,NewsDao,CompanyDao等等,可直接供Service层调用.其中实现类的代码如下: /** * Copyright 2009-1012 the original author or authors. * My Blog site: http://www.blogjava.net/rongxh7 */ package rong.common.dao; import java.io.Seria

ASP.NET MVC+EF框架+EasyUI实现权限管理系列(4)-业务逻辑层的封装

原文:ASP.NET MVC+EF框架+EasyUI实现权限管理系列(4)-业务逻辑层的封装 ASP.NET MVC+EF框架+EasyUI实现权限管系列 (开篇) (1):框架搭建 (2):数据库访问层的设计Demo (3):面向接口编程前言:前面几篇博客我们基本已经介绍完了搭建整个项目和数据库访问层以及一些业务逻辑层的实现,当然了,我们的数据库访问层这样还是可以在进行封装的,但是我到这里就行了吧,项目也不大,不需要那么麻烦的,那么我们今天开始介绍我们需要介绍的内容,那就是我

如何写出一个完全和Service层剥离的dao层？

问题描述如何写出一个完全和Service层剥离的dao层?不要在service层构造hql语句,完全只是传参数,dao层构造hql,如果换了别的持久化框架,那么只需要修改dao层就可以,service完全可以不动,这样体现出来低耦合的软件开发原则解决方案在Service层传来参数,使用Map传过来,然后在到层增加一个函数,专门负责在dao层生成hql语句,一般的函数都封装好了,基本要构造hql语句的,都是需要查询的,需要构造key=value形式的,所以map刚好符合,我在dao层就是这么

如果用纯JDBC做DAO层的话？

问题描述问下,如果用纯JDBC做DAO层的话?类中关联的对象在哪层设置进去好呢?在hibernate里的一对一对关系中,hibernate取的时候自动会将关联的对象同时取出来,然后设置进去,如果用JDBC,那要手动设置,但是,在哪层设置比较好呢,在service层还是控制层,还是dao层呢?望高手解答,谢谢解决方案解决方案二:DAO层解决方案三:感觉还是在DAO层比较好service只负责分配数据数据間的关系还是不让其干预好解决方案四:我觉得在dao层比较好,不过还要看具体的吧,看你用的是

android开发查询数据库的实现类和dao层

问题描述 android开发查询数据库的实现类和dao层之前开发的项目数据单机的吧,现在在公司要开发联网的项目,就用上了数据库,我就要写这前我写的实现类和接口,还有DBHelper,那是我做网站的时候用于查询数据库的,请问做app操作数据库和我之前写的一样么,写个DBHelper,实现类集成接口,增删查改写到实现类里.感觉这流程是不怎么熟悉啊解决方案 ActiveAndroid 一个andriod DB操作的开源库,很方便解决方案二: 你用ado比较好点----

Unitils+hibernate+Spring+PostgreSql做dao层测试遇到的错误

这两天看陈雄华的书<Spring3.0企业开发实战>17章做dao层的测试,由于使用postgreSql数据库,所以遇到了不少错误,很多问题百度都没找到答案,所以记录下来给遇到同样错误的童鞋做个参考.下面是我遇到的问题: 1.unitils目前还不支持Hibernate4,所以使用hibernate4的童鞋,要么换hibernate3要么自己用dbUnit做测试. 2.org.unitils.core.UnitilsException: Missing configuration for or

Spring配置事务在DAO层和业务逻辑层

Spring通过AOP实现声明式事务管理.通常通过TransactionProxyFactoryBean设置Spring事务代理.我们需要一个目标对象包装在事务代理中.这个目标对象一般是一个普通Java对象的bean.当我们定义TransactionProxyFactoryBean时,必须提供一个相关的 PlatformTransactionManager的引用和事务属性. 事务属性含有上面描述的事务定义. PlatformTransactionManager: HibernateTransac