u011721609
- 浏览: 45435 次
-
文章分类
最新评论
关于dao层的封装和前端分页的结合（文章有点长，耐心点哦）
任何一个封装讲究的是，实用，多状态。
Action：
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; } }
其中涉及到的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; } }
然后讲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 intgetNums(Object ...args);
/**
* 根据条件集合
* */
public List<T>getList(PageUtil pageUtil, Object ...args);
/**
* 保存对象
* */
public TmakePersitent(T entity);
/**
* 根本编号获得对象
* */
public TfindById(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); } }
下面看一下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==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底层的魅力。
分享到：
发表评论
相关推荐
### 使用配置文件对DAO层封装具有分页功能的S2SH整合实例 #### 背景及概述 本文档旨在详细介绍如何使用配置文件的方式完成DAO层的封装，并在此基础上实现分页功能，最终达成S2SH（Struts、Spring、Hibernate）的...
DAO（Data Access Object）模式是软件开发中常用的一种设计模式，主要用于封装对数据库的操作，将数据访问层与业务逻辑层分离，以实现更清晰的代码结构和更好的可维护性。在DAO模式中，我们通常创建一个接口来定义...
DAO则是Model层的一部分，它封装了对数据库的所有操作，使得业务逻辑层与数据库交互变得更加简单和模块化。 在Struts框架中，我们可以使用Struts提供的标签库来实现前端的分页展示。例如，`<s:iterator>`标签可以...
Struts和DAO（Data Access Object）模式是Java Web开发中常用的两种技术，它们结合使用可以构建高效、可维护的Web应用程序。在这个场景中，"struts+dao分页"指的是利用Struts框架来处理用户请求，并通过DAO模式来...
本资源"分页dao+service.rar"可能包含了一个关于如何在Java后端实现分页查询的教程，主要涉及DAO（Data Access Object）层和服务（Service）层的设计和实现。下面我们将详细探讨分页查询的相关知识点。 1. **分页...
DAO模式是一种数据访问设计模式，用于封装对数据库的操作，将业务逻辑层与数据访问层分离。DAO类提供了与数据库进行交互的方法，如增删查改操作，使得业务逻辑组件只需调用DAO方法即可完成数据操作，降低了耦合性。 ...
4. **与DAO交互**：提供方法与数据访问层（如GroupDao.java）交互，获取分页数据。可能包含一个通用的`queryByPage`方法，接收SQL查询语句或Mapper接口，返回分页结果。 5. **兼容性**：考虑到不同的数据库可能有...
这个项目提供了关于如何在实际应用中集成Struts、DAO和Hibernate的实例，对于理解这些技术的协同工作以及在Java Web开发中实现分页功能具有很高的学习价值。通过深入研究和实践，开发者可以更好地掌握这些框架的用法...
在这个项目中，Service层封装了与分页相关的业务逻辑，比如根据用户请求的页码和每页大小，调用DAO层的方法获取相应的数据。这样，Service层可以独立于DAO层和Action层，有利于后期的扩展和维护。 Action层是控制层...
- **Service**：业务逻辑层，通常会封装分页查询的逻辑，根据前端传递的参数计算出SQL的LIMIT和OFFSET，调用DAO层进行数据库查询。 - **DAO**：数据访问对象，执行实际的SQL查询。在MyBatis中，可以使用动态SQL来...
在分页场景下，Spring可以用来管理DAO（数据访问对象）和Service，使得分页逻辑可以在Service层中实现，DAO层则专注于与数据库的交互。Spring的AOP（面向切面编程）还能帮助我们添加事务管理，确保数据操作的完整性...
10. **前端分页库**：为了简化前端分页逻辑，可以使用诸如Bootstrap-Pagination、jQuery Pagination等库，它们提供了现成的分页组件，只需配置参数即可。 以上是关于“用ssm框架和Ajax写的分页查询”的主要知识点。...
4. **重用分页类**：在大型项目中，为了代码的整洁和可维护性，通常会设计一个公共的分页类或分页工具类，封装分页逻辑。此类可以包含计算总页数、处理分页参数、返回分页数据等功能，适用于不同的数据源和查询场景...
5. **Controller层**：在Controller层，接收前端请求，将页码参数传递给Service层，得到分页数据后，将其封装成响应对象，返回给前端。 6. **前端展示**：前端接收到服务器返回的分页数据后，负责渲染页面，展示...
在分页系统中，Spring可以管理数据库连接池、事务管理以及DAO层的服务实例，提供强大的依赖注入机制，使得代码更易于测试和维护。 其次，SpringMVC是Spring框架的一部分，专门用于处理Web请求。在分页系统中，它...
在SSH（Spring、Struts2、Hibernate）框架...通过在DAO层设计合适的接口和实现，可以轻松地实现分页查询，并通过封装的`PageBean`类将分页信息传递给前端。这种方法既保持了代码的整洁，又保证了分页功能的高效和灵活。
3. **Service和DAO层**：在Service层定义分页查询的方法，如`List<User> getUsersByPage(int pageNum, int pageSize)`，然后在DAO层实现具体的SQL执行。Service层通常会封装一些业务逻辑，如计算起始位置。 4. **...
在服务层（Service）和控制层（Controller）中，我们可以根据用户请求的页码计算出偏移量，然后调用DAO层的方法进行分页查询，将结果填充到`PageBean`对象中，最后返回给前端展示。 分页查询的关键在于正确设置查询...
4. **配置与使用**：在项目中使用SSH分页插件，通常需要在Spring配置文件中进行声明，然后在Service层或者DAO层通过注解或接口调用来启用分页功能。 5. **前端展示**：前端页面需要配合后端提供的分页信息，生成...