jsp实现分页显示信息（数据库、EL表达式、连接池）

最新推荐文章于 2024-06-24 19:02:23 发布

ruiguang21

最新推荐文章于 2024-06-24 19:02:23 发布

阅读量1.8k

点赞数

本文链接：https://blog.csdn.net/ruiguang21/article/details/53612513

版权

一、准备工作

1.1在mysql数据库中你建立学生的表

1.2细节：

    1.2.0. 先导入musql的jar包
    1.2.1. 性别一般用枚举型
    1.2.2. 要将表转储sql文件，放在web项目额web-info下面
    1.2.3. 在删除sql文件中的一些信息时，会出现中文乱码问题，这时候一定不要保存，先“右键”sql文件，把字符集修改为
    1.2.4. 因为要用到连接池，先把context.xml放到meta-info下面

准备工作

数据库

二、javabean（属性私有化、do/get方法、空参构造函数、带参构造函数）：

package com.bright.bean;

public class Student {

    private int id;
    private String name;
    private String sex;
    private String clazz;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getClazz() {
        return clazz;
    }
    public void setClazz(String clazz) {
        this.clazz = clazz;
    }

    public Student() {
        super();
    }

    public Student(int id, String name, String sex, String clazz) {
        super();
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.clazz = clazz;
    }
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

三、学生信息初始化（将信息存入到数据库中，有了这个就不需要sql文件了）

package init;

import java.sql.*;
import java.util.Random;
import com.bright.bean.*;

public class StudentInit {

    public static void main(String[] args) {
        //连接数据库（用JDBC连接）
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn=DriverManager.getConnection("jdbc:mysql:///student", "root", "123");
            PreparedStatement stat=conn.prepareStatement("insert into student values (null,?,?,?)");//因为id是自增长的

            //假设有88个学生，每个班20人，分成了5个班（外循环控制班级，内循环控制每个班的学生人数20人）
            for (int i = 1; i < 6; i++) 
            {
                for(int j=1;j<21;j++)
                {
                    String sex="男";
                    //生成一个随机整数
                    if(new Random().nextInt()%2==0)
                    {
                        sex="女";
                    }

                    Student stu=new Student(0, i+"班的"+j+"号学生", sex, i+"班");

                    //存储
                    stat.setString(1, stu.getName());
                    stat.setString(2, stu.getSex());
                    stat.setString(3, stu.getClazz());

                    stat.executeUpdate();

                    //循环到最后一个人了就退出循环
                    if(i==5&&j==8)
                    {
                        break;
                    }
                }
            }
            conn.close();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

四、servlet处理数据（分页一般用get处理）：

package com.bright.servlet;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;

import com.bright.bean.Student;


public class PageServlet extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        //声明四个参数
        long rows=0;    //数据总数（可能比较长，就定义为了long）
        int size=10;    //每一页显示的记录条数
        int page=1;     //当前第几页
        int pageCount=0;//一共有多少页

        String pn=request.getParameter("page");//通过参数获取page（当前是第几页）

        //得到当前是第几页
        if(pn!=null && pn.length()>0)
        {
            try {
                page=Integer.parseInt(pn);      //进行类型转换（得到的是一个字符串）
            } catch (NumberFormatException e) {
                e.printStackTrace();
                page=1;                         //如过又错，就返回第一页得到信息
            }
        }

        //使用连接池
        try {
            InitialContext initCtx = new InitialContext();
            Context ctx=(Context) initCtx.lookup("java:comp/env");
            DataSource ds=(DataSource) ctx.lookup("jdbcmysql");

            Connection conn=ds.getConnection();

            PreparedStatement stat=conn.prepareStatement("select count(*) as rows from student");//先从数据库中取到所有的数据

            ResultSet rs=stat.executeQuery();//将查询到的结果放到结果集中

            //有下一条
            if(rs.next())
            {
                rows=rs.getLong("rows");//得到数据总数
            }

            //计算pageCount（总页数）
            if(rows%size==0)
            {
                pageCount=(int)(rows/size);
            }else{
                pageCount=(int)(rows/size)+1;
            }

            //将查询到的数据放到List集合中
            List<Student> list=new ArrayList<Student>();

            //使用SQL进行分页(两个问号分别代表每一页的开头和结尾)
            stat=conn.prepareStatement("select * from student limit ?,?");
            stat.setInt(1,(page-1)*size);//每一页的开头
            stat.setInt(2, size);//每一页的结尾

            rs=stat.executeQuery();

            while(rs.next())
            {
                Student s=new Student();
                s.setId(rs.getInt(1));      
                s.setName(rs.getString(2));
                s.setSex(rs.getString(3));
                s.setClazz(rs.getString(4));

                list.add(s);
            }

            conn.close();

            //将数据发送给JSP页面，并实现转发
            request.setAttribute("list", list);
            request.setAttribute("pageCount", pageCount);//总页数
            request.setAttribute("page", page);//当前显示页

            request.getRequestDispatcher("/page.jsp").forward(request, response);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

五（1）、配置文件XML：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name></display-name>
  <servlet>
    <servlet-name>PageServlet</servlet-name>
    <servlet-class>com.bright.servlet.PageServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>PageServlet</servlet-name>
    <url-pattern>/ps</url-pattern>
  </servlet-mapping>    
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

五（2）、连接池连接的文件：

<?xml version="1.0" encoding="UTF-8"?>
<Context>

<!-- 
    name: jndi中的名字，servlet中，就通过该名字获取数据源
    type： 对象的类型
    maxActive： 最大活动连接数（没有被使用的连接数）
    maxIdle： 最大连接数
    maxWait： 如果没有连接，等待连接的时间，-1表示无限等待
    ....
 -->
    <Resource
        name="jdbcmysql"
        auth="Container"    
        type="javax.sql.DataSource"
        maxActive="5"
        maxIdle="5"
        maxWait="-1"
        driverClassName="com.mysql.jdbc.Driver"
        username="root"
        password="123"
        url="jdbc:mysql:///student"/>//student是数据库的名称
</Context>


 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

六、静态页面（用jsp显示）

6.1.

<%@ page language="java" import="java.util.*"  contentType="text/html; charset=utf-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
  </head>

  <body>
    <center>
        <table border="1" cellpadding="0" cellspacing="0" width="50%">
            <caption>学生信息显示</caption>
            <tr>
                <th>序号</th>
                <th>ID</th>
                <th>姓名</th>
                <th>性别</th>
                <th>班级</th>
            </tr>

        <c:choose>
                <c:when test="${empty list}">
                    <tr>
                        <td colspan="5">没有学生信息</td>
                    </tr>
                </c:when>

            <c:otherwise>
                <c:forEach items="${list}" var="st" varStatus="index">
                    <tr>
                        <td>${index.count}</td>
                        <td>${st.id}</td>
                        <td>${st.name}</td>
                        <td>${st.sex}</td>
                        <td>${st.clazz}</td>
                    </tr>
                </c:forEach>

                <tr>
                    <td colspan="5">
                        <c:if test="${!(page==1)}">
                            <a href="ps?page=${page-1 }">上一页</a>
                        </c:if>

                        <c:forEach var="p" begin="1" end="${pageCount }">
                            <a href="ps?page=${p}">第${p}页</a>
                        </c:forEach>

                        <c:if test="${!(page==pageCount)}">
                            <a href="ps?page=${page+1 }">下一页</a>
                        </c:if>

                    </td>
                </tr>
            </c:otherwise>  
            </c:choose>
        </table>
    </center>
  </body>
</html>

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

6.2. 细节：
①使用了EL表达式，在page中要有

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 
 1
 
 1

②表格的第一列要有编号

③<c:choose>中有<c:when>可有多个和<c:otherwise>，<c:otherwise>中有<forEach>

七、运行结果(部分)：

第一页
第二页
最后一页

八、小结

1、通过http:localhost:8080/pagination/ps（这时候访问的是servlet）

2、servlet中的思路：
（1）连接数据库，从数据库中查询到所有数据，进行预处理，将查询到的所有数据方法哦结果集中–>知道数据总数rows
（2）根据数据总数，通过公式就可以得到总页数pageCount
（3）通过sql语句进行分页（这时候有两个未知量，一个是每一页的起始位置，另一个是每一页的结尾）

    ①通过sql语句查询数据库--->进行预处理（有几个问好就存储几个数据）
    ②将查询到的结果放到结果集中
    ③如果有下一条，就取出查询到的所有数据，给stu赋值
    ④将stu添加到集合中
（4）将集合，总页数，当前页数放到request中
（5）进行重定向（就跳转到jsp页面显示数据了）

ruiguang21

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
jsp实现分页显示信息（数据库、EL表达式、连接池）

一、准备工作1.1在mysql数据库中你建立学生的表1.2细节： 1.2.0. 先导入musql的jar包 1.2.1. 性别一般用枚举型 1.2.2. 要将表转储sql文件，放在web项目额web-info下面 1.2.3. 在删除sql文件中的一些信息时，会出现中文乱码问题，这时候一定不要保存，先“右键”sql文件，把字符集修改为 1.
复制链接

扫一扫