㈠ Jsp + servlet 做一个分页显示 怎么做 跪求代码 要全面的
我这个是基于ssh分页的，和selevt差不多，你可以参考一下，最重要的是自个会了理解了才行，别人的总是别人的。。。。。。好了 往下看。开始了。。。。。。。。。。。。。。。。 分页应该是每个程序员都要掌握的技术，也是用处最多的一种，本人不才，写了一个分页（基于数据库），请大家指点，首先得来个实体类（存储分页的信息，我起名称叫Page）
import java.util.ArrayList;
import java.util.List;public class Page {
private int totalPage = 1;/**
* 前一页
*/
private int prePage = 1;/**
* 下一页
*/
private int nextPage = 1;/**
* 总记录数
*/
private int totalRec = 0;/**
* 默认每页记录数
*/
private final int defaultPageSize = 10;/**
* 每页记录数
*/
private int pageSize = defaultPageSize;/**
* 当前页码
*/
private int pageIndex = 1;/**
* 全部页码，从1开始
*/
private int[] pageNumbers;public int getPageIndex() {
return pageIndex;
}public void setPageIndex(int pageIndex) {
this.pageIndex = pageIndex > 0 ? pageIndex : 1;
}public int getNextPage() {
return nextPage;
}public void setNextPage(int nextPage) {
this.nextPage = nextPage > this.totalPage ? this.totalPage : nextPage;
}public int getPageSize() {
return pageSize;
}public void setPageSize(int pageSize) {
this.pageSize = pageSize > 0 ? pageSize : 10;
}public int getPrePage() {
return prePage;
}public void setPrePage(int prePage) {
this.prePage = prePage < 1 ? 1 : prePage;
}public int getTotalPage() {
return totalPage;
}public void setTotalPage(int totalPage) {
this.totalPage = totalPage > 0 ? totalPage : 1;
}public int getTotalRec() {
return totalRec;
}public void setTotalRec(int totalRec) {
this.totalRec = totalRec > -1 ? totalRec : 0;
}public int[] getPageNumbers() {
return pageNumbers;
}public void setPageNumbers(int[] pageNumbers) {
this.pageNumbers = pageNumbers;
}
}
==============实体类有了，我们得在写一个公共的DAO方法（也就是每一个用到分页的地方都会调用这个）================public List findPageByQuery(final String queryString,
final Object[] parameters, final Page pageInfo) {
return (List) getHibernateTemplate().execute(new HibernateCallback()//这里使用了匿名内部类
{
public Object doInHibernate(Session session)//Spring进行事务维护 省去每次创建session和关闭session
throws HibernateException
{
Query query = session.createQuery(queryString);
if (parameters != null)
{
for (int i = 0; i < parameters.length; i++)
{
query.setParameter(i, parameters[i]);
}
}
ScrollableResults sr = query.scroll();
sr.last();
int totalCount = sr.getRowNumber();
int startIndex = (pageInfo.getPageIndex() - 1)
* pageInfo.getPageSize();
query.setMaxResults(pageInfo.getPageSize());
query.setFirstResult(startIndex);
int totalRec = totalCount + 1;
pageInfo.setTotalRec(totalRec);
int totalPage = (totalRec % pageInfo.getPageSize() == 0) ? (totalRec / pageInfo
.getPageSize())
: (totalRec / pageInfo.getPageSize()) + 1;
int[] pageNumbers = new int[totalPage];
for (int i = 0; i < totalPage; i++)
{
pageNumbers[i] = (i + 1);
}
pageInfo.setPageNumbers(pageNumbers);
pageInfo.setTotalPage(totalPage);
pageInfo.setPageSize(pageInfo.getPageSize());
pageInfo.setPageIndex(pageInfo.getPageIndex());
pageInfo.setPrePage(pageInfo.getPageIndex() - 1);
pageInfo.setNextPage(pageInfo.getPageIndex() + 1);
return query.list();
}
}, true);
}
=================至此我们的工作就完成了一半了 ，接下了就改写具体的方法了，来调用我们的公工分页方法public List getUU(int lexample,Page pageInfo)
{
/*ApplicationContext context = new (
"applicationContext.xml");
= (DaoImpl) context.getBean("Dao");
System.out.print();*/ //自己测试时候可以使用
List list = null;
if (pageInfo == null)
pageInfo = new Page();
try
{
hql="SELECT exa FROM Example exa WHERE 1=1 AND exa.LExample="+lexample;
list = this.getCommonDAO().findPageByQuery(hql, null, pageInfo);
} catch (Exception ex)
{
System.out.println(ex);
}
return list;
}=============接下来就是action中调用了===============public ActionForward getMore(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
ExampleForm exampleForm = (ExampleForm) form;// TODO Auto-generated method stub
List list = new ArrayList();
try
{
//pageInfo = (PageInfo) request.getAttribute("pageInfo");
String type=request.getParameter("type");
//类别编号
int typeId=0;
//页码编号
String page=request.getParameter("page");
if(page==null)
{page="1";<br> }
if(type==null) {
//默认显示女的
type="2";
}
System.out.println("action...........................");
pageInfo.setPageIndex(Integer.parseInt(page));
pageInfo.setPageSize(20);
typeId=Integer.parseInt(type);
// pageInfo.setPageIndex(Integer.parseInt(request.getParameter("Index")));
list = this.exampleBiz.getUU(typeId,pageInfo);
if(list.size()!=0)
{
request.setAttribute("list", list);
request.setAttribute("pageInfo", pageInfo);
}
}catch
(Exception ex)
{
ex.printStackTrace();
}
return mapping.findForward("more");
}======下面是页面，我们的工作马上就完了。<%String nowPage ;
String type;
int total;
nowPage=request.getParameter("page");
if(nowPage==null)
{nowPage="1";<br>}
type=request.getParameter("type"); //这个是我项目中的类别，没必要的
if(type==null) {
type="2";
}
int curPage=Integer.parseInt(nowPage);
int typeId=Integer.parseInt(type);
System.out.println(typeId+"------------------------------------");
if((Page)request.getAttribute("pageInfo") == null){
total = 1;
} else {
total = ((Page)request.getAttribute("pageInfo")).getTotalPage();
if(curPage>((Page)request.getAttribute("pageInfo")).getTotalPage()) {
curPage=total;
}
}
%><div style="width:870px; margin-bottom:20px;">
<logic:notEmpty name="list">
<logic:iterate id="example" name="list">
<div class="s_ren">
<div><img src="example.account.headIcn" /></div>
<div class="style_ju"><strong>${example.account.name }</strong></div>
<div>明星指数：<span class="style_ju">254179</span></div>
<div style="float:left; background-color:#FFC189; text-align:center; height:22px; width:55px; line-height:22px;">送鲜花</div>
<div style="float:right; background-color:#9DCBE7; text-align:center;height:22px; width:55px; line-height:22px;">扔鸡蛋</div>
</div>
</logic:iterate>
</logic:notEmpty>
</div>
<div style=" border-top:1px solid #ccc; height:1px;"></div>
<div style="text-align:center">
<a href="${pageContext.request.contextPath }/example.do?method=getMore&page=1&type=<%=typeId %>">首页</a> |
<a href="${pageContext.request.contextPath }/example.do?method=getMore&page=<%=curPage-1<0?1:curPage-1%>&type=<%=typeId %>"">上一页</a> |
<a href="${pageContext.request.contextPath }/example.do?method=getMore&page=<%=(curPage+1)>total?total:curPage+1%>&type=<%=typeId %>"">下一页</a> |
<a href="${pageContext.request.contextPath }/example.do?method=getMore&page=<%=total %>">末页</a>
当前第<%=curPage %>页 转到第 <select id="page" onchange="window.location.href='${pageContext.request.contextPath }/example.do?method=getMore&page='+document.getElementById('page').value;&type=<%=typeId %>"> <%
for(int toPage = 1; toPage<=total; toPage++) {
%>
<option value = <%=toPage%>
<%if(toPage==curPage){ %>
selected
<%} %>
>
<%=toPage %>
</option>
<%
}
%>
</select> 页
共<%=total%>页 ${pageInfo.pageIndex}
</div>OK!，现在我们的分页就行了，赶快试试吧！
㈡ 分页和分段
页和分段系统有许多相似之处，但在概念上两者完全不同，主要表现在：
1、页是信息的物理单位，分页是为实现离散分配方式，以消减内存的外零头，提高内存的利用率；或者说，分页仅仅是由于系统管理的需要，而不是用户的需要。
段是信息的逻辑单位，它含有一组其意义相对完整的信息。分段的目的是为了能更好的满足用户的需要。
2、页的大小固定且由系统确定，把逻辑地址划分为页号和页内地址两部分，是由机器硬件实现的，因而一个系统只能有一种大小的页面。
段的长度却不固定，决定于用户所编写的程序，通常由编辑程序在对源程序进行编辑时，根据信息的性质来划分。
3、分页的作业地址空间是维一的，即单一的线性空间，程序员只须利用一个记忆符，即可表示一地址。
分段的作业地址空间是二维的，程序员在标识一个地址时，既需给出段名，又需给出段内地址。
㈢ ASP多个条件查询并且分页显示
简单说说原理，具体的你自己实现就行了。
sql="select * from table where 1=1"
if t="t" then
sql=sql&" and xxx='"&request("筛选条件")&"'"
end if
这样就可以一出来是全部，，
在筛选的form里的action=加上t=t
然后在分页里
if t="t" then
<a href="?page=<%=page+1%>&t=t&各个条件">下一页
else
<a href="?page=<%=page+1%>">
end if
㈣ mysql如何做分页查询
很多应用往往只展示最新或最热门的几条记录，但为了旧记录仍然可访问，所以就需要个分页的导航栏。然而，如何通过MySQL更好的实现分页，始终是比较令人头疼的问题。虽然没有拿来就能用的解决办法，但了解数据库的底层或多或少有助于优化分页查询。
我们先从一个常用但性能很差的查询来看一看。
SELECT *
FROM city
ORDER BY id DESC
LIMIT 0, 15
这个查询耗时0.00sec。So，这个查询有什么问题呢？实际上，这个查询语句和参数都没有问题，因为它用到了下面表的主键，而且只读取15条记录。
CREATE TABLE city (
id int(10) unsigned NOT NULL AUTO_INCREMENT,
city varchar(128) NOT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB;
真正的问题在于offset(分页偏移量)很大的时候，像下面这样：
SELECT *
FROM city
ORDER BY id DESC
LIMIT 100000, 15;
上面的查询在有2M行记录时需要0.22sec，通过EXPLAIN查看SQL的执行计划可以发现该SQL检索了100015行，但最后只需要15行。大的分页偏移量会增加使用的数据，MySQL会将大量最终不会使用的数据加载到内存中。就算我们假设大部分网站的用户只访问前几页数据，但少量的大的分页偏移量的请求也会对整个系统造成危害。Facebook意识到了这一点，但Facebook并没有为了每秒可以处理更多的请求而去优化数据库，而是将重心放在将请求响应时间的方差变小。
对于分页请求，还有一个信息也很重要，就是总共的记录数。我们可以通过下面的查询很容易的获取总的记录数。
SELECT COUNT(*)
FROM city;
然而，上面的SQL在采用InnoDB为存储引擎时需要耗费9.28sec。一个不正确的优化是采用 SQL_CALC_FOUND_ROWS,SQL_CALC_FOUND_ROWS 可以在能够在分页查询时事先准备好符合条件的记录数，随后只要执行一句 select FOUND_ROWS(); 就能获得总记录数。但是在大多数情况下，查询语句简短并不意味着性能的提高。不幸的是，这种分页查询方式在许多主流框架中都有用到，下面看看这个语句的查询性能。
SELECT SQL_CALC_FOUND_ROWS *
FROM city
ORDER BY id DESC
LIMIT 100000, 15;
这个语句耗时20.02sec，是上一个的两倍。事实证明使用 SQL_CALC_FOUND_ROWS 做分页是很糟糕的想法。
下面来看看到底如何优化。文章分为两部分，第一部分是如何获取记录的总数目，第二部分是获取真正的记录。
高效的计算行数
如果采用的引擎是MyISAM，可以直接执行COUNT(*)去获取行数即可。相似的，在堆表中也会将行数存储到表的元信息中。但如果引擎是InnoDB情况就会复杂一些，因为InnoDB不保存表的具体行数。
我们可以将行数缓存起来，然后可以通过一个守护进程定期更新或者用户的某些操作导致缓存失效时，执行下面的语句：
SELECT COUNT(*)
FROM city
USE INDEX(PRIMARY);
获取记录
下面进入这篇文章最重要的部分，获取分页要展示的记录。上面已经说过了，大的偏移量会影响性能，所以我们要重写查询语句。为了演示，我们创建一个新的表“news”，按照时事性排序(最新发布的在最前面)，实现一个高性能的分页。为了简单，我们就假设最新发布的新闻的Id也是最大的。
CREATE TABLE news(
id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
title VARCHAR(128) NOT NULL
) ENGINE=InnoDB;
一个比较高效的方式是基于用户展示的最后一个新闻Id。查询下一页的语句如下，需要传入当前页面展示的最后一个Id。
SELECT *
FROM news WHERE id < $last_id
ORDER BY id DESC
LIMIT $perpage
查询上一页的语句类似，只不过需要传入当前页的第一个Id，并且要逆序。
SELECT *
FROM news WHERE id > $last_id
ORDER BY id ASC
LIMIT $perpage
上面的查询方式适合实现简易的分页，即不显示具体的页数导航，只显示“上一页”和“下一页”，例如博客中页脚显示“上一页”，“下一页”的按钮。但如果要实现真正的页面导航还是很难的,下面看看另一种方式。
SELECT id
FROM (
SELECT id, ((@cnt:= @cnt + 1) + $perpage - 1) % $perpage cnt
FROM news
JOIN (SELECT @cnt:= 0)T
WHERE id < $last_id
ORDER BY id DESC
LIMIT $perpage * $buttons
)C
WHERE cnt = 0;
通过上面的语句可以为每一个分页的按钮计算出一个offset对应的id。这种方法还有一个好处。假设，网站上正在发布一片新的文章，那么所有文章的位置都会往后移一位，所以如果用户在发布文章时换页，那么他会看见一篇文章两次。如果固定了每个按钮的offset Id，这个问题就迎刃而解了。Mark Callaghan发表过一篇类似的博客，利用了组合索引和两个位置变量，但是基本思想是一致的。
如果表中的记录很少被删除、修改，还可以将记录对应的页码存储到表中，并在该列上创建合适的索引。采用这种方式，当新增一个记录的时候，需要执行下面的查询重新生成对应的页号。
SET p:= 0;
UPDATE news SET page=CEIL((p:= p + 1) / $perpage) ORDER BY id DESC;
当然，也可以新增一个专用于分页的表，可以用个后台程序来维护。
UPDATE pagination T
JOIN (
SELECT id, CEIL((p:= p + 1) / $perpage) page
FROM news
ORDER BY id
)C
ON C.id = T.id
SET T.page = C.page;
现在想获取任意一页的元素就很简单了：
SELECT *
FROM news A
JOIN pagination B ON A.id=B.ID
WHERE page=$offset;
还有另外一种与上种方法比较相似的方法来做分页，这种方式比较试用于数据集相对小，并且没有可用的索引的情况下—比如处理搜索结果时。在一个普通的服务器上执行下面的查询，当有2M条记录时，要耗费2sec左右。这种方式比较简单，创建一个用来存储所有Id的临时表即可(这也是最耗费性能的地方)。
CREATE TEMPORARY TABLE _tmp (KEY SORT(random))
SELECT id, FLOOR(RAND() * 0x8000000) random
FROM city;
ALTER TABLE _tmp ADD OFFSET INT UNSIGNED PRIMARY KEY AUTO_INCREMENT, DROP INDEX SORT,ORDER BY random;
接下来就可以向下面一样执行分页查询了。
SELECT *
FROM _tmp
WHERE OFFSET >= $offset
ORDER BY OFFSET
LIMIT $perpage;
简单来说，对于分页的优化就是。。。避免数据量大时扫描过多的记录。
㈤ 在JSP中如何实现分页技术啊
title: JSP分页技术实现
summary:使用工具类实现通用分页处理
author: evan_zhao
email: [email protected]
目前比较广泛使用的分页方式是将查询结果缓存在HttpSession或有状态bean中，翻页的时候从缓存中取出一页数据显示。这种方法有两个主要的缺点：一是用户可能看到的是过期数据；二是如果数据量非常大时第一次查询遍历结果集会耗费很长时间，并且缓存的数据也会占用大量内存，效率明显下降。
其它常见的方法还有每次翻页都查询一次数据库，从ResultSet中只取出一页数据（使用rs.last();rs.getRow()获得总计录条数，使用rs.absolute()定位到本页起始记录）。这种方式在某些数据库(如oracle)的JDBC实现中差不多也是需要遍历所有记录，实验证明在记录数很大时速度非常慢。
至于缓存结果集ResultSet的方法则完全是一种错误的做法。因为ResultSet在Statement或Connection关闭时也会被关闭，如果要使ResultSet有效势必长时间占用数据库连接。
因此比较好的分页做法应该是每次翻页的时候只从数据库里检索页面大小的块区的数据。这样虽然每次翻页都需要查询数据库，但查询出的记录数很少，网络传输数据量不大，如果使用连接池更可以略过最耗时的建立数据库连接过程。而在数据库端有各种成熟的优化技术用于提高查询速度，比在应用服务器层做缓存有效多了。
在oracle数据库中查询结果的行号使用伪列ROWNUM表示（从1开始）。例如select * from employee where rownum<10 返回前10条记录。但因为rownum是在查询之后排序之前赋值的，所以查询employee按birthday排序的第100到120条记录应该这么写：
[pre] select * from (
select my_table.*, rownum as my_rownum from (
select name, birthday from employee order by birthday
) my_table where rownum <120
) where my_rownum>=100
[/pre]
mySQL可以使用LIMIT子句：
select name, birthday from employee order by birthday LIMIT 99,20
DB2有rownumber()函数用于获取当前行数。
SQL Server没研究过，可以参考这篇文章：http://www.csdn.net/develop/article/18/18627.shtm
在Web程序中分页会被频繁使用，但分页的实现细节却是编程过程中比较麻烦的事情。大多分页显示的查询操作都同时需要处理复杂的多重查询条件，sql语句需要动态拼接组成，再加上分页需要的记录定位、总记录条数查询以及查询结果的遍历、封装和显示，程序会变得很复杂并且难以理解。因此需要一些工具类简化分页代码，使程序员专注于业务逻辑部分。下面是我设计的两个工具类：
PagedStatement 封装了数据库连接、总记录数查询、分页查询、结果数据封装和关闭数据库连接等操作，并使用了PreparedStatement支持动态设置参数。
RowSetPage 参考PetStore的page by page iterator模式， 设计RowSetPage用于封装查询结果（使用OracleCachedRowSet缓存查询出的一页数据，关于使用CachedRowSet封装数据库查询结果请参考JSP页面查询显示常用模式）以及当前页码、总记录条数、当前记录数等信息， 并且可以生成简单的HTML分页代码。
PagedStatement 查询的结果封装成RowsetPage。
下面是简单的使用示例：
//DAO查询数据部分代码：
…
public RowSetPage getEmployee(String gender, int pageNo) throws Exception{
String sql="select emp_id, emp_code, user_name, real_name from employee where gender =?";
//使用Oracle数据库的分页查询实现,每页显示5条
PagedStatement pst =new PagedStatementOracleImpl(sql, pageNo, 5);
pst.setString(1, gender);
return pst.executeQuery();
}
//Servlet处理查询请求部分代码：
…
int pageNo;
try{
//可以通过参数pageno获得用户选择的页码
pageNo = Integer.parseInt(request.getParameter("pageno") );
}catch(Exception ex){
//默认为第一页
pageNo=1;
}
String gender = request.getParameter("gender" );
request.setAttribute("empPage", myBean.getEmployee(gender, pageNo) );
…
//JSP显示部分代码
<%@ page import = "page.RowSetPage"%>
…
<script language="javascript">
function doQuery(){
form1.actionType.value="doQuery";
form1.submit();
}
</script>
…
<form name=form1 method=get>
<input type=hidden name=actionType>
性别：
<input type=text name=gender size=1 value="<%=request.getParameter("gender")%>">
<input type=button value=" 查询 " onclick="doQuery()">
<%
RowSetPage empPage = (RowSetPage)request.getAttribute("empPage");
if (empPage == null ) empPage = RowSetPage.EMPTY_PAGE;
%>
…
<table cellspacing="0" width="90%">
<tr> <td>ID</td> <td>代码</td> <td>用户名</td> <td>姓名</td> </tr>
<%
javax.sql.RowSet empRS = (javax.sql.RowSet) empPage.getRowSet();
if (empRS!=null) while (empRS.next() ) {
%>
<tr>
<td><%= empRS.getString("EMP_ID")%></td>
<td><%= empRS.getString("EMP_CODE")%></td>
<td><%= empRS.getString("USER_NAME")%></td>
<td><%= empRS.getString("REAL_NAME")%></td>
</tr>
<%
}// end while
%>
<tr>
<%
//显示总页数和当前页数(pageno)以及分页代码。
//此处doQuery为页面上提交查询动作的javascript函数名， pageno为标识当前页码的参数名
%>
<td colspan=4><%= empPage .getHTML("doQuery", "pageno")%></td>
</tr>
</table>
</form>
效果如图：
因为分页显示一般都会伴有查询条件和查询动作，页面应已经有校验查询条件和提交查询的javascript方法（如上面的doQuery），所以RowSetPage.getHTML()生成的分页代码在用户选择新页码时直接回调前面的处理提交查询的javascript方法。注意在显示查询结果的时候上次的查询条件也需要保持，如<input type=text name=gender size=1 value="<%=request.getParameter("gender")%>">。同时由于页码的参数名可以指定，因此也支持在同一页面中有多个分页区。
另一种分页代码实现是生成每一页的URL，将查询参数和页码作为QueryString附在URL后面。这种方法的缺陷是在查询条件比较复杂时难以处理，并且需要指定处理查询动作的servlet，可能不适合某些定制的查询操作。
如果对RowSetPage.getHTML()生成的默认分页代码不满意可以编写自己的分页处理代码，RowSetPage提供了很多getter方法用于获取相关信息（如当前页码、总页数、 总记录数和当前记录数等）。
在实际应用中可以将分页查询和显示做成jsp taglib， 进一步简化JSP代码，屏蔽Java Code。
附：分页工具类的源代码， 有注释，应该很容易理解。
1.Page.java
2.RowSetPage.java(RowSetPage继承Page)
3.PagedStatement.java
4.PagedStatementOracleImpl.java(PagedStatementOracleImpl继承PagedStatement)
您可以任意使用这些源代码，但必须保留author [email protected]字样
///////////////////////////////////
//
// Page.java
// author: [email protected]
//
///////////////////////////////////
package page;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
/**
* Title: 分页对象<br>
* Description: 用于包含数据及分页信息的对象<br>
* Page类实现了用于显示分页信息的基本方法，但未指定所含数据的类型，
* 可根据需要实现以特定方式组织数据的子类，<br>
* 如RowSetPage以RowSet封装数据，ListPage以List封装数据<br>
* Copyright: Copyright (c) 2002 <br>
* @author [email protected] <br>
* @version 1.0
*/
public class Page implements java.io.Serializable {
public static final Page EMPTY_PAGE = new Page();
public static final int DEFAULT_PAGE_SIZE = 20;
public static final int MAX_PAGE_SIZE = 9999;
private int myPageSize = DEFAULT_PAGE_SIZE;
private int start;
private int avaCount,totalSize;
private Object data;
private int currentPageno;
private int totalPageCount;
/**
* 默认构造方法，只构造空页
*/
protected Page(){
this.init(0,0,0,DEFAULT_PAGE_SIZE,new Object());
}
/**
* 分页数据初始方法，由子类调用
* @param start 本页数据在数据库中的起始位置
* @param avaCount 本页包含的数据条数
* @param totalSize 数据库中总记录条数
* @param pageSize 本页容量
* @param data 本页包含的数据
*/
protected void init(int start, int avaCount, int totalSize, int pageSize, Object data){
this.avaCount =avaCount;
this.myPageSize = pageSize;
this.start = start;
this.totalSize = totalSize;
this.data=data;
//System.out.println("avaCount:"+avaCount);
//System.out.println("totalSize:"+totalSize);
if (avaCount>totalSize) {
//throw new RuntimeException("记录条数大于总条数？！");
}
this.currentPageno = (start -1)/pageSize +1;
this.totalPageCount = (totalSize + pageSize -1) / pageSize;
if (totalSize==0 && avaCount==0){
this.currentPageno = 1;
this.totalPageCount = 1;
}
//System.out.println("Start Index to Page No: " + start + "-" + currentPageno);
}
public Object getData(){
return this.data;
}
/**
* 取本页数据容量（本页能包含的记录数）
* @return 本页能包含的记录数
*/
public int getPageSize(){
return this.myPageSize;
}
/**
* 是否有下一页
* @return 是否有下一页
*/
public boolean hasNextPage() {
/*
if (avaCount==0 && totalSize==0){
return false;
}
return (start + avaCount -1) < totalSize;
*/
return (this.getCurrentPageNo()<this.getTotalPageCount());
}
/**
* 是否有上一页
* @return 是否有上一页
*/
public boolean hasPreviousPage() {
/*
return start > 1;
*/
return (this.getCurrentPageNo()>1);
}
/**
* 获取当前页第一条数据在数据库中的位置
* @return
*/
public int getStart(){
return start;
}
/**
* 获取当前页最后一条数据在数据库中的位置
* @return
*/
public int getEnd(){
int end = this.getStart() + this.getSize() -1;
if (end<0) {
end = 0;
}
return end;
}
/**
* 获取上一页第一条数据在数据库中的位置
* @return 记录对应的rownum
*/
public int getStartOfPreviousPage() {
return Math.max(start-myPageSize, 1);
}
/**
* 获取下一页第一条数据在数据库中的位置
* @return 记录对应的rownum
*/
public int getStartOfNextPage() {
return start + avaCount;
}
/**
* 获取任一页第一条数据在数据库中的位置，每页条数使用默认值
* @param pageNo 页号
* @return 记录对应的rownum
*/
public static int getStartOfAnyPage(int pageNo){
return getStartOfAnyPage(pageNo, DEFAULT_PAGE_SIZE);
}
/**
* 获取任一页第一条数据在数据库中的位置
* @param pageNo 页号
* @param pageSize 每页包含的记录数
* @return 记录对应的rownum
*/
public static int getStartOfAnyPage(int pageNo, int pageSize){
int startIndex = (pageNo-1) * pageSize + 1;
if ( startIndex < 1) startIndex = 1;
//System.out.println("Page No to Start Index: " + pageNo + "-" + startIndex);
return startIndex;
}
/**
* 取本页包含的记录数
* @return 本页包含的记录数
*/
public int getSize() {
return avaCount;
}
/**
* 取数据库中包含的总记录数
* @return 数据库中包含的总记录数
*/
public int getTotalSize() {
return this.totalSize;
}
/**
* 取当前页码
* @return 当前页码
*/
public int getCurrentPageNo(){
return this.currentPageno;
}
/**
* 取总页码
* @return 总页码
*/
public int getTotalPageCount(){
return this.totalPageCount;
}
/**
*
* @param queryJSFunctionName 实现分页的JS脚本名字，页码变动时会自动回调该方法
* @param pageNoParamName 页码参数名称
* @return
*/
public String getHTML(String queryJSFunctionName, String pageNoParamName){
if (getTotalPageCount()<1){
return "<input type='hidden' name='"+pageNoParamName+"' value='1' >";
}
if (queryJSFunctionName == null || queryJSFunctionName.trim().length()<1) {
queryJSFunctionName = "gotoPage";
}
if (pageNoParamName == null || pageNoParamName.trim().length()<1){
pageNoParamName = "pageno";
}
String gotoPage = "_"+queryJSFunctionName;
StringBuffer html = new StringBuffer("\n");
html.append("<script language=\"Javascript1.2\">\n")
.append("function ").append(gotoPage).append("(pageNo){ \n")
.append( " var curPage=1; \n")
.append( " try{ curPage = document.all[\"")
.append(pageNoParamName).append("\"].value; \n")
.append( " document.all[\"").append(pageNoParamName)
.append("\"].value = pageNo; \n")
.append( " ").append(queryJSFunctionName).append("(pageNo); \n")
.append( " return true; \n")
.append( " }catch(e){ \n")
// .append( " try{ \n")
// .append( " document.forms[0].submit(); \n")
// .append( " }catch(e){ \n")
.append( " alert('尚未定义查询方法：function ")
.append(queryJSFunctionName).append("()'); \n")
.append( " document.all[\"").append(pageNoParamName)
.append("\"].value = curPage; \n")
.append( " return false; \n")
// .append( " } \n")
.append( " } \n")
.append( "}")
.append( "</script> \n")
.append( "");
html.append( "<table border=0 cellspacing=0 cellpadding=0 align=center width=80%> \n")
.append( " <tr> \n")
.append( " <td align=left><br> \n");
html.append( " 共" ).append( getTotalPageCount() ).append( "页")
.append( " [") .append(getStart()).append("..").append(getEnd())
.append("/").append(this.getTotalSize()).append("] \n")
.append( " </td> \n")
.append( " <td align=right> \n");
if (hasPreviousPage()){
html.append( "[<a href='javascript:").append(gotoPage)
.append("(") .append(getCurrentPageNo()-1)
.append( ")'>上一页</a>] \n");
}
html.append( " 第")
.append( " <select name='")
.append(pageNoParamName).append("' onChange='javascript:")
.append(gotoPage).append("(this.value)'>\n");
String selected = "selected";
for(int i=1;i<=getTotalPageCount();i++){
if( i == getCurrentPageNo() )
selected = "selected";
else selected = "";
html.append( " <option value='").append(i).append("' ")
.append(selected).append(">").append(i).append("</option> \n");
}
if (getCurrentPageNo()>getTotalPageCount()){
html.append( " <option value='").append(getCurrentPageNo())
.append("' selected>").append(getCurrentPageNo())
.append("</option> \n");
}
html.append( " </select>页 \n");
if (hasNextPage()){
html.append( " [<a href='javascript:").append(gotoPage)
.append("(").append((getCurrentPageNo()+1))
.append( ")'>下一页</a>] \n");
}
html.append( "</td></tr></table> \n");
return html.toString();
}
}
///////////////////////////////////
//
// RowSetPage.java
// author: [email protected]
//
///////////////////////////////////
package page;
import javax.sql.RowSet;
/**
* <p>Title: RowSetPage</p>
* <p>Description: 使用RowSet封装数据的分页对象</p>
* <p>Copyright: Copyright (c) 2003</p>
* @author [email protected]
* @version 1.0
*/
public class RowSetPage extends Page {
private javax.sql.RowSet rs;
/**
*空页
*/
public static final RowSetPage EMPTY_PAGE = new RowSetPage();
/**
*默认构造方法，创建空页
*/
public RowSetPage(){
this(null, 0,0);
}
/**
*构造分页对象
*@param crs 包含一页数据的OracleCachedRowSet
*@param start 该页数据在数据库中的起始位置
*@param totalSize 数据库中包含的记录总数
*/
public RowSetPage(RowSet crs, int start, int totalSize) {
this(crs,start,totalSize,Page.DEFAULT_PAGE_SIZE);
}
/**
*构造分页对象
*@param crs 包含一页数据的OracleCachedRowSet
*@param start 该页数据在数据库中的起始位置
*@param totalSize 数据库中包含的记录总数
*@pageSize 本页能容纳的记录数
*/
public RowSetPage(RowSet crs, int start, int totalSize, int pageSize) {
try{
int avaCount=0;
if (crs!=null) {
crs.beforeFirst();
if (crs.next()){
crs.last();
avaCount = crs.getRow();
}
crs.beforeFirst();
}
rs = crs;
super.init(start,avaCount,totalSize,pageSize,rs);
}catch(java.sql.SQLException sqle){
throw new RuntimeException(sqle.toString());
}
}
/**
*取分页对象中的记录数据
*/
public javax.sql.RowSet getRowSet(){
return rs;
}
}
///////////////////////////////////
//
// PagedStatement.java
// author: [email protected]
//
///////////////////////////////////
package page;
import foo.DBUtil;
import java.math.BigDecimal;
import java.util.List;
import java.util.Iterator;
import java.util.Collections;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.Timestamp;
import javax.sql.RowSet;
/**
* <p>Title: 分页查询</p>
* <p>Description: 根据查询语句和页码查询出当页数据</p>
* <p>Copyright: Copyright (c) 2002</p>
* @author [email protected]
* @version 1.0
*/
public abstract class PagedStatement {
public final static int MAX_PAGE_SIZE = Page.MAX_PAGE_SIZE;
protected String countSQL, querySQL;
protected int pageNo,pageSize,startIndex,totalCount;
protected javax.sql.RowSet rowSet;
protected RowSetPage rowSetPage;
private List boundParams;
/**
* 构造一查询出所有数据的PageStatement
* @param sql query sql
*/
public PagedStatement(String sql){
this(sql,1,MAX_PAGE_SIZE);
}
/**
* 构造一查询出当页数据的PageStatement
* @param sql query sql
* @param pageNo 页码
*/
public PagedStatement(String sql, int pageNo){
this(sql, pageNo, Page.DEFAULT_PAGE_SIZE);
}
/**
* 构造一查询出当页数据的PageStatement，并指定每页显示记录条数
* @param sql query sql
* @param pageNo 页码
* @param pageSize 每页容量
*/
public PagedStatement(String sql, int pageNo, int pageSize){
this.pageNo = pageNo;
this.pageSize = pageSize;
this.startIndex = Page.getStartOfAnyPage(pageNo, pageSize);
this.boundParams = Collections.synchronizedList(new java.util.LinkedList());
this.countSQL = "select count(*) from ( " + sql +") ";
this.querySQL = intiQuerySQL(sql, this.startIndex, pageSize);
}
/**
*生成查询一页数据的sql语句
*@param sql 原查询语句
*@startIndex 开始记录位置
*@size 需要获取的记录数
*/
protected abstract String intiQuerySQL(String sql, int startIndex, int size);
/**
*使用给出的对象设置指定参数的值
*@param index 第一个参数为1，第二个为2
㈥ 看看JSP中怎样实现分页显示
分页依据：
select 字段列表 from 表名 limit m,n;
m: 表示起始记录，并且从0开始
n: 查询记录的个数，每页记录数
分页信息
共多少页
有没有上一页
有没有下一页
当前页
注：分页信息类Page
注2：创建分页信息辅助类PageUtil
public static Page createPage(int everyPage,int totalCount,int currentPage)
everyPage: 程序员定
totalCount: 总记录数，查询数据库表记录 select count(*) from 表名
currentPage: 从默认第一页开始，下一页= 当前页+1 上一页 = 当前页-1
分页数据集合List
依据查询语句获得集合： select 字段列表 from 表名 limit m,n;
m: beginIndex
n: everyPage
具体实现：：：
UserBiz:
//分页
public int getCont();
public List<User> findByPage(Page page);
123
UserBizImpl：
@Override
public int getCont() {
String sql = "select count(*) as count from user";
CountUtil count = (CountUtil) u.get(sql, CountUtil.class);
return count.getCount();
}
@Override
public List<User> findByPage(Page page) {
String sql = "select * from user limit "+page.getBeginIndex()+", "+page.getEveryPage();
return u.query(sql, User.class);
}
servlet：：UserServlet
int everyPage = 5;//每页记录数
int totalCount = ubiz.getCont();//获取总记录数
//点击链接重新获取当前页
String scurrentPage = request.getParameter("currentPage");
int currentPage = 1; //当前页，默认1
if(scurrentPage == null){
currentPage = 1;//从第一页开始访问
}else{
currentPage = Integer.parseInt(scurrentPage);
}
//分页信息
Page page = PageUtil.createPage(everyPage, totalCount, currentPage);
//分页数据信息
List<User> list = ubiz.findByPage(page);
request.setAttribute("page", page);
request.setAttribute("list", list);
//转发到userlist.jsp
request.getRequestDispatcher("/back/manager/userlist.jsp").forward(request, response);
userlist.jsp中的分页表现
<table width="461" height="24" border="1" cellpadding="0" cellspacing="0">
<tr>
<td width="199">当前为第${page.currentPage}页,共${page.totalPage}页</td>
<td width="256">
<c:choose>
<c:when test="${page.hasPrePage}">
<a href="<%=path %>/user.do?method=list¤tPage=1">首页</a> |
<a href="<%=path %>/user.do?method=list¤tPage=${page.currentPage -1 }">上一页</a>
</c:when>
<c:otherwise>
首页 | 上一页
</c:otherwise>
</c:choose>
<c:choose>
<c:when test="${page.hasNextPage}">
<a href="<%=path %>/user.do?method=list¤tPage=${page.currentPage + 1 }">下一页</a> |
<a href="<%=path %>/user.do?method=list¤tPage=${page.totalPage }">尾页</a>
</c:when>
<c:otherwise>
下一页 | 尾页
</c:otherwise>
</c:choose>
</td>
</tr>
</table>
附：：：：page类（分页信息实体类）
public class Page {
private int everyPage; //每页显示记录数
private int totalCount; //总记录数
private int totalPage; //总页数
private int currentPage; //当前页
private int beginIndex; //查询起始点
private boolean hasPrePage; //是否有上一页
private boolean hasNextPage; //是否有下一页
public Page(int everyPage, int totalCount, int totalPage,
int currentPage,int beginIndex, boolean hasPrePage,
boolean hasNextPage) { //自定义构造方法
this.everyPage = everyPage;
this.totalCount = totalCount;
this.totalPage = totalPage;
this.currentPage = currentPage;
this.beginIndex = beginIndex;
this.hasPrePage = hasPrePage;
this.hasNextPage = hasNextPage;
}
///////get，set方法略
}
附：pageutil 分页信息辅助类
public class PageUtil {
//创建Page对象
public static Page createPage(int everyPage,int totalCount,int currentPage) {//创建分页信息对象
everyPage = getEveryPage(everyPage);
currentPage = getCurrentPage(currentPage);
int totalPage = getTotalPage(everyPage, totalCount);
int beginIndex = getBeginIndex(everyPage, currentPage);
boolean hasPrePage = getHasPrePage(currentPage);
boolean hasNextPage = getHasNextPage(totalPage, currentPage);
return new Page(everyPage, totalCount, totalPage, currentPage,
beginIndex, hasPrePage, hasNextPage);
}
// 以下方法辅助创建Page对象
public static int getEveryPage(int everyPage) { //获得每页显示记录数
return everyPage == 0 ? 10 : everyPage;
}
public static int getCurrentPage(int currentPage) { //获得当前页
return currentPage == 0 ? 1 : currentPage;
}
public static int getTotalPage(int everyPage,int totalCount) {//获得总页数
int totalPage = 0;
if(totalCount != 0 &&totalCount % everyPage == 0) {
totalPage = totalCount / everyPage;
} else {
totalPage = totalCount / everyPage + 1;
}
return totalPage;
}
public static int getBeginIndex(int everyPage,int currentPage) {//获得起始位置
return (currentPage - 1) * everyPage;
}
public static boolean getHasPrePage(int currentPage) {//获得是否有上一页
return currentPage == 1 ? false : true;
}
public static boolean getHasNextPage(int totalPage, int currentPage) { //获得是否有上一页
return currentPage == totalPage || totalPage == 0 ? false : true;
}
}
㈦ css 中 怎么做分页
用CSS是不能分页的，分页是程序控制的。
比如说：有100条数据要在页面展示，每次展现10条，一共10页。
程序会在第一页取出1--10条数据给静态页面展示。
到第二页的时候在去11--20条数据给静态页面展示。
当然你要给程序相对应的参数，他才能从数据库里面取出来。
美工只做一个展现页面给程序员，分页就是在静态页面上某个位置写上“上一页”、“下一页”、“第一页”、“最后一页”“共多少页”，或者是数字的1、2、3、4、5、6那种，剩下的程序员就会搞定一切的。
CSS只能做装饰，不能分页。
㈧ 网站的分页功能是什么
绝大多数的网站的内容量大，显示器的范围有限，当遇大量内容的网页时就要用到分页。
网站就好象 一样，一页怎么可能写完所有内容呢。
就象你说的 到了页面规定的数量后就自动的分1.2.3页
但是在网站制作过程中需要程序员编写分页程序，这样才有分页效果。
㈨ asp怎么分页显示啊
作为一个程序员详细代码你还是自己写吧，这里只给个思路：分页的原理就是每次点击下一页的时候url中传递一个页面的变量到ASP页面，这个ASP页面在哪用到这个变量呢？就是在SELECT语句中用到的，比如说你每次从数据库中取10条记录(相当于设置每页显示10条)，那个变量就是取记录的起始位置，大体就是这样了，具体代码中你要先算出总共记录条数，你想每页显示多少条，从而再算出总共多少页