分页的实现
分页简介

分页（英语：Paging），是一种操作系统里存储器管理的一种技术，可以使电脑的主存可以使用存储在辅助存储器中的数据。操作系统会将辅助存储器（通常是磁盘）中的数据分区成固定大小的区块，称为“页”。当不需要时，将分页由主存（通常是内存）移到辅助存储器；当需要时，再将数据取回，加载主存中。相对于分段，分页允许存储器存储于不连续的区块以维持文件系统的整齐。分页是磁盘和内存间传输数据块的最小单位，在Java中是一种特别常见的现象，下面我将一点一点的带着大家来分析一下分页。
理解分页

分页无非就是在服务器端得到数据，然后以固定的条数来写到浏览器端进行显示的过程，要想写好分页，不非就是首先明确，一个分页功能需要包含什么样的变量，这些变量该怎么获得，是从前端页面传过来呢,还是从后端获取的呢，下面咱们来简单的了解一下：

1.totalCount :总的数据的条数，显然易见，由于数据库的数据可以变化，显然该数据需要从后台获取。

2.totalPage:总的页数，由于总的数据是从数据库中查询出来的，每页多少条数据都可以是事先知道的，所以，从后台获取

3.list 每页的数据，显然是从后台获取的

4.currentPage当前页，显然是从前台获取的，因为每次大家需要点击不同的页数，传递过来的数据都是不一样的

5rows.每页多少条数据，可以从前台获取也可以从后台获取，我建议从后台获取，可以将其存到配置文件中，可以通过获取到不同的标准，符合Java的编程理念
细节优化和讲解

首先将rows写到web.xml文件中对应的分页对应的servlet中，再通过getServletConfig().getInitParameter()初始化的时候获取：



各变量的简单的书写流程，大家可以简单理解一下，下面会详细解答



流程分析

1.首先从前台获取到当前页

2.利用service查询PageBean

3.将pageBean存到request域对象中

4.转发到list.jsp，利用jstl和el表达式来实现数据的显示



代码体现

将分页的详细属性封装成JavaBean，便于存到域对象中，获取其数据值
package cn.ujiuye.domain;

import java.util.List;

/**
 * 分页的javaBean
 */
public class PageBean<T> {
    private int totalCount;  //总的记录数
    private int totalPage;   //总的页码
    private List<T> list;    //每页的数据
    private int currentPage; //当前页
    private int rows;        //每页显示的条数

    public int getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(int totalCount) {
        this.totalCount = totalCount;
    }

    public int getTotalPage() {
        return totalPage;
    }

    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }

    public List<T> getList() {
        return list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }

    public int getCurrentPage() {
        return currentPage;
    }

    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }

    public int getRows() {
        return rows;
    }

    public void setRows(int rows) {
        this.rows = rows;
    }

    @Override
    public String toString() {
        return "PageBean{" +
                "totalCount=" + totalCount +
                ", totalPage=" + totalPage +
                ", list=" + list +
                ", currentPage=" + currentPage +
                ", rows=" + rows +
                '}';
    }
}


首先书写一个findProductByPageServlet，实现前端和后端的数据的交互，我认为首先写后台代码，再将所需要的当前页的currentPage手动通过地址栏手动传入数据，这样可以最快进入数据的书写流程，可以先检查后端代码是不是实现的没有问题


package cn.ujiuye.web.servlet;
import cn.ujiuye.domain.PageBean;
import cn.ujiuye.domain.Product;
import cn.ujiuye.service.ProductService;
import cn.ujiuye.service.impl.ProductServiceImpl;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class FindProductByPageServlet extends HttpServlet {

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取请求参数
        String currentPage = request.getParameter("currentPage");
        String rows = getServletConfig().getInitParameter("rows");
        //判断从其他的页面传递过来的时候,这个时候需要做对其当前页的判断
        if (currentPage == null || "".equals(currentPage)){
            currentPage = "1";
        }

        System.out.println("当前页码是:"+currentPage);
        System.out.println("每页的条数是:"+ rows);

        //2.调用service进行查询
        ProductService service = new ProductServiceImpl();
        PageBean<Product> pb = service.findUserByPage(currentPage,rows);

        System.out.println(pb.getTotalPage()+"***************");

        //3.将pageBean存入到域对象中
        request.setAttribute("pb",pb);
        //4.转发到list.jsp页面中去
        request.getRequestDispatcher("/list.jsp").forward(request,response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }


}


在service层实现数据的业务逻辑的处理，我是用了接口的思想来实现的，把数据存入到JavaBean的时候，方便调用，将其分页的各项需求的内容都写入到JavaBean中，从前端获取的当前页，从servlet中获取的每页有多少条数据，通过dao来查询数据库中一共有多少条数据，通过计算获取其一共多少页，返回每一页有多少条数据，这些数据在service层都传入到JavaBean中，用于封装起来了
  /**
     * 分页查询
     * @param _currentPage
     * @param _rows
     * @return
     */
    @Override
    public PageBean<Product> findUserByPage(String _currentPage, String _rows) {
        int currentPage = Integer.parseInt(_currentPage); //当前页数
        int rows = Integer.parseInt(_rows);               //每页多少条数据

        if (currentPage <= 1){
            currentPage = 1;
        }
        //1.创建一个空的PageBean对象
        PageBean<Product> pb =  new PageBean<Product>();
        //2.设置参数
        pb.setCurrentPage(currentPage);
        pb.setRows(rows);

        //3.使用dao查询获取总数据数
        int totalCount = dao.findTotalCount();
        System.out.println(totalCount);

        pb.setTotalCount(totalCount);
        //4.调用dao查询每页List集合中的详情
        int start = (currentPage - 1) * rows;
        List<Product> list = dao.findByPage(start,rows);
        pb.setList(list);

        //5.计算出总页码
        int totalPage = totalCount % rows == 0 ? totalCount / rows : totalCount / rows + 1;
        pb.setTotalPage(totalPage);

        return pb;
    }

在dao层中实现每页数据的显示和总记录的查询
 /**
     * 返回总记录数
     * @return
     */
    @Override
    public int findTotalCount() {
        //1.定义sql
        String sql = " select count(*) from product ";
        return template.queryForObject(sql,Integer.class);
    }

    /**
     * 分页操作,返回每一页的数据
     * @param start
     * @param rows
     * @return
     */
    @Override
    public List<Product> findByPage(int start, int rows) {
        //1.定义sql
        String sql = "select * from product limit ?,? ";
        return template.query(sql,new BeanPropertyRowMapper<Product>(Product.class),start,rows);
    }

这些完成后就开始了前端页面的书写，主要就是说从域对象中获取需要的值，然后利用jstl和el表达式来获取其值，从而达到显示的效果，注意上一页和下一页的写法和对于一些特别的地方的控制，在这里就不多介绍了，我还加入了bootstrap让页面更加漂亮了，下面给大家显示一个前端的源码和相应的显示结果
 <%--分页栏显示出来--%>
     <nav aria-label="Page navigation" style="text-align: center">
         <ul class="pagination pagination-lg">

             <c:if test="${pb.currentPage == 1}">
                 <li class="disabled">
             </c:if>
             <c:if test="${pb.currentPage != 1}">
                 <li>
             </c:if>

                 <a href="${pageContext.request.contextPath}/findProductByPageServlet?currentPage=${pb.currentPage - 1}" aria-label="Previous">
                     <span aria-hidden="true">&laquo;</span>
                 </a>
             </li>


             <c:forEach begin="1" end="${pb.totalPage}" var="i">

                 <c:if test="${pb.currentPage == i}">
                     <li class="active"><a href="${pageContext.request.contextPath}/findProductByPageServlet?currentPage=${i}">${i}</a></li>
                 </c:if>
                 <c:if test="${pb.currentPage != i}">
                     <li><a href="${pageContext.request.contextPath}/findProductByPageServlet?currentPage=${i}">${i}</a></li>
                 </c:if>

             </c:forEach>

             <c:if test="${pb.currentPage == pb.totalPage}">
                 <li class="disabled">
                     <a aria-label="Next">
                         <span aria-hidden="true">&raquo;</span>
                     </a>
                 </li>
             </c:if>

             <c:if test="${pb.currentPage != pb.totalPage}">
                 <li>
                     <a href="${pageContext.request.contextPath}/findProductByPageServlet?currentPage=${pb.currentPage + 1}" aria-label="Next">
                         <span aria-hidden="true">&raquo;</span>
                     </a>
                 </li>
             </c:if>


             <span style="font-size: 25px;margin-left: 5px">
                    &nbsp;&nbsp;共${pb.totalCount}条数据,共${pb.totalPage}页
             </span>
         </ul>
     </nav>



总结：希望大家都可以认真来确定自己是否学会了，是否可以真的能够实现自己的功能，自己可以来写自己想要的，自己要具备可以不改变的功能，能够对知识有一个真实的认识，我写的好的，大家多多指教，欢迎评论和点赞，希望要源码的私聊我

分页问题很普遍，开发者几乎都要用到，有关分页的原理可以参考前面的文章：
http://blog.csdn.net/treeroot/archive/2004/09/29/121071.aspx
很多人在分页问题上处理的不够好，往往导致整个程序混乱，代码可读性差，不过有经验的一般都会做一个JavaBean来实现分页功能，但是就是这个JavaBean如何设计又带来一大堆问题，有的甚至使程序逻辑更加混乱。这里推荐一篇文章：
http://blog.csdn.net/treeroot/articles/122802.aspx
设计这个分页功能要达到的目标：
1.和实现无关，这样才可以复用。
2.符合开闭原则，也就是说可以新增功能，但不需要修改。
3.简洁明了，容易看懂。

下面的设计每次只获取一页数据，每次都要重新设置查询总数，具体如何获得自己实现，这是一个比较通用的分页实现。

这里设计一个接口：
package treeroot.util;
import java.util.List;
/**
* 该接口用来实现分页功能，注意这里没有提供修改的功能。
* @author treerot
* @version 1.0
* @since 2004-9-30
*/
public interface Pageable
{
　　/**
　　* 获得数据结果
　　* @return
　　*/
　　public List getResult();
　　/**
　　* 获得查询总数
　　* @return
　　*/
　　public int getCount();
　　/**
　　* 获得每页纪录数
　　* @return
　　*/
　　public int getPageSize();
　　/**
　　* 获得当前页编号
　　* @return
　　*/
　　public int getCurrentPage();
　　/**
　　* 获得总页数
　　* @return
　　*/
　　public int getPages();
　　/**
　　* 每页默认显示纪录数
　　*/
　　public final static int DEFAULT_PAGESIZE=20;

}
这个接口非常简单，就是包括一个结果列表和一些分页的必要信息，这里注意几点：
1.这个接口的实现表示的是某一次查询的某一页数据，和上次查询无关
2.这个接口的实现应该是只读的，也就是说不可以修改的。
3.getPages()方法是冗余的，但是这里仍然提供这个方法。
下面给出一个抽象实现：
package treeroot.util;
import java.util.List;
/**
* @author treerot
* @version 1.0
* @since 2004-9-30
*/
public abstract class AbstractPage implements Pageable
{
　　private int currentPage;
　　private int pageSize;
　　private int pages;　
　 
　　protected int count;
　　protected List result;

　　/**
　　* 指定当前页　
　　* @param currentPage
　　* @throws PageException
　　*/
　　public AbstractPage(int currentPage){
　　　　this(currentPage,Pageable.DEFAULT_PAGESIZE);
　　}
　　/**
　　* 指定当前页和页大小
　　* @param currentPage
　　* @param pageSize
　　* @throws PageException
　　*/
　　public AbstractPage(int currentPage,int pageSize) {
　　　　this.currentPage=currentPage;
　　　　this.pageSize=pageSize;
　　}

　　protected void checkPage(int currentPage) throws PageException{
　　　　if((currentPage<1)||(currentPage>this.getPages()))
　　　　　　　throw new PageException("页超出范围:总页数为"+this.getPages()+"，当前页为"+currentPage);
　　}
　　/**
　　* 这个方法被子类重写用来初始化，也就是计算count值和result结果，在子类 的构造函数中调用。
　　*/
　　abstract protected void init() throws PageException;
　　
　　public List getResult()
　　{
　　　　return result;
　　}
　
　　public int getCount()
　　{
　　　　return count;
　　}

　　public int getPageSize()
　　{
　　　　return pageSize;
　　}

　　public int getCurrentPage()
　　{
　　　　return currentPage;　
　　}
　
　　public int getPages()
　　{
　　　 if(pages==0) this.pages=(count+pageSize-1)/pageSize;
　　　　return pages;
　　}
}
这个抽象类实现了接口中的所有方法，但是定义了一个抽象方法init()，在子类中必须实现这个方法。上面的一个接口和一个抽象类看起来比较简单，你可能会觉得好像什么都没有做，实现上确实没有做什么,但是却可以给开发带来很大的帮助。我们可以根据自己的需要要继承这个抽象类，而数据可以通过各种方式获得，比如直接通过一个List获得，或者通过JDBC，Hibernate等等，不过我们都需要把结果封装到一个List里面,通过Hibernate就显得特别方便了。
PageException是自定义的一个异常
package treeroot.util　　　
/**
* @author treeroot
* @version 1.0
* @since 2004-9-30
*/
public class PageException extends Exception
{
　　public PageException(){
　　　　super();
　　}
　　public PageException(String message){
　　　　super(message);
　　}
}

这里构建一个最简单的分页实现，也就是说通过查询结果的列表来构建页对象，这种情况是存在的：比如本次要显示的结果不是直接从数据库查询得到的，而是通过过滤某次数据库查询得到的，总之就是一个包含所有数据的结果集合。
不知道有没有说清楚，这里直接给出一个参考实现：
package treeroot.util;
import java.util.List;
/**
* @author treerot
* @version 1.0
* @since 2004-9-30
*/
public class ListPage extends AbstractPage implements Pageable
{
　　private List list;
　　/**
　　* 通过一个结果列表来初始化
　　* @param list
　　* @throws PageException
　　*/
　　public ListPage(List list) throws PageException
　　{
　　　　this(list, 1, Pageable.DEFAULT_PAGESIZE);
　　}
　　/**
　　* 通过一个结果列表来初始化，指定当前页
　　* @param list
　　* @param currentPage
　　* @throws PageException
　　*/
　　public ListPage(List list, int currentPage) throws PageException
　　{
　　　　this(list, currentPage, Pageable.DEFAULT_PAGESIZE);
　　}
　　/**
　　* 通过一个结果列表来初始化，指定当前页和页大小
　　* @param list
　　* @param currentPage
　　* @param pageSize
　　* @throws PageException
　　*/
　　public ListPage(List list, int currentPage, int pageSize)　throws PageException
　　{
　　　　super(currentPage, pageSize);
　　　　//这里为了达到fail-fast，直接抛出异常，不是必须的。
　　　　if(list==null) throw new NullPointerException(); 
　　　 
　　　　this.list = list;
　　　　init();
　　}
　　protected void init() throws PageException
　　{
　　　　this.count = list.size();
　　　　checkPage(this.getCurrentPage());
　　　　int fromIndex = (this.getCurrentPage() - 1) * this.getPageSize();
　　　　int toIndex = Math.min(fromIndex + this.getPageSize(), this.count);
　　　　this.result = list.subList(fromIndex, toIndex);
　　}
}

是不是觉得很简单，看一下怎么应用吧，假如你有一个方法就是获得查询结果，那么你就可以这样用了。
在Servlet或者Action中：
int currentPage=1;
String str=request.getParameter("currentPage");
if(str!=null){
　　try{
　　　　 currentPage=Integer.parseInt(str);
　　}
　　 catch(NumberFormatException e){}　 
}

List list= .... //这里获得所有结果，可能是直接获得数据库查询结果，也可能经过处理。
Pageable pg =null;
try{ 
　　pg= new ListPage(list,currentPage);
        //或者通过Dao　pg=(new Dao()).getResutl(currentPage); 返回类型为Pageable
}
catch(PageException e)
{
　　pg=null;
} 
request.setAttribute("page",pg);
//转发给一个JSP页面显示。
是不是觉得很简洁？当然这里没有给出具体的的数据获取方法，但是在JSP显示页面就会觉得很舒服了，这里简单写一个JSP。
<%
Pageable pg=(Pageable)request.getAttribute("page");
%> 
<table>
<tr>
<th>学号</th>
<th>姓名</th>
</tr>　 
<%
if(pg!=null){ 
　　List list=pg.getResult();
　　for(int i=0;i<list.size();i++){
　　　　Student stu=(Student)list.get(i);
%> 
　　　　<tr>
　　　　<td><%=stu.getNumber()%></td>
　　　　<td><%=stu.getName()%></td> 
　　　　</tr> 
<%
　　}
%>

　　<tr>
　　<td colspan="2">
　　总纪录:<%=pg.getCount()%> &nbsp;&nbsp; 
　　每页显示：<%=pg.getPageSize()%> &nbsp;&nbsp
　　页次：<%=pg.getCurrentPage()%>/<%=pg.getPages()%> &nbsp;&nbsp;
　　<a href="#" onClick="gotoPage(<%=pg.getCurrentPage()-1%>)">上一页</a>
　　 <a href="#" onClick="gotoPage(<%=pg.getCurrentPage()+1%>)">上一页</a>
　　</td> 　 
　　</tr>

<%
}
else{
%>
　　<tr>
　　<td colspan="2">指定的页不存在</td>
　　</tr>
<%
} 
%> 
这里只是简单得描述了一下，gotoPage是一个javascript函数，就是提交一个表单，指定当前页码。这里有些问题都没有处理：比如页码越界(可以在客户端也可以在服务器端验证，可以报错也可以自动纠正)。


我开始就是为了在Hibernate中使用分页才设计这个分页实现的，因为使用Hibernate时，查询后的结果被自动封装到一个List中了，所以使用起来特别方便，这里我做了一个比较庸俗的实现，就是查询参数只适合字符串类型,不过大部分查询还真的只是对字符串操作。
package treeroot.util;
import net.sf.hibernate.HibernateException;
import treeroot.common.dao.AbstractBaseDao;
/**
* @author treerot
* @version 1.0
* @since 2004-9-30
*/
public class HibernatePage extends AbstractPage implements Pageable
{
　　private String querySql;
　　private String countSql;
　　private String[] parameters;
　　public HibernatePage(int currentPage,String querySql,String countSql,String[] parameters) throws PageException{
　　　　this(currentPage,Pageable.DEFAULT_PAGESIZE,querySql,countSql,parameters);
　　}
　　public HibernatePage(int currentPage,int pageSize,String querySql,String countSql,String[] parameters)　throws PageException
　　{
　　　　super(currentPage, pageSize);
　　　　this.querySql = querySql;
　　　　this.countSql = countSql;
　　　　this.parameters = parameters;
　　　　init();
　　}
　　protected void init() throws PageException
　　{
　　　　try{
　　　　　　　 this.count = AbstractBaseDao.queryCount(countSql);
　　　　　　　int fromIndex = (this.getCurrentPage() - 1) * this.getPageSize();
　　　　　　　int toIndex = Math.min(this.count, fromIndex + this.getPageSize());
　　　　　　　this.result = AbstractBaseDao.find(this.querySql,this.parameters,fromIndex,toIndex);
　　　　}
　　　　catch (HibernateException e)
　　　　{
　　　　　　　throw new PageException(e.getMessage());
　　　　}
　　}
}
这个类的设计并不是很合理的，因为查询只能接受字符串参数，但是如果只需要字符串参数就足够了。另外查询语句必须是JDBC风格的参数(?), 而不是Hibernate风格的(:=)，你看过Dao里面的代码就知道为什么了。先看一下如何使用吧(一个Dao中的方法):

public Pageable findByName(String name,int currentPage) throws PageException{
　　String countSql="select count(*) from MyClass as c where c.name like ?";
　　String querySql="from MyClass as c where c.name like ?";
　　String[] parameter=new String[]{name};
　　return new HibernatePage(currentPage,countSql,querySql,parameter);
} 

这个方法应该是比较简洁的，这里给出queryCount和find的实现,我对Hibernate的了解比较肤浅，所以下面的方法如果有什么不当的地方还望指出，谢谢！
public static int queryCount(String hql, String[] args) throws HibernateException
{

　　if (hql == null) throw new NullPointerException();
　　Object obj = null;
　　Transaction trans = null;
　　Session s = null;
　　try
　　{
　　　　s = HibernateSessionFactory.currentSession();
　　　　trans = s.beginTransaction();
　　　　Query q = s.createQuery(hql);
　　　　if (args != null)
　　　　{
　　　　　　for (int i = 0; i < args.length; i++){
　　　　　　　　q.setString(i, args[i]);
　　　　　　}
　　　　}
　　　　obj = q.uniqueResult();
　　　　trans.commit();
　　}
　　catch (HibernateException e)
　　{
　　　　if (trans != null)
　　　　{
　　　　　　try{
　　　　　　　　trans.rollback();
　　　　　　}
　　　　　　catch (HibernateException ex){//no need to care this Exception }
　　　　}
　　　　throw e;
　　}
　　return ((Integer) obj).intValue();
}
public　static List find(String hql, String[] args, int fromIndex, int toIndex)　throws HibernateException
{
　　if (hql == null) throw new NullPointerException();
　　List l = null;
　　Transaction trans = null;
　　Session s = null;
　　try{
　　　　s = HibernateSessionFactory.currentSession();
　　　　trans = s.beginTransaction();
　　　　Query q = s.createQuery(hql);
　　　　if (args != null){
　　　　　　for (int i = 0; i < args.length; i++){
　　　　　　　　q.setString(i, args[i]);
　　　　　　}
　　　　}
　　　　if (fromIndex > -1){
　　　　　　 if (toIndex > fromIndex){
　　　　　　　　　q.setFirstResult(fromIndex);
　　　　　　　　　q.setMaxResults(toIndex - fromIndex);
　　　　　　　}
　　　　　　　else{
　　　　　　　　　throw new IndexOutOfBoundsException();
　　　　　　　}
　　　　}
　　　　l = q.list();
　　　　trans.commit();
　　　}
　　　catch (HibernateException e){
　　　　　if (trans != null){
　　　　　　　try{
　　　　　　　　　trans.rollback();
　　　　　　　}
　　　　　　　catch (HibernateException ex){ //no need to care this Exception }
　　　　　}
　　　　　throw e;
　　　}
　　　return l;
}

GridView分页的实现
要在GridView中加入
//实现分页
AllowPaging="true"
//一页数据10行
 PageSize="10"
// 分页时触发的事件

OnPageIndexChanging="gvwDesignationName_PageIndexChanging"
在服务器事件里


 protected void gvwDesignationName_PageIndexChanging(object sender, GridViewPageEventArgs e)
    {
        gvwDesignationName.PageIndex=e.newIndex;

        bingDesignatioonName();
    }



这里我给出一个通用显示分页的模板（网上搜的，自己给出注释)

<PagerTemplate>

                当前第:

                //((GridView)Container.NamingContainer)就是为了得到当前的控件
                <asp:Label ID="LabelCurrentPage" runat="server" Text="<%# ((GridView)Container.NamingContainer).PageIndex + 1 %>"></asp:Label>

                页/共:

                //得到分页页面的总数
                <asp:Label ID="LabelPageCount" runat="server" Text="<%# ((GridView)Container.NamingContainer).PageCount %>"></asp:Label>

                页

                 //如果该分页是首分页，那么该连接就不会显示了.同时对应了自带识别的命令参数CommandArgument
                <asp:LinkButton ID="LinkButtonFirstPage" runat="server" CommandArgument="First" CommandName="Page"

                    Visible='<%#((GridView)Container.NamingContainer).PageIndex != 0 %>'>首页</asp:LinkButton>

                <asp:LinkButton ID="LinkButtonPreviousPage" runat="server" CommandArgument="Prev"

                    CommandName="Page" Visible='<%# ((GridView)Container.NamingContainer).PageIndex != 0 %>'>上一页</asp:LinkButton>

               //如果该分页是尾页，那么该连接就不会显示了
                <asp:LinkButton ID="LinkButtonNextPage" runat="server" CommandArgument="Next" CommandName="Page"

                    Visible='<%# ((GridView)Container.NamingContainer).PageIndex != ((GridView)Container.NamingContainer).PageCount - 1 %>'>下一页</asp:LinkButton>

                <asp:LinkButton ID="LinkButtonLastPage" runat="server" CommandArgument="Last" CommandName="Page"

                    Visible='<%# ((GridView)Container.NamingContainer).PageIndex != ((GridView)Container.NamingContainer).PageCount - 1 %>'>尾页</asp:LinkButton>

                转到第

                <asp:TextBox ID="txtNewPageIndex" runat="server" Width="20px" Text='<%# ((GridView)Container.Parent.Parent).PageIndex + 1 %>' />页

                //这里将CommandArgument即使点击该按钮e.newIndex 值为3 
                <asp:LinkButton ID="btnGo" runat="server" CausesValidation="False" CommandArgument="-2"

                    CommandName="Page" Text="GO" />

            </PagerTemplate>
对应该事件中代码为


 protected void gvwDesignationName_PageIndexChanging(object sender, GridViewPageEventArgs e)

    {

        // 得到该控件
        GridView theGrid = sender as GridView;

        int newPageIndex = 0;

        if (e.NewPageIndex==-3)

        {

            //点击了Go按钮
            TextBox txtNewPageIndex = null;


            //GridView较DataGrid提供了更多的API，获取分页块可以使用BottomPagerRow 或者TopPagerRow，当然还增加了HeaderRow和FooterRow
            GridViewRow pagerRow = theGrid.BottomPagerRow;

            

            if (pagerRow != null)

            {

                //得到text控件
                txtNewPageIndex = pagerRow.FindControl("txtNewPageIndex") as TextBox;    

            }

            if ( txtNewPageIndex!= null)

            {

                //得到索引
                newPageIndex = int.Parse(txtNewPageIndex.Text) - 1; 

            }

        }

        else

        { 

            //点击了其他的按钮
            newPageIndex = e.NewPageIndex;

        }

        //防止新索引溢出
        newPageIndex = newPageIndex < 0 ? 0 : newPageIndex;

        newPageIndex = newPageIndex >= theGrid.PageCount ? theGrid.PageCount - 1 : newPageIndex;

        

        //得到新的值
        theGrid.PageIndex = newPageIndex;

        

         //重新绑定
        bingDesignatioonName();

    }

在ASP.NET中，GridView控件本身就带有分页的功能，只要把当前页面的索引值赋给GridView的PageIndex就可以实现了分页，至于数据怎么分页，全都由GridView封装起来了。
在ASP.NET MVC中分页的实现就只能靠自己来设计了。首先来说一下分页的原理。现在有一个张news表，中间有很多信息，我们假设一页显示5条记录，这样，页面数量=总记录数/5；这里，如果出现小数，得进位取整。如比总记录和数为51，那么分的页面数量是11，最后一页只有一条记录。好，有这样一个思路后，现在就来做ASP.NET MVC中的分页了。
1、 数据库和表
创建一个Data_Company的数据库，建一张news表，表结构如下图：

ID是主键，并助是自动增长列。
2、 现在，我们用O/R Designer来创建news表的LINQ To SQL的实体类。
创建一个名为MvcCompany的ASP.NET MVC Web Application项目，然后选中Models，右键，“添加”，“新建项”，选中C#中的“数据”，如下图：

选择“LINQ to SQL类”，名称设为“CompanyData.dbml”，然后“添加”。
打开“服务器资源管理器”，创建连接，展开表，找到news表，拖到CompanyData.dbml的左边表视图区（注：.dbml视图左边是SQL表和SQL视图区，右边是SQL存储过程和SQL函数区），效果如下图：

在“解决方案资源管理器”下的，“Models”多了三个文件，CompanyData.dbml，展开它，会有CompanyData.dbml.layout和CompanyData.designer.cs，前者是CompanyData.dbml视图的一些信息（比如news表在的坐标等信息），后者是news实体类及Data_Company数据库的类，在数据库类中聚合了news实体类。
3、 添加news列表类。因为一个news实体类，一次只能表示一条记录，如果呈现一个news表中的数据，最好定义一个集合类来存临时来存放news记录的集合。
类的实现如下：



http://www.cnblogs.com/axzxs2001/archive/2009/09/08/1562757.html