任何一个封装讲究的是,使用,多状态。
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 = ; // 当前页数 //默认每页的数量
protected int numPerPage = ; 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条记录 protected Integer pageFirRecord=;//当前页第一条记录
protected Integer currentPage=;//当前页数
protected Integer totalPages;//总页数
protected Integer totalRecord;//总记录数
protected Integer showRecordNum=DEFAULT_PAGE_NUM;//每页显示记录数
protected Integer showPageNum;//当前页显示的记录数量
protected Integer prePage=;
protected Integer nexePage=;
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
} public Integer getNexePage() {
return nexePage;
}
public void setNexePage() { if(currentPage==totalPages){ //如果当前页码为总页码,即最后一页
this.nexePage = ;//返回0
}else{
this.nexePage = currentPage+;//当前页加1
}
if(totalPages==){//如果总页数为0,怎么返回0;
this.nexePage = ;
}
} public Integer getShowPageNum() {//返回当前页显示的记录数量
return showPageNum;
}
public void setShowPageNum() {//当前页显示的记录数量
if(currentPage*showRecordNum-totalRecord>){//当前页数*每页显示的条数—总的记录条数>0 表示现在已经是最后一页了
this.showPageNum = totalRecord-(currentPage-)*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==){
this.totalPages = totalRecord/showRecordNum;
}else{
this.totalPages = totalRecord/showRecordNum+;
} } 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==||currentPage<){
currentPage=;
}
if(currentPage>totalPages&&totalPages!=){
this.currentPage=totalPages;//当前页大于总页数时为总页数,并且保证不存在记录时不出错,即totalPages!=0
}else if(totalPages==){
this.currentPage=;
}else{
this.currentPage = currentPage;
}
} public void setPageFirRecord() {//第一条记录所在集合的标号,比实际排数少一
this.pageFirRecord = (getCurrentPage()-)*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);
}

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[]), pageUtil.getPageFirRecord(), pageUtil.getShowRecordNum());
} public int getNums(Object... args) {
return authApplyD.findByPage(getHQL((String)args[]), , ).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(), , ).size() == ? null: authApplyD.findByPage(hql.toString(), , );
} }

下面看一下 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,就是调用父类的构造方法
} }

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);
}
 
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== && pageSize==)){
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== && pageSize==)){
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(, value);
if(!(offset== && pageSize==)){
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 = ; i < values.length ; i++){
query.setParameter( i, values[i]);
}
if(!(offset== && pageSize==)){
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=;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底层的魅力。
共同开发,共同努力。

本文来自 泥沙砖瓦浆木匠 之笔。

秋日和煦不眼刺,燥气干爽流吾血。满屋墨气留纸上,暗里偷懒靠椅凳。忙时课上立马跑,闲是不知哪里去。纸上总归字太少,心中满是字母书。
  
                                          

SSH, 整合分页功能,连带DAO经典封装的更多相关文章

  1. poscms基于list标签实现的查询分页功能

    poscms系统本身有一个在查询页(search页面)实现的查询分页功能,基于系统封装的php函数dr_search_url() 但是今天的需求除了导航栏.列表页.详情页都实现查询功能外,关键是有两个 ...

  2. Java - 框架之 SSH 整合

                        代码获取 十四. ssh 整合1 - 包 1. Struts jar 包    - Struts-2.xx\apps\stutrs2-blank\WEB-INF ...

  3. 带分页功能的SSH整合,DAO层经典封装

    任何一个封装讲究的是,使用,多状态.Action:     任何一个Action继承分页有关参数类PageManage,自然考虑的到分页效果,我们必须定义下几个分页的参数.并根据这个参数进行查值. 然 ...

  4. 简单封装分页功能pageView.js

    分页是一个很简单,通用的功能.作为一个有经验的前端开发人员,有义务把代码中类似这样公共的基础性的东西抽象出来,一来是改善代码的整体质量,更重要的是为了将来做类似的功能或者类似的项目,能减少不必要的重复 ...

  5. DjangoRestFramework框架三种分页功能的实现 - 在DjangoStarter项目模板中封装

    前言 继续Django后端开发系列文章.刚好遇到一个分页的需求,就记录一下. Django作为一个"全家桶"型的框架,本身啥都有,分页组件也是有的,但默认的分页组件没有对API开发 ...

  6. 自己封装的JS分页功能[用于搭配后台使用]

    * 2016.7.03 修复bug,优化代码逻辑 * 2016.5.25 修复如果找不到目标对象的错误抛出. * 2016.5.11 修复当实际页数(pageNumber)小于生成的页码间隔数时的bu ...

  7. 三大框架SSH整合

    三大框架SSH整合 -------------------------------Spring整合Hibernate------------------------------- 一.为什么要整合Hi ...

  8. 夺命雷公狗---DEDECMS----33dedecms自定义搜索以及分页功能完成

    我们现在要开始实现模版里面的搜索功能了,我们先找要做出一个检索提交表单,如下所示: 只要我们点击生成之后我们的表单就获取到了,可以直接拿生成好的html表单拿来用来测试下.. 将他嵌入首页的模版文件, ...

  9. 从MVC和三层架构说到SSH整合开发

    相信很多人都认同JavaWeb开发是遵从MVC开发模式的,遵从三层架构进行开发的,是的,大家都这么认同.但是相信大家都会有过这样一个疑问,if(MVC三层模式==三层架构思想)out.println( ...

随机推荐

  1. 设计原则之依赖倒置js

    依赖倒置 定义:高层模块不应该依赖低层模块,二者都应该依赖其抽象:抽象不应该依赖细节:细节应该依赖抽象.(百科全书) 这个定义什么意思,太专业 感觉不像人话.. 什么叫高层模块,什么叫底层模块,什么叫 ...

  2. Python项目--Scrapy框架(二)

    本文主要是利用scrapy框架爬取果壳问答中热门问答, 精彩问答的相关信息 环境 win8, python3.7, pycharm 正文 1. 创建scrapy项目文件 在cmd命令行中任意目录下执行 ...

  3. springboot与缓存(redis,或者caffeine,guava)

    1.理论介绍 Java Caching定义了5个核心接口,分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry. CachingProvide ...

  4. Add-Migration : 无法将“Add-Migration”项识别为 cmdlet、函数、脚本文件或可运行程序的名称

    解决办法: PM>Import-Module C:\Users\Administrator.MACKJON\.nuget\packages\entityframework\6.2.0\tools ...

  5. python3 第二十四章 - 函数式编程之Anonymous function(匿名函数)

    匿名函数指一类无须定义标识符的函数或子程序.Python用lambda语法定义匿名函数,只需用表达式而无需申明.lambda语法的定义如下: lambda [arg1 [,arg2, ... argN ...

  6. java多线程系列14 设计模式 Master-Worker

    Master-Worker模式是常用的并行设计模式,可以将大任务划分为小任务,是一种分而治之的设计理念. 系统由两个角色组成,Master和Worker,Master负责接收和分配任务,Worker负 ...

  7. Java集合:ConcurrentHashMap原理分析

    集合是编程中最常用的数据结构.而谈到并发,几乎总是离不开集合这类高级数据结构的支持.比如两个线程需要同时访问一个中间临界区(Queue),比如常会用缓存作为外部文件的副本(HashMap).这篇文章主 ...

  8. BeanUtil拷贝

    拷贝vo对象 一些查询到的数据很多是不需要的,可以创建vo对象,对需要的对象属性进行拷贝 maven依赖 <dependency> <groupId>org.projectlo ...

  9. Day03(黑客成长日记)

    #猜数游戏 != 是不等于 # import random # secret = random.randint(,) # gwea = # tries = # : # guess = int(inpu ...

  10. EF6 学习笔记(二):操练 CRUD 增删改查

    EF6学习笔记总目录 ASP.NET MVC5 及 EF6 学习笔记 - (目录整理) 接上篇: EF6 学习笔记(一):Code First 方式生成数据库及初始化数据库实际操作 本篇原文链接: I ...