JavaWeb分页技术总结

分页技术：将所有数据分段展示给用户的技术。 分页的意义：增加系统的复杂度，另外可以将大量的数据限制在某一个特定的范围。 选择分页的标准： 首先，判断的标准是速度,显而易见,数据库服务器,Web应用服务器和客户端之间是网络,如果网络传递的数据量越少,则客户端获得响应的速度越快。一般来说,数据库服务器和Web应用服务器的处理能力一般比客户端要强很多.从这两点来看,在客户端分页的方案是最不可取的。 其次，在Web服务器端分页和在数据库端分页,如果选择在Web服务器端分页的话,大部分的被过滤掉的数据还是被传输到了Web应用服务器端,与其这样还不如直接在数据库端进行分页。 因此比较好的分页做法应该是每次翻页的时候只从数据库里检索页面大小的块区的数据。 虽然每次翻页都需要查询数据库，但查询出的记录数很少，网络传输数据量不大，如果使用连接池更可以略过最耗时的建立数据库连接过程。而在数据库端有各种成熟的优化技术用于提高查询速度，比在应用服务器层做缓存有效得多。 Web服务器端分页和在数据库端分页： 数据库端分页：通过JDBC的方式访问数据库，根据数据库类型采取不同的SQL分页语句。 对于MySql数据库：采用limit m,n语句进行分页，需要指定m和n的2个值 Limit后的两个参数中，参数m是起始下标[页码]，它从0开始；参数n是返回的记录数。 SQL语句形式：

1  语句1: select * from 表名 limit m,n; --返回表中m-n行的数据
2  语句2: select * from 表名 limit m offset n; --从n行开始到返回表中m行的数据
3  假设 numberpage 表示每页要显示的条数,pagenumber表示页码:
4  语句3：select * from 表名 limit (pagenumber-1)*numberpage,numberpage;
5  语句4：select * from 表名 limit numberpage offset(pagenumber-1)*numberpage;

对于Oracle数据库：采用rownum的方式进行分页,rownum表示一条记录的行号,注意Oracle获取每一行后才赋予.因此,指定rownum区间来取得分页数据在一层查询语句中是无法做到的,要分页还要进行一次查询。 SQL形式：

1  select * from (
2    select page.*,rownum rn 
3    from (select * from 表名) page 
4    where rownum <= (?-1)*?+?)
5    where rn > (?-1)*?;
6
7
8  --其中page是将表中的数据查询出来取名为page

另外,不论使用哪种数据库，都的想知道数据中有几条数据，自然需要一个获取总行的SQL： SQL形式：

 select count(*) from 表名;

首先：实现分页的具体实现需要结合JDBC和Java代码实现： 分页的时，返回的参数包括查询的结果集(List)，总的页数(pageCount)、当前第几页(pageNo)等等信息，所以我们封装一个查询结果Page类，当然还需要分页的一个实体类，这里我以Entity为例，具体代码：

1Page.java:
2//第一种实现方式：
3import java.util.List;
4import entity.Entity;
5public class Page {
6private int pageNo;//当前页数
7private int hangCount;//每页显示的行数
8private int sumCount;//总条数
9private int sumPage;//总页数
10         private List<Entity>  entitys;//需要生成setXX()和getXX()方法
11public int getPageNo() {
12return pageNo;
13}
14public void setPageNo(int pageNo) {
15//给当前页赋值
16if (pageNo<=1) {
17   this.pageNo=1;
18}else if (pageNo>=this.sumPage) {
19this.pageNo=this.sumPage;
20}else {
21this.pageNo = pageNo;
22
23}
24}
25public int getHangCount() {
26return hangCount;
27}
28public void setHangCount(int hangCount) {
29this.hangCount = hangCount;
30}
31public int getSumCount() {
32return sumCount;
33}
34public void setSumCount(int sumCount) {
35this.sumCount = sumCount;
36if(this.sumCount%this.hangCount==0){
37this.sumPage = this.sumCount/this.hangCount;
38}
39else{
40this.sumPage = this.sumCount/this.hangCount+1;
41}
42}
43public int getSumPage() {
44return sumPage;
45}
46public void setSumPage(int sumPage) {
47this.sumPage = sumPage;
48}
49//List<Entity>  entitys 生成的setXX()和getXX()方法
50
51}
52//第二种实现方式：
53import java.util.List;
54import entity.Entity;
55public class Page {
56private int pageNo;//当前页数
57private int hangCount;//每页显示的行数
58private int sumCount;//总条数
59private int sumPage;//总页数
60         private List<Entity>  entitys;//需要生成setXX()和getXX()方法
61public int getPageNo() {
62return pageNo;
63}
64public void setPageNo(int pageNo) {
65  this.pageNo = pageNo;  
66}
67public int getHangCount() {
68return hangCount;
69}
70public void setHangCount(int hangCount) {
71this.hangCount = hangCount;
72}
73public int getSumCount() {
74return sumCount;
75}
76public void setSumCount(int sumCount) {
77this.sumCount = sumCount;
78setSumPage((getSumCount()%hangCount)==0?(getSumCount()/hangCount):(getTotalNum() /hangCount+1));  
79}
80public int getSumPage() {
81return sumPage;
82}
83public void setSumPage(int sumPage) {
84this.sumPage = sumPage;
85}
86   // 获取首页  
87    public int getFirstPage() {  
88        return 1;  
89    }  
90    // 获取末页  
91    public int getLastPage() {  
92        return sumPage;  
93    }  
94
95    // 获取上一页  
96    public int getPrePage() {  
97        if (pageNo > 1)  
98            return pageNo - 1;  
99        return 1;  
100    }  
101    // 获取下一页  
102    public int getBackPage() {  
103        if (pageNo<sumPage)  
104            return pageNo + 1;  
105        return sumPage;  
106    }  
107    // 判断'首页'及‘上一页’是否可用  
108    public String isPreable() {  
109        if (pageNo == 1)  
110            return "disabled";  
111        return "";  
112    }  
113    // 判断'尾页'及‘下一页’是否可用  
114    public String isBackable() {  
115        if (pageNo == totalPage)  
116            return "disabled";  
117        return "";  
118     }  
119//List<Entity>  entitys 生成的setXX()和getXX()方法
120}

其次：编写数据数据连接类，以BaseDao为例，具体代码： 数据库驱动类名：oracle.jdbc.driver.OracleDriver 数据库连接URL：jdbc:oracle:thin:@localhost:1521:连接名 数据库用户名和密码：userName，passWord

1//BaseDao.java
2第一种方式：
3import java.sql.Connection;  
4import java.sql.DriverManager;  
5import java.sql.PreparedStatement;  
6import java.sql.ResultSet;  
7import java.sql.SQLException;  
8public class BaseDao{ 
9        //使用ThreadLocal是为了保证事务的一致，使得同一个线程的所有数据库操作使用同一个Connection 
10    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();  
11    public static Connection getConnection() {  
12        Connection conn = null;  
13        conn = threadLocal.get();  
14        if (conn == null) {  
15            try {  
16                Class.forName("数据库驱动类名");  
17           conn = DriverManager.getConnection(  
18           "数据库连接URL", "用户名","密码");  
19                threadLocal.set(conn);  
20            } catch (ClassNotFoundException e) {  
21                e.printStackTrace();  
22            } catch (SQLException e) {  
23                e.printStackTrace();  
24            }  
25        }  
26        return conn;  
27    }  
28
29    // 封装设置Connection自动提交  
30    public static void setAutoCommit(Connection conn, Boolean flag) {  
31        try {  
32            conn.setAutoCommit(flag);  
33        } catch (SQLException e) {  
34            e.printStackTrace();  
35        }  
36    }  
37
38    // 设置事务提交  
39    public static void commit(Connection conn) {  
40        try {  
41            conn.commit();  
42        } catch (SQLException e) {  
43            e.printStackTrace();  
44        }  
45    }  
46
47    // 封装设置Connection回滚  
48    public static void rollBack(Connection conn) {  
49        try {  
50            conn.rollback();  
51        } catch (SQLException e) {  
52            e.printStackTrace();  
53        }  
54    }  
55
56    // 封装关闭Connection、PreparedStatement、ResultSet的函数  
57    public static void closeConnection() {  
58        Connection conn = threadLocal.get();  
59        try {  
60            if (conn != null) {  
61                conn.close();  
62                conn = null;  
63                threadLocal.remove();  
64            }  
65        } catch (SQLException e) {  
66            e.printStackTrace();  
67        }  
68
69    }  
70      //关闭PreparedStatement
71    public static void closePreparedStatement(PreparedStatement pstmt) {  
72        try {  
73            if (pstmt != null) {  
74                pstmt.close();  
75                pstmt = null;  
76            }  
77        } catch (SQLException e) {  
78            e.printStackTrace();  
79        }  
80    }  
81      //关闭ResultSet
82    public static void closeResultSet(ResultSet rs) {  
83        try {  
84            if (rs != null) {  
85                rs.close();  
86                rs = null;  
87            }  
88        } catch (SQLException e) {  
89            e.printStackTrace();  
90        }  
91    }  
92    //公共的增删改方法
93public int allUpdateAndAddAndDel(List<Object> list,String sql){
94try {
95conn=getConnection();
96ps=conn.prepareStatement(sql);
97if(list.size()>0){
98for (int i = 0; i < list.size(); i++) {
99ps.setObject((i+1), list.get(i));
100}
101}
102return ps.executeUpdate();
103} catch (Exception e) {
104e.printStackTrace();
105return -1;
106}
107finally{
108closeAll();
109}
110}
111//查询公共方法
112    public ResultSet select(String sql,List<Object> list) {
113  try {
114  conn=getConnection();
115  ps=conn.prepareStatement(sql);
116  if (list.size()>0) {
117for (int i = 0; i < list.size(); i++) {
118ps.setObject((i+1), list.get(i));
119}
120}
121  rs=ps.executeQuery();
122
123  return rs;  
124} catch (Exception e) {
125e.printStackTrace();
126return null;  
127}
128}
129}

第二种方式：

1import java.sql.Connection;
2import java.sql.DriverManager;
3import java.sql.PreparedStatement;
4import java.sql.ResultSet;
5import java.util.List;
6
7public class BaseDao {
8private String name="用户名";
9private String pwd="密码";
10private String drivername="数据库驱动名";
11private String url="数据库连接URL";
12public Connection conn = null;
13public PreparedStatement ps = null;
14public ResultSet rs = null;
15
16/**
17* 关闭所有接口对象的方法
18*/
19public void closeAll(){
20try {
21if(rs!=null)rs.close();
22if(ps!=null)ps.close();
23if(conn!=null)conn.close();
24} catch (Exception e) {
25e.printStackTrace();
26}
27}
28/**
29* 获取连接对象的方法
30*/
31public Connection getConnection(){
32try {
33Class.forName(drivername);
34conn = DriverManager.getConnection(url, name, pwd);
35return conn;
36} catch (Exception e) {
37e.printStackTrace();
38return null;
39}
40}
41// 封装设置Connection自动提交  
42    public static void setAutoCommit(Connection conn, Boolean flag) {  
43        try {  
44            conn.setAutoCommit(flag);  
45        } catch (SQLException e) {  
46            e.printStackTrace();  
47        }  
48    }  
49
50    // 设置事务提交  
51    public static void commit(Connection conn) {  
52        try {  
53            conn.commit();  
54        } catch (SQLException e) {  
55            e.printStackTrace();  
56        }  
57    }  
58
59    // 封装设置Connection回滚  
60    public static void rollBack(Connection conn) {  
61        try {  
62            conn.rollback();  
63        } catch (SQLException e) {  
64            e.printStackTrace();  
65        }  
66    }  
67
68    // 封装关闭Connection、PreparedStatement、ResultSet的函数  
69    public static void closeConnection() {  
70        Connection conn = threadLocal.get();  
71        try {  
72            if (conn != null) {  
73                conn.close();  
74                conn = null;  
75                threadLocal.remove();  
76            }  
77        } catch (SQLException e) {  
78            e.printStackTrace();  
79        }  
80
81    }  
82//公共的增删改方法
83public int allUpdateAndAddAndDel(List<Object> list,String sql){
84try {
85conn=getConnection();
86ps=conn.prepareStatement(sql);
87if(list.size()>0){
88for (int i = 0; i < list.size(); i++) {
89ps.setObject((i+1), list.get(i));
90}
91}
92return ps.executeUpdate();
93} catch (Exception e) {
94e.printStackTrace();
95return -1;
96}
97finally{
98closeAll();
99}
100}
101//查询公共方法
102    public ResultSet select(String sql,List<Object> list) {
103  try {
104  conn=getConnection();
105  ps=conn.prepareStatement(sql);
106  if (list.size()>0) {
107for (int i = 0; i < list.size(); i++) {
108ps.setObject((i+1), list.get(i));
109}
110}
111  rs=ps.executeQuery();
112
113  return rs;  
114} catch (Exception e) {
115e.printStackTrace();
116return null;  
117}
118}
119}

利用Jsp/Servlet实现： 以实体类User为例，需要UserInfo.java:

1//UserInfo.java
2import java.util.Date;  
3public class UserInfo {  
4    private int id;  
5    private String username;  
6    private String password;  
7    private String truename;  
8    private String sex;  
9    private Date birthday;  
10    private String home;  
11    private String colleage;  
12    private String comingYear;  
13
14    public int getId() {  
15        return id;  
16    }  
17
18    public void setId(int id) {  
19        this.id = id;  
20    }  
21
22    public String getUsername() {  
23        return username;  
24    }  
25
26    public void setUsername(String username) {  
27        this.username = username;  
28    }  
29
30    public String getPassword() {  
31        return password;  
32    }  
33
34    public void setPassword(String password) {  
35        this.password = password;  
36    }  
37
38    public String getTruename() {  
39        return truename;  
40    }  
41
42    public void setTruename(String truename) {  
43        this.truename = truename;  
44    }  
45
46    public String getSex() {  
47        return sex;  
48    }  
49
50    public void setSex(String sex) {  
51        this.sex = sex;  
52    }  
53
54    public Date getBirthday() {  
55        return birthday;  
56    }  
57
58    public void setBirthday(Date birthday) {  
59        this.birthday = birthday;  
60    }  
61
62    public String getHome() {  
63        return home;  
64    }  
65
66    public void setHome(String home) {  
67        this.home = home;  
68    }  
69
70    public String getColleage() {  
71        return colleage;  
72    }  
73
74    public void setColleage(String colleage) {  
75        this.colleage = colleage;  
76    }  
77
78    public String getCy() {  
79        return comingYear;  
80    }  
81
82    public void setCy(String cy) {  
83        this. comingYear= cy;  
84    }  
85}

在dao层实现：

1import java.sql.Connection;  
2import java.sql.PreparedStatement;  
3import java.sql.ResultSet;  
4import java.sql.SQLException;  
5import java.util.ArrayList;  
6import java.util.List;  
7import entity.UserInfo;  
8import entity.BaseDao;   
9public class UserInfoDao {  
10    public List<UserInfo> getUserList(UserInfo userInfo, int pageNo,  
11            int hangCount ) throws Exception {  
12        PreparedStatement pstmt = null;  
13        ResultSet rs = null;  
14        List<UserInfo> userList = null;  
15        try {  
16            String sql = "select * from(select rownum num,u.* from(select * from user_info where sex = ? and home like '"  
17                    + userInfo.getHome()  
18                    + "%"  
19                    + "' and colleage like '"  
20                    + userInfo.getColleage()  
21                    + "%"  
22                    + "' and comingyear like '"  
23                    + userInfo.getCy()  
24                    + "%"  
25                    + "' order by id) u where rownum<=?) where num>=?";  
26            userList = new ArrayList<UserInfo>();  
27            Connection conn = BaseDao.getConnection();  
28            pstmt = conn.prepareStatement(sql);  
29            pstmt.setString(1, userInfo.getSex());  
30            pstmt.setInt(2, pageNo * hangCount);  
31            pstmt.setInt(3, (pageNo - 1) * hangCount + 1);  
32            rs = pstmt.executeQuery();  
33            while (rs.next()) {  
34                UserInfo user = new UserInfo();  
35                user.setId(rs.getInt("id"));  
36                user.setTruename(rs.getString("truename"));  
37                user.setSex(rs.getString("sex"));  
38                user.setHome(rs.getString("home"));  
39                userList.add(user);  
40            }  
41        } catch (SQLException e) {  
42            e.printStackTrace();  
43            throw new Exception(e);  
44        } finally {  
45            BaseDao.closeResultSet(rs);  
46            BaseDao.closePreparedStatement(pstmt);  
47        }  
48        return userList;  
49    }  
50
51    public int getTotalNum(UserInfo userInfo) throws Exception {  
52        PreparedStatement pstmt = null;  
53        ResultSet rs = null;  
54        int count = 0;  
55        try {  
56            String sql = "select count(*) from user_info where sex=? and home like '"  
57                    + userInfo.getHome()  
58                    + "%"  
59                    + "' and colleage like '"  
60                    + userInfo.getColleage()  
61                    + "%"  
62                    + "' and comingyear like '"  
63                    + userInfo.getCy()+ "%" + "'";  
64            Connection conn = BaseDao.getConnection();  
65            pstmt = conn.prepareStatement(sql);  
66            pstmt.setString(1, userInfo.getSex());  
67            rs = pstmt.executeQuery();  
68            if (rs.next()) {  
69                count = rs.getInt(1);  
70            }  
71        } catch (SQLException e) {  
72            e.printStackTrace();  
73            throw new Exception(e);  
74        } finally {  
75            BaseDao.closeResultSet(rs);  
76             BaseDao.closePreparedStatement(pstmt);  
77        }  
78        return count;  
79    }  
80}
81在service层：
82import java.sql.Connection;  
83import util.BaseDao;  
84import util.Page;  
85public class UserInfoManage {  
86    private UserInfoDao userInfoDao = null;  
87
88    public UserInfoManage () {  
89        userInfoDao = new UserInfoDao();  
90    }  
91
92    public Page userBasicSearch(UserInfo u, int pageNo,  
93            int hangCount) throws Exception {  
94        Connection connection = null;  
95        Page pagination = new Page();  
96        try {  
97            connection = BaseDao.getConnection();  
98            DBUtility.setAutoCommit(connection, false);  
99            pagination.setList(userInfoDao.getUserList(u, pageNo, hangCount));  
100            pagination.setPageNo(pageNo);  
101            pagination.setHangCount(hangCount);  
102            pagination.setSumCount(userInfoDao.getTotalNum(u));  
103            BaseDao.commit(connection);  
104        } catch (Exception e) {  
105            DBUtility.rollBack(connection);  
106            e.printStackTrace();  
107            throw new Exception();  
108        } finally {  
109            BaseDao.closeConnection();  
110        }  
111        return pagination;  
112    }  
113}

在Servlet:

1import java.io.*;  
2import java.util.*;   
3import javax.servlet.ServletConfig;  
4import javax.servlet.ServletException;  
5import javax.servlet.http.HttpServlet;  
6import javax.servlet.http.HttpServletRequest;  
7import javax.servlet.http.HttpServletResponse;  
8
9import entity.UserInfo;  
10import service.UserInfoManage;  
11import util.Page;  
12
13public class UserBasicSearchServlet extends HttpServlet {  
14    private static final long serialVersionUID = 1L;  
15    private int hangCount = 0;  
16
17    @Override  
18    public void init(ServletConfig config) throws ServletException {  
19        hangCount = Integer.parseInt(config.getInitParameter("hangCount"));  
20    }  
21    @Override  
22    protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
23            throws ServletException, IOException {  
24        doPost(req, resp);  
25    }  
26
27    @Override  
28    protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
29            throws ServletException, IOException {  
30        // 1.取得页面参数并构造参数对象  
31        int pageNo = Integer.parseInt(req.getParameter("pageNo"));  
32        String sex = req.getParameter("gender");  
33        String home = req.getParameter("newlocation");  
34        String colleage = req.getParameter("colleage");  
35        String comingyear = req.getParameter("ComingYear");  
36
37        UserInfo u = new UserInfo();  
38        u.setSex(sex);  
39        u.setHome(home);  
40        u.setColleage(colleage);  
41        u.setCy(comingyear);  
42
43        // 2.调用业务逻辑取得结果集  
44        UserInfoManage userInfoManage = new UserInfoManage();  
45        PageModel<UserInfo> pagination = userInfoManage.userBasicSearch(u,  
46                pageNo, pageSize);  
47        List<UserInfo> userList = pagination.getList();  
48
49        // 3.封装返回结果  
50        StringBuffer resultXML = new StringBuffer();  
51        try {  
52            resultXML.append("<?xml version='1.0' encoding='gb18030'?>/n");  
53            resultXML.append("<root>/n");  
54            for (Iterator<UserInfo> iterator = userList.iterator(); iterator  
55                    .hasNext();) {  
56                UserInfo userInfo = iterator.next();  
57                resultXML.append("<data>/n");  
58                resultXML.append("/t<id>" + userInfo.getId() + "</id>/n");  
59                resultXML.append("/t<truename>" + userInfo.getTruename()  
60                        + "</ truename >/n");  
61                resultXML.append("/t<sex>" + userInfo.getSex() + "</sex>/n");  
62                resultXML.append("/t<home>" + userInfo.getHome() + "</home>/n");  
63                resultXML.append("</data>/n");  
64            }  
65            resultXML.append("<pagination>/n");  
66            resultXML.append("/t<total>" + pagination.getTotalPage()  
67                    + "</total>/n");  
68            resultXML.append("/t<start>" + pagination.getFirstPage()  
69                    + "</start>/n");  
70            resultXML.append("/t<end>" + pagination.getLastPage() + "</end>/n");  
71            resultXML.append("/t<pageno>" + pagination.getPageNo()  
72                    + "</pageno>/n");  
73            resultXML.append("</pagination>/n");  
74
75            resultXML.append("</root>/n");  
76        } catch (Exception e) {  
77            e.printStackTrace();  
78        }  
79        writeResponse(req, resp, resultXML.toString());  
80
81    }  
82
83    public void writeResponse(HttpServletRequest request,  
84            HttpServletResponse response, String result) throws IOException {  
85        response.setContentType("text/xml");  
86        response.setHeader("Cache-Control", "no-cache");  
87        response.setHeader("Content-Type", "text/xml; charset=gb18030");  
88        PrintWriter pw = response.getWriter();  
89        pw.write(result);  
90        pw.close();  
91    }  
92}

利用SSH实现： 在dao层编写getSumCount()和List<Student> getStuByPage(Integer pageNo, Integer pageCount)2个方法： 有2种方法： 第一种：使用普通的分页方法

1//实现获取总行数的方法
2 import org.hibernate.HibernateException;
3 import org.hibernate.Session;
4 import org.hibernate.Query;
5 private BaseUtil baseUtil;//需要生成setXX()和getXX()方法
6 public Integer getSumCount() {
7     //获取session
8Session session = baseUtil.getHibernateTemplate().getSessionFactory().openSession();
9//执行查询，调用查询结果唯一的uniqueResult()方法;
10Object object =session.createQuery("select count(别名.id) from 类名 别名 ").uniqueResult();
11//根据数据类型确定返回值，类型不对时需要强制转换
12return Integer.valueOf(object.toString());
13}
14//实现分页的方法
15public List<Entity> getEntityByPage(Integer pageNo, Integer pageCount) {
16Session session = baseUtil.getHibernateTemplate().getSessionFactory().openSession();
17Query query = session.createQuery("from 类名 别名 ");
18query.setMaxResults(pageCount);
19return query.setFirstResult((pageNo-1)*pageCount).list();
20}

第二种：使用Spring框架提供的方法

1import org.hibernate.HibernateException;
2  import org.springframework.orm.hibernate3.HibernateCallback;
3  import org.hibernate.Query;
4  //实现获取总行数的方法
5 public Integer getSumCount() {
6Object obj = baseUtil.getHibernateTemplate().execute(new HibernateCallback() {
7public Object doInHibernate(Session session){
8Query query = session.createQuery("select count(别名.id) from 类名 别名 ");
9Object object = query.uniqueResult();
10return object;
11}
12});
13return Integer.valueOf(obj.toString());
14}
15  //实现分页的方法
16  getEntityByPage(final Integer pageNo, final Integer pageCount)：方法内的变量必须是final
17public List<Entity> getEntityByPage(final Integer pageNo, final Integer pageCount) {
18List<Entity> entitys = baseUtil.getHibernateTemplate().executeFind(new HibernateCallback() {
19public Object doInHibernate(Session session){
20Query query = session.createQuery("from 类名 别名");
21query.setMaxResults(pageCount);
22query.setFirstResult((pageNo-1)*pageCount);
23return query.list();
24}
25});
26return entitys ;
27}

在service层中：

在action层中：

1//EntityAction.java
2import service.EntityService;
3import util.Page;
4import com.opensymphony.xwork2.ActionSupport;
5public class EntityAction extends ActionSupport {
6private EntityService EntityService;//需要生成setXX()方法
7private Page page;//当前页，需要生成setXX()和getXX()方法
8private Integer pageNo=1;//当前页数，需要生成setXX()和getXX()方法
9private Integer pageCount=2;//每页显示行数，需要生成setXX()和getXX()方法
10@SuppressWarnings("unchecked")
11@Override
12public String execute() throws Exception {
13page=entityService.getEntityByPage(pageNo, pageCount);
14return SUCCESS;
15}
16 //EntityService.java
17private Page page;//需要生成setXX()和getXX()方法
18  private Integer pageNo=1；
19  private Integer pageCount=1；
20  public Page getEntityByPage(Integer pageNo, Integer pageCount) {
21if(page==null){
22page=new Page();
23}
24page.setHangCount(pageCount);
25page.setSumCount(stuDao.getSumCount());
26page.setPageNo(pageNo);
27page.setEntitys(stuDao.getEntityByPage(page.getPageNo(), page.getHangCount()));
28return page;
29}
30

最后在jsp页面：

1<div class=pager>
2*   [首页](form表单action名?pageNo=1)
3*   [上一页](form表单action名?pageNo=${page.pageNo-1})
4*   [下一页](form表单action名?pageNo=${page.pageNo+1})
5*   [末页](form表单action名?pageNo=${page.sumPage})
6</div>

综上所述，分页功能可以基本实现。