前言
最近发现很多出入Java开发行业的小伙伴对于SSM框架基于Mysql的分页有些模糊，今天就分页做了一个简单的案例，希望能够帮到大家，如有不足的地方，还请提出宝贵的建议。
闲话少叙，接下来我们来具体看看，为了让大家看的比较明白点，我以一个完整的案例演示：
1、环境配置：
jdk7.0+tomcat7.0+MyEclipse2014+MySql5.7
2、数据库表结构：
/*
Navicat MySQL Data Transfer
Source Host : localhost:3306
Source Database : mybatis
Target Host : localhost:3306
Target Database : mybatis
Date: 2018-03-12 15:47:53
*/
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(32) NOT NULL COMMENT '用户名称',
`password` varchar(32) NOT NULL DEFAULT '',
`birthday` date DEFAULT NULL COMMENT '生日',
`sex` char(1) DEFAULT NULL COMMENT '性别',
`address` varchar(256) DEFAULT NULL COMMENT '地址',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=26 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', '小明', '123', '2017-06-08', '2', '陕西省西安市碑林区');
INSERT INTO `user` VALUES ('2', '小红', '123', '2017-06-08', '1', '陕西省西安市长安区');
INSERT INTO `user` VALUES ('3', '小花', '123', '2017-06-08', '1', '陕西省西安市未央区');
INSERT INTO `user` VALUES ('4', '小苗', '123', '2017-06-08', '1', '陕西省西安市新城区');
INSERT INTO `user` VALUES ('5', '小丽', '123', '2017-06-08', '1', '陕西省宝鸡市凤县');
INSERT INTO `user` VALUES ('6', '小娟', '123', '2017-06-08', '1', '陕西省宝鸡市岐山县');
INSERT INTO `user` VALUES ('7', '小明', '123', '2017-06-08', '2', '陕西省西安市碑林区');
INSERT INTO `user` VALUES ('8', '小红', '123', '2017-06-08', '1', '陕西省西安市长安区');
INSERT INTO `user` VALUES ('9', '小花', '123', '2017-06-08', '1', '陕西省西安市未央区');
INSERT INTO `user` VALUES ('10', '小苗', '123', '2017-06-08', '1', '陕西省西安市新城区');
INSERT INTO `user` VALUES ('11', '小丽', '123', '2017-06-08', '1', '陕西省宝鸡市凤县');
INSERT INTO `user` VALUES ('12', '小娟', '123', '2017-06-08', '1', '陕西省宝鸡市岐山县');
INSERT INTO `user` VALUES ('13', '小明', '123', '2017-06-08', '2', '陕西省西安市碑林区');
INSERT INTO `user` VALUES ('14', '小红', '123', '2017-06-08', '1', '陕西省西安市长安区');
INSERT INTO `user` VALUES ('15', '小花', '123', '2017-06-08', '1', '陕西省西安市未央区');
INSERT INTO `user` VALUES ('16', '小苗', '123', '2017-06-08', '1', '陕西省西安市新城区');
INSERT INTO `user` VALUES ('17', '小丽', '123', '2017-06-08', '1', '陕西省宝鸡市凤县');
INSERT INTO `user` VALUES ('18', '小娟', '123', '2017-06-08', '1', '陕西省宝鸡市岐山县');
3、工程结构
在MyEclipse中新建JavaWeb工程“SSM_FenYe”，并进行如下配置：3.1、工程配置：
3.2、jar包管理
4、配置说明：
src：该目录下主要存放java代码，其中：
com.byzx.ssm.bean：管理java实体类;com.byzx.ssm.dao：持久层代码管理，主要完成对数据库的CRUD;
com.byzx.ssm.service：业务层代码管理，主要完成相关的业务处理；
com.byzx.ssm.action：控制层代码管理，主要完成模型跟视图之间的交互；
com.byzx.ssm.test：一般用来进行单元测试；
config：该目录下主要存放配置文件，其中：
db.properties： 配置数据库的driver、url、username、password；jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc\:mysql\://localhost\:3306/mybatis?characterEncoding\=utf-8 jdbc.username=root jdbc.password=rootlog4j.properties： 配置框架日志输出；
# Global logging configuration # developer-->DEBUG productor-->INFO or ERROR log4j.rootLogger=DEBUG, stdout # MyBatis logging configuration... 6 log4j.logger.org.mybatis.example.BlogMapper=TRACE # Console output... log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%nmybatis-config.xml： 主要进行mybatis框架的配置，我们一般会配置别名、mapper映射等。
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- 这是mybatis的主配置文件，跟spring整合后，dataSources交给spring配置 文件管理 -->
<configuration>
<!-- 配置访问别名-->
<typeAliases>
<package name="com.byzx.ssm.bean" />
</typeAliases>
<!-- 配置mappers映射文件 -->
<mappers>
<package name="com.byzx.ssm.dao" />
</mappers>
</configuration>
spring-beans.xml：
spring框架配置文件，主要用来配置dataSource、sqlSessionFactory、MapperScannerConfigurer等。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:annotation-config></context:annotation-config>
<!-- 配置service中的bean -->
<context:component-scan base-package="com.byzx.ssm.service"></context:component-scan>
<!-- spring配置文件，跟mybaits整合后，DataSource需要在这里配置 -->
<!-- 加载外部db.properties -->
<context:property-placeholder location="classpath:db.properties" />
<!-- 数据库连接池，两种方式，可以使用c3p0，这里我们使用的是dbcp -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="maxActive" value="10" />
<property name="maxIdle" value="5" />
</bean>
<!-- mapper配置 -->
<!-- 将mybatis中的写在代码中的sqlsessionfactory配置在 Spring配置文件中，交由spring管理，从而简化操作 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 数据库连接池 -->
<property name="dataSource" ref="dataSource" />
<!-- 加载mybatis的全局配置文件 -->
<property name="configLocation" value="classpath:mybatis-config.xml" />
</bean>
<!-- 这里主要配置mapper扫描器，我们只需要在使用的时候通过
@AutoWired直接访问dao层的接口就行 -->
<bean
class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.byzx.ssm.dao"></property>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
</bean>
</beans>
spring-mvc.xml：
springmvc框架配置文件，主要用来配置我们自身的Controller和视图解析器等。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 使用 mvc:annotation-driven代替注解映射器和注解适配器配置
mvc:annotation-driven默认加载很多的参数绑定方法，
比如json转换解析器就默认加载了，如果使用mvc:annotation-driven不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter
实际开发时使用mvc:annotation-driven
-->
<mvc:annotation-driven></mvc:annotation-driven>
<!-- 扫描所有的Controller -->
<context:component-scan base-package="com.byzx.ssm.action"></context:component-scan>
<!-- 配置视图解析器 进行jsp解析，默认使用jstl标签，classpath下得有jstl的包 -->
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver" />
<!-- 视图解析器
解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包
-->
<!-- <bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
配置jsp路径的前缀
<property name="prefix" value="/WEB-INF/jsp/"/>
配置jsp路径的后缀
<property name="suffix" value=".jsp"/>
</bean> -->
</beans>
web.xml：
位于工程WEB-INF下的web.xml文件，是整个JavaWeb工程的全局配置文件，我们可以在里面配置我们的欢迎界面，前端控制器等：
<?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>ssm-demo</display-name>
<!-- 项目默认的欢迎界面，本次用action访问，因此这里没有什么实质性意义 -->
<welcome-file-list>
<welcome-file>userList.jsp</welcome-file>
</welcome-file-list>
<!-- 配置spring容器，也就是配置：spring-beans.xml等 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-*.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 配置前端控制器，也就是配置：springmvc.xml进来 -->
<servlet>
<servlet-name>ssm-demo</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<!-- 配置拦截器 -->
<servlet-mapping>
<servlet-name>ssm-demo</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
<!-- 解决数据库响应中文乱码的问题 -->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
写到这里，文件配置算是完成了，接下来我们将进入到编码阶段。
5、主代码编写
User.java
在com.byzx.ssm.bean下新建User.java，要求跟数据库表字段一一对应（我们案例中使用的是resultType），示例如下：
扫描二维码关注公众号，回复：
360671 查看本文章
package com.byzx.ssm.bean;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable{
private static final long serialVersionUID = -6384316775494692203L;
private int id;//用戶ID
private String username;//用户名称
private Date birthday;//生日
private String sex;//性别
private String address;//住址
private String password;//密码
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", birthday="
+ birthday + ", sex=" + sex + ", address=" + address
+ ", password=" + password + "]";
}
}
Page.java
要完成分页功能，就需要准备一个分页的工具类，放在bean目录下：
package com.byzx.ssm.bean;
import java.io.Serializable;
/**
* 分页
*/
public class Page implements Serializable {
private static final long serialVersionUID = -3198048449643774660L;
private int pageNow = 1; // 当前页数
private int pageSize = 4; // 每页显示记录的条数
private int totalCount; // 总的记录条数
private int totalPageCount; // 总的页数
private int startPos; // 开始位置，从0开始
private boolean hasFirst;// 是否有首页
private boolean hasPre;// 是否有前一页
private boolean hasNext;// 是否有下一页
private boolean hasLast;// 是否有最后一页
/**
* 通过构造函数 传入 总记录数 和 当前页
*
* @param totalCount
* @param pageNow
*/
public Page(int totalCount, int pageNow) {
this.totalCount = totalCount;
this.pageNow = pageNow;
}
/**
* 取得总页数，总页数=总记录数/总页数
*
* @return
*/
public int getTotalPageCount() {
totalPageCount = getTotalCount() / getPageSize();
return (totalCount % pageSize == 0) ? totalPageCount
: totalPageCount + 1;
}
public void setTotalPageCount(int totalPageCount) {
this.totalPageCount = totalPageCount;
}
public int getPageNow() {
return pageNow;
}
public void setPageNow(int pageNow) {
this.pageNow = pageNow;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getTotalCount() {
return totalCount;
}
public void setTotalCount(int totalCount) {
this.totalCount = totalCount;
}
/**
* 取得选择记录的初始位置
*
* @return
*/
public int getStartPos() {
return (pageNow - 1) * pageSize;
}
public void setStartPos(int startPos) {
this.startPos = startPos;
}
/**
* 是否是第一页
*
* @return
*/
public boolean isHasFirst() {
return (pageNow == 1) ? false : true;
}
public void setHasFirst(boolean hasFirst) {
this.hasFirst = hasFirst;
}
/**
* 是否有首页
*
* @return
*/
public boolean isHasPre() {
// 如果有首页就有前一页，因为有首页就不是第一页
return isHasFirst() ? true : false;
}
public void setHasPre(boolean hasPre) {
this.hasPre = hasPre;
}
/**
* 是否有下一页
*
* @return
*/
public boolean isHasNext() {
// 如果有尾页就有下一页，因为有尾页表明不是最后一页
return isHasLast() ? true : false;
}
public void setHasNext(boolean hasNext) {
this.hasNext = hasNext;
}
/**
* 是否有尾页
*
* @return
*/
public boolean isHasLast() {
// 如果不是最后一页就有尾页
return (pageNow == getTotalCount()) ? false : true;
}
public void setHasLast(boolean hasLast) {
this.hasLast = hasLast;
}
}
UserDao.xml
接着是对于dao层的一个操作，首先需要编写mapper映射文件，在mapper中，最主要的是两条sql语句的编写
<?xml version="1.0" encoding="UTF-8" ?> <!-- 映射文件：这里就是对user表进行crud --> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.byzx.ssm.dao.UserDao"> <!-- 分页SQL语句 语法：select * from 表名 limit 开始位置,每页显示条数--> <select id="selectUsersByPage" resultType="User"> select * from user <where> <choose> <when test="username!=null and username!=''"> username like concat(concat('%',#{username}),'%') </when> </choose> </where> limit #{startPos},#{pageSize} </select> <!-- 取得记录的总数 语法：select count(*) form 表名--> <select id="getUsersCount" resultType="int"> SELECT COUNT(*) FROM user </select> <!-- 通过用户名模糊查询用户信息 --> <select id="findListByName" parameterType="User" resultType="User"> select * from user <where> <choose> <when test="username!=null and username!=''"> username like concat(concat('%',#{username}),'%') </when> </choose> </where> </select> </mapper>
UserDao.java
紧接着是对于dao层对应接口的编写，接口中的方法，参数类型，返回值类型要跟mapper映射器一一对应。
package com.byzx.ssm.dao;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.byzx.ssm.bean.User;
public interface UserDao {
/**
* 使用注解方式传入多个参数，用户产品分页，通过登录用户ID查询
* @param page
* @param userId
* @return startPos},#{pageSize}
*/
public List<User> selectUsersByPage(@Param(value="username")String username,@Param(value="startPos") Integer startPos,@Param(value="pageSize") Integer pageSize);
/**
* 取得产品数量信息，通过登录用户ID查询
* @param userId
* @return
*/
public int getUsersCount();
/**
* 通过用户名模糊查询用户信息
* @param u
* @return
*/
public List<User> findListByName(User u);
/**
* 登录
* @param user
* @return
*/
public List<User> login(User user);
}
持久层（dao）完成之后需要编写相应的业务接口和实现方法，在接口中定义这样一个方法，然后实现类中覆写一下：
IUserService.java
package com.byzx.ssm.service;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.springframework.ui.Model;
import com.byzx.ssm.bean.User;
public interface IUserService {
/**
* 分页显示商品
* @param request
* @param model
* @param loginUserId
*/
void showUsersByPage(HttpServletRequest request,Model model,User u);
/**
* 通过用户名查询用户信息
* @param u
* @return
*/
public List<User> findListByName(User u);
}
UserService.java
package com.byzx.ssm.service.impl;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.ui.Model;
import com.byzx.ssm.bean.Page;
import com.byzx.ssm.bean.User;
import com.byzx.ssm.dao.UserDao;
import com.byzx.ssm.service.IUserService;
/**
* @Service("userService")
* @author Administrator
*
*/
@Service
public class UserService implements IUserService {
@Autowired
private UserDao userDao;
@Override
public List<User> findListByName(User u) {
return userDao.findListByName(u);
}
@Override
public void showUsersByPage(HttpServletRequest request, Model model, User u) {
String pageNow = request.getParameter("pageNow");//获取前台界面传过来的当前页码
Page page = null;
List<User> users = new ArrayList<User>();
int totalCount = (int) userDao.getUsersCount();
if (pageNow != null) {
page = new Page(totalCount, Integer.parseInt(pageNow));
users = this.userDao.selectUsersByPage(u.getUsername(),
page.getStartPos(), page.getPageSize());
} else {
page = new Page(totalCount, 1);
users = this.userDao.selectUsersByPage(u.getUsername(),
page.getStartPos(), page.getPageSize());
}
model.addAttribute("users", users);
model.addAttribute("page", page);
}
}
接下来是控制器的编写，当用户需要跳转到这个现实产品的页面时，就需要经过这个控制器中相应方法的处理，这个处理过程就是调用业务层的方法来完成，然后返回结果到JSP动态显示，服务器端生成好页面后传给客户端（浏览器）现实，这就是一个MVC过程。
UserController.java
package com.byzx.ssm.action;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.byzx.ssm.bean.User;
import com.byzx.ssm.service.IUserService;
@Controller
@RequestMapping("/user")
public class UserController {
@Autowired
private IUserService userService;
/**
* 根据用户名称做模糊查询
* @param request
* @return
*/
@RequestMapping("/findlist")//这个就是设置的action。完整写法为:/findlist.action
public String findListByName(Model model,User u) {
List<User> users = userService.findListByName(u);
model.addAttribute("users", users);
return "userList.jsp";
}
/**
* 初始化 “用户信息”列表 JSP页面,具有分页功能 (GET请求)
*
* @param request
* @param model
* @return
*/
@RequestMapping(value = "/showUser", method = RequestMethod.GET)
public String showMyUser(HttpServletRequest request, Model model,User u) {
logo(request, model, u);
return "userList.jsp";
}
private void logo(HttpServletRequest request, Model model, User u) {
userService.showUsersByPage(request, model,u);
}
/**
* 初始化 “用户信息”列表 JSP页面,具有分页功能 （POST请求）
*
* @param request
* @param model
* @return
*/
@RequestMapping(value = "/findUsers", method = RequestMethod.POST)
public String findUsersByUserName(HttpServletRequest request, Model model,User u) {
logo(request, model, u);
return "userList.jsp";
}
}
最后就是jsp界面的一个数据展示。主要是结合JSTL和EL来写，在循环输出的时候也做了判断，如果接受的参数为空，那么输出暂无商品，只有接受的参数不为空的时候，才循环输出
userList.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>查询用户列表</title>
</head>
<body>
<form
action="${pageContext.request.contextPath }/user/findUsers.action"
method="post">
<h2>当前登录的用户是：${sessionScope.username}</h2>
查询条件：
<table width="100%" border=1>
<tr>
<td><input type="text" name="username" /></td>
<td><input type="submit" value="查询" /></td>
</tr>
</table>
用户列表：
<table width="100%" border=1>
<tr>
<td>名称</td>
<td>生日</td>
<td>性别</td>
<td>住址</td>
<td>操作</td>
</tr>
<c:forEach items="${users }" var="item">
<tr>
<td>${item.username }</td>
<td><fmt:formatDate value="${item.birthday }"
pattern="yyyy-MM-dd" /></td>
<td><c:if test="${item.sex==2}">男</c:if> <c:if
test="${item.sex==1}">女</c:if></td>
<td>${item.address}</td>
</tr>
</c:forEach>
</table>
<!-- 分页功能 start -->
<div align="center">
<font size="2">共 ${page.totalPageCount} 页</font> <font size="2">第
${page.pageNow} 页</font> <a href="showUser.action?pageNow=1">首页</a>
<c:choose>
<c:when test="${page.pageNow - 1 > 0}">
<a href="showUser.action?pageNow=${page.pageNow - 1}">上一页</a>
</c:when>
<c:when test="${page.pageNow - 1 <= 0}">
<a href="showUser.action?pageNow=1">上一页</a>
</c:when>
</c:choose>
<c:choose>
<c:when test="${page.totalPageCount==0}">
<a href="showUser.action?pageNow=${page.pageNow}">下一页</a>
</c:when>
<c:when test="${page.pageNow + 1 < page.totalPageCount}">
<a href="showUser.action?pageNow=${page.pageNow + 1}">下一页</a>
</c:when>
<c:when test="${page.pageNow + 1 >= page.totalPageCount}">
<a href="showUser.action?pageNow=${page.totalPageCount}">下一页</a>
</c:when>
</c:choose>
<c:choose>
<c:when test="${page.totalPageCount==0}">
<a href="showUser.action?pageNow=${page.pageNow}">尾页</a>
</c:when>
<c:otherwise>
<a href="showUser.action?pageNow=${page.totalPageCount}">尾页</a>
</c:otherwise>
</c:choose>
</div>
<!-- 分页功能 End -->
</form>
</body>
</html>
好了，到了这里基于ssm框架和MySql数据库的分页查询功能就算是做好了，同时本案例也整合了模糊查询功能。后续我们还可以分享其他的实现方式。
6、部署项目
输入地址：http://localhost:8080/SSM_FenYe/user/findUsers.action