SSM框架分页实现-优快云博客

本文链接：https://blog.youkuaiyun.com/Souwy/article/details/69230880

SSM（Spring+SpringMVC+MyBatis）分页

采用maven的方式
用了一些spring的拦截器的设置

整合mybatis

配置db.properties
mysql.username=root
mysql.password=root
mysql.url=jdbc:mysql://localhost:3306/mysql
mysql.driver=com.mysql.jdbc.Driver
当然你也可以加一些连接池之类的，这里我才用的是dbcp来进行管理的
下面是我的包目录，在最后会给出相应的pom.xml,另外基本上都给出了比较详细的注释，如果有疑问的大家可以一起讨论，最后请多多指教

配置applicationContext.xml

<?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:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
    <context:component-scan base-package="com.paging.service"></context:component-scan>
    <context:component-scan base-package="com.paging.controller"></context:component-scan>
    <context:component-scan base-package="com.paging.bean"></context:component-scan>
    <context:component-scan base-package="com.paging.dao"></context:component-scan>
    <bean id="propertyConfigurer"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:db.properties"></property>
    </bean>
    <!-- 链接数据库 采用dbcp方式链接-->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${mysql.driver}"></property>
        <property name="url" value="${mysql.url}"></property>
        <property name="username" value="${mysql.username}"></property>
        <property name="password" value="${mysql.password}"></property>
    </bean>
    <!--配置SqlSessionFactoryBean 必须的配置 -->
    <bean id="sqlFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatisConfiguration.xml"></property>
        <property name="mapperLocations" value="classpath:com/paging/dao/*.xml"></property> 
    </bean>
    <bean id="usersDao" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="com.paging.dao.UsersDao"></property>
        <property name="sqlSessionFactory" ref="sqlFactoryBean"></property>
    </bean>
    <!--配置事务管理-->
    <bean
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
        id="transactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--开启注解，其实也可以不用-->
    <mvc:annotation-driven />
</beans>
配置log4j
<?xml version="1.0" encoding="UTF-8"?>    
<!DOCTYPE log4j:configuration PUBLIC "-//APACHE//DTD LOG4J 1.2//EN" "log4j.dtd">  
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<!-- 可以配置多个appender来对应不同的输出，如文件输出，sql输出，控制台输出，邮件输出等 -->  
  <!-- [控制台STDOUT] 不同的输出类型对应着不同的calss，如控制台输出class对应着 org.apache.log4j.ConsoleAppender -->  
  <appender name="console" class="org.apache.log4j.ConsoleAppender">  <!-- name提供给logger或者root调用 -->
     <param name="encoding" value="GBK" />  <!-- 保存字符集 -->
     <param name="target" value="System.out" />  <!-- 输出到控制台 -->
     <layout class="org.apache.log4j.PatternLayout"> <!-- loyout表示输出方式，可以多种，class值区分，PatternLayout表示自定义格式 --> 
       <param name="ConversionPattern" value="%d{ISO8601} 耗时：%r [日志来自：%-40.40c{3} 日志类型: %-5p 日志内容：%m]%n" />  <!-- 输出格式，后面解释 -->
     </layout>  
      <!--filter过滤器设置输出的级别:ALL < DEBUG < INFO < WARN < ERROR < FATAL < OFF
          所有下面输出的是debug到warn不会有error和fatal
      -->  
        <filter class="org.apache.log4j.varia.LevelRangeFilter">  
            <param name="levelMin" value="debug" />  
            <param name="levelMax" value="warn" />  
            <param name="AcceptOnMatch" value="true" />  <!-- 答案：http://bbs.youkuaiyun.com/topics/350195913 -->
        </filter>  
  </appender>  

  <!-- [公共Appender] 这个class表示输入到文件，并且按日期生成新文件-->  
  <appender name="DEFAULT-APPENDER" class="org.apache.log4j.DailyRollingFileAppender">  
     <param name="File" value="${webapp.root}/logs/common-default.log" />  <!-- ${webapp.root}项目根路径，自动获得，不用配置，可自己在web.xml中配置 -->
     <param name="Append" value="true" />  <!-- 是否项目重启继续保存之前日志 -->
     <param name="encoding" value="GBK" />  
     <param name="threshold" value="all" /> <!-- 记录所有类型日志，记录它和比它等级高的日志all<debug -->
     <param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />  <!-- 日期格式  例子：common-default.log.2015-09-17.log-->
     <layout class="org.apache.log4j.PatternLayout">  <!-- 输出方式 -->
    <param name="ConversionPattern" value="%d{ISO8601} 耗时：%r [日志来自：%-40.40c{3} 日志类型: %-5p 日志内容：%m]%n" />  
     </layout>  
   </appender>  

   <!-- [debug日志APPENDER] -->  
   <appender name="DEBUG-APPENDER" class="org.apache.log4j.DailyRollingFileAppender">  
     <param name="File" value="${webapp.root}/logs/controller/debug-log.log" />  
     <param name="Append" value="true" />  
     <param name="encoding" value="GBK" />  
     <param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />  
     <layout class="org.apache.log4j.PatternLayout">  
        <param name="ConversionPattern" value="%d{ISO8601} 耗时：%r [日志来自：%-40.40c{3} 日志类型: %-5p 日志内容：%m]%n" />  
     </layout>  
   </appender>  

   <!-- [info日志APPENDER] -->  
   <appender name="INFO-APPENDER"  
class="org.apache.log4j.DailyRollingFileAppender">  
     <param name="File" value="${webapp.root}/logs/controller/info-log.log" />  
     <param name="Append" value="false" />  
     <param name="encoding" value="GBK" />
     <param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />  
     <layout class="org.apache.log4j.PatternLayout">  
    <param name="ConversionPattern" value="%d{ISO8601} 耗时：%r [日志来自：%-40.40c{3} 日志类型: %-5p 日志内容：%m]%n" />  
     </layout> 
     <!-- 我只想记录info日志，就做如下设置 -->
     <filter class="org.apache.log4j.varia.LevelRangeFilter">     
       <param name="LevelMax" value="info"/>     
       <param name="LevelMin" value="info"/>     
      </filter>   
   </appender>  

    <!-- [组件日志APPENDER] -->  
   <appender name="COMPONENT-APPENDER"  
class="org.apache.log4j.DailyRollingFileAppender">  
     <param name="File" value="${webapp.root}/logs/logistics-component.log" />  
     <param name="Append" value="true" />  
     <param name="encoding" value="GBK" />  
     <param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />  
     <layout class="org.apache.log4j.PatternLayout">  
    <param name="ConversionPattern" value="%d{ISO8601} 耗时：%r [日志来自：%-40.40c{3} 日志类型: %-5p 日志内容：%m]%n" />  
     </layout>  
   </appender>  

     <!-- debug log -->  
     <!-- name指定的是包名，表示这个logger只记录com.wzw.controller下的所有日志 -->
   <logger name="com.wzw.controller" additivity="true">  <!-- additivity 是否继承root -->
      <!-- <level value="${loggingLevel}" />   -->
      <level value="DEBUG"></level>  <!-- 现在级别 -->
      <appender-ref ref="DEBUG-APPENDER" />  
   </logger>  

     <!-- info log -->  
     <!-- name指定的是包名，这样只操作此包下的log -->
   <logger name="com.wzw.controller" additivity="true">  
      <level value="INFO"></level>  
      <appender-ref ref="INFO-APPENDER" />  
      <appender-ref ref="console"/>
   </logger>  

   <!-- Root Logger -->  
   <!-- 所有logger的父类，记录所有的日志。 -->
   <root> 
       <level value="ALL"></level>  <!-- 限定记录等级 -->
       <appender-ref ref="DEFAULT-APPENDER" />  <!-- 调用记录方式 -->
       <appender-ref ref="console"/>
   </root>  

</log4j:configuration>

配置spring-mvc.xml

<?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:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
        <!--声明前缀和后缀-->
    <bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/">
        </property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    <!--引入spring配置文件-->
    <import resource="classpath:applicationContext.xml"/>
     <!--声明拦截器-->
         <mvc:interceptors>  
          <!--   多个拦截器，顺序执行   -->
            <mvc:interceptor>  
                <mvc:mapping path="/**"/>  
                <bean class="com.paging.interceptor.LoginInterceptor"></bean>  
            </mvc:interceptor>  
        </mvc:interceptors>  

</beans>

接下来是bean中的Users与Page
Page.java

/**
     * 页的数量
     */
    private int pageCount;
    /**
     * 页的大小
     */
    private int pageSize;
    /**
     * 数据的总量
     */
    private int total;
    /**
     * dangqianye
     * 
     */
    private int nowPage;
    ......省略set，get方法

Users.java

    private String username;
    private String password;
    private int user_type;

接下来是dao层下的代码

package com.paging.dao;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.paging.bean.Page;
import com.paging.bean.Users;
import com.paging.service.impl.UserServiceImpl;
//声明一个bean
@Service("pageDao")
public class PageDao {
    private Page page= new Page();
    @Autowired   //采取自动注入
    private UserServiceImpl userservice;
    public List<Users> nextPage(int nowPage){
    //nowPage代表当前页 如果当前页与总页数减一相等，代表这是最后一页
    //设置当前页不变
        if(nowPage==(page.getPageCount()-1)){
            page.setNowPage(nowPage);
        }else{
        //如果当前页不是最后一页 ，当前页加一
            page.setNowPage(nowPage+1);
        }
        //返回一个列表，此处与users.xml对应的接口方法 第一个参数代表起始位置，第二个参数代表每一页显示的数量，每点击一次下一次就应该乘以所设置的页的大小
      return userservice.userPage(page.getNowPage()*page.getPageSize(), page.getPageSize());
    }
    public List<Users> previousPage(int nowPage){
    //如果当前页是第一页，那么点击上一页，则任然是当前页
        if(nowPage==0){
            page.setNowPage(0);
            System.out.println(page.getNowPage()+"----NowPage");
        }else{
        //否则当前页减1
            page.setNowPage(nowPage-1);
        }
         return userservice.userPage((page.getNowPage())*page.getPageSize(), page.getPageSize());
    }
    //初始化页的设置
    public Page init(int pageSize){
    //根据定义获取查询的总数量
        page.setTotal(userservice.countUsers());
        //设置第一次显示的是第一页
        page.setNowPage(0);
        //如果总数量小于所设置的页大小 ，表示只有一页
        if(page.getTotal()<=pageSize){
            page.setPageCount(1);
            System.out.println(page.getPageCount());
      //如果总数量除以页大小为整，如果不为整则加一。
        }else if(page.getTotal()%pageSize==0){
            page.setPageCount((page.getTotal()/pageSize));
        }else{
            page.setPageCount((page.getTotal()/pageSize)+1);
        }
        //初始化页大小
        page.setPageSize(pageSize);
        return page;
    }
    public List<Users> getUsers(int nowPage,int pageSize){
        List<Users> list = userservice.userPage(nowPage, pageSize);
        return list;
    }
}

package com.paging.dao;

import java.util.List;

import com.paging.bean.Users;

public interface UsersDao {
   public int isUsers(String username);
   public int isTrueByPassword(String username,String password);
   public int getIdByUsername(String username);
   public List<Users> getByUsersId(int id);
   public int countUsers();
   public List<Users> userPage(int nowPage,int pageSize);
}

这里采用mybatis的动态生成接口的方式 users.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.paging.dao.UsersDao">
  <select id="isUsers" parameterType="String" resultType="int">
    select count(*) from users where username = #{username}
  </select>
  <select id="isTrueByPassword" parameterType="String" resultType="int">
      select count(*) from users where username = #{0}  and password = #{1}    
  </select>
  <select id="getIdByUsername" parameterType="String" resultType="int">
    select user_id from users where username = #{username}
  </select>
  //resulitmap 当结果为一个集合的时候使用
  <resultMap type="com.paging.bean.Users" id="Users">
  <id column="user_id" property="user_id"/>
  <result column="username" property="username"/>
  <result column="password" property="password"/>
  <result column="user_type" property="user_type"/>
  </resultMap>
  <select id="getByUsersId" resultMap="Users" parameterType="int">
     select * from users where user_type = 0 
  </select>
  <select id="countUsers" resultType="int">
     select count(*) from users where user_type = 0
  </select>
  <select id="userPage" resultMap="Users" parameterType="int">
    select * from users where user_type = 0 limit #{0},#{1}
  </select>
</mapper>

接下来是service层和impl层
service层接口方法与dao层的方法相同
impl实现service接口

package com.paging.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.paging.bean.Users;
import com.paging.dao.UsersDao;
import com.paging.service.UserService;

@Service("userservice")
public class UserServiceImpl implements UserService{
    @Autowired
    @Qualifier("usersDao")
    private UsersDao usersDao;
    public int isUsers(String username) {
        return usersDao.isUsers(username);
    }

    public int isTrueByPassword(String username, String password) {
        return usersDao.isTrueByPassword(username, password);
    }

    public int getIdByUsername(String username) {
        return usersDao.getIdByUsername(username);
    }

    public List<Users> getByUsersId(int id) {
        return  usersDao.getByUsersId(id);
    }

    public int countUsers() {
        return usersDao.countUsers();
    }

    public List<Users> userPage(int nowPage, int pageSize) {
        return usersDao.userPage(nowPage, pageSize);
    }


}

接下来是LoginInterceptor类，这个类继承了HandlerInterceptor，用来对登陆进行拦截控制

package com.paging.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import com.paging.service.impl.UserServiceImpl;

public class LoginInterceptor implements HandlerInterceptor {
    @Autowired
    private UserServiceImpl userservice;
    //这是我自己设的一个计数标志
    int tag = 0;
    //一个开关主要用来控制登录用的
    private boolean flag = false;
    public void afterCompletion(HttpServletRequest arg0,
            HttpServletResponse arg1, Object arg2, Exception arg3)
            throws Exception {}
    public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
            Object arg2, ModelAndView arg3) throws Exception {}
    public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object arg2) throws Exception {
            //每次访问该拦截器的时候，计数器加1
        tag = tag + 1;
        System.out.println("第几次访问" + tag);
        //创建一个session
        HttpSession session = request.getSession();
        /*
         * 判断输入的路劲是否是登录页面
         * 防止用户在登陆之后又又返回登录页面登录而不经过判断就直接进去
         * 同时消除上一次登录的用户session消息 ，如果没有这个判断可能会出现bug
         * 当用户登录过一次的时候session 中的username是存在的 次时重新登录乱输密码
         * 会导致登录成功，所以必须加次判断，消除session ，初始化flag
         */
        if (request.getRequestURI().contains("login")) {
            session.removeAttribute("username");
            flag = false;
        }//如果用户没有登陆过那么flag = false 此时进行登录判断
        if (!flag) {
        //获取username信息
            String username = request.getParameter("username");
            String error = null;
            //判断用户名是否存在，一个比较简单的判断语句 select count(*) from users where username = ?
            int i = userservice.isUsers(username);
            System.out.println(i);
            //如果存在，判断密码是否正确
            if (i != 0) {
                String password = request.getParameter("password");
                System.out.println(username + ":" + password);
                //相同的判断方式
                if (userservice.isTrueByPassword(username, password) != 0) {
                //让flag = true 的目的是因为，拦截器在你访问不同的页面的时候，一直进行拦截控制，那么你在进行非登录界面的时候他也会拦截，所以让flag=true ，可以让你在正常登录之后，不会进行用户名和密码判断
                    flag = true;
                    System.out.println("你用的是密码登录");
                    System.out.println();
                    System.out.println("第几次访问" + tag);
                    System.out.println("------------"
                            + userservice.isTrueByPassword(username, password));
                    session.setAttribute("username", username);
                    return true;
                } else {
                    error = "你的密码错误";
                    request.setAttribute("error", error);
                    System.out.println("你的密码错误");
                    request.getRequestDispatcher("/index.jsp").forward(request,
                            response);
                    return false;
                }
            } else {
                error = "你输入的用户名不存在";
                request.setAttribute("error", error);
                System.out.println("ssss");
                request.getRequestDispatcher("/index.jsp").forward(request,
                        response);
                return false;
            }
        }//如果登录过一次那么flag = true 将走下面的通道 
        else {
            System.out.println("login.....................");
            System.out.println();
            System.out.println("第几次访问" + tag);
            //如果已经登录过一次那么session必定存在username 不为空，如果为空则代表，你企图不登录就想访问其他的页面 ，此时将会强制让你返回到登录页面 ，并初始化flag
            if (session.getAttribute("username") == null) {
                flag = false;
                request.getRequestDispatcher("/index.jsp").forward(request,
                        response);
                return false;
            } else {
            //如果session中的username不为空，允许访问
                System.out.println(request.getRequestURI());
                System.out.println(session.getAttribute("username"));
                return true;
            }

        }
    }

}

接下来是controller层

package com.paging.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.paging.bean.Page;
import com.paging.bean.Users;
import com.paging.dao.PageDao;
import com.paging.service.impl.UserServiceImpl;
@Controller
public class LoginAction {
    @Autowired
    private UserServiceImpl userservice;
    @Autowired(required = false)
    private HttpServletRequest request;
    private Page page = new Page();
    @Autowired
    private PageDao pageDao;

    @RequestMapping("/login")
    public ModelAndView login(String username, ModelMap modelMap) {
        //设置一个初始化的page 页大小为3
        page = pageDao.init(3);
        //在页面中显示你所设置的页面数据
        List<Users> list = pageDao.getUsers(page.getNowPage(), page.getPageSize());
        System.out.println("nowPage---------" + page.getNowPage());
        System.out.println(list);
        Map<String, Object> map = new HashMap<String, Object>();
        //放入map集合中并传给页面
        map.put("list", list);
        map.put("page", page);
        System.out.println(page);
        System.out.println(username);
        return new ModelAndView("main", map);
    }

    @RequestMapping("/beforepage")
    public ModelAndView beforePage(int pageNow) {
        Map<String, Object> map = new HashMap<String, Object>();
        //设置页面数据，并传入参数当前页
        List<Users> list = pageDao.previousPage(pageNow);
        System.out.println("nowPage---------" + page.getNowPage());
        map.put("list", list);
        map.put("page", page);
        return new ModelAndView("main", map);
    }

    @RequestMapping("/nextpage")
    public ModelAndView nextPage(int pageNow) {
        System.out.println(pageNow);
        //设置页面数据，并传入参数当前页
        List<Users> list = pageDao.nextPage(pageNow);
        System.out.println("nowPage---------" + page.getNowPage());
        System.out.println(list+"---------------list");
        Map<String, Object> map = new HashMap<String, Object>();
        System.out.println(list);
        map.put("list", list);
        map.put("page", page);
        return new ModelAndView("main", map);
    }
}

最后是页面的设置，我用了jstl标签
index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib prefix="j" uri="http://java.sun.com/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%>">
    <title>登录页面</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
  </head>
  <body>
  <c:out value="${error}"></c:out>
       <div> 
         <h2>您好！您还没登录了</h2>
         <form action="login.do" method="post">
             用户名：<input type="text" name="username"><br>   
             密码 ：<input type="password" name="password"><br>
             <input type="submit" value="登录">      
         </form>
         <j:out value='${error}'></j:out>
       </div>
  </body>
</html>

main.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib prefix="j" uri="http://java.sun.com/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%>">
<title>main</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
</head>
<body>
    <table border="1px" align="center">
        <tr>
            <td>id</td>
            <td>用户名</td>
            <td>密码</td>
            <td>用户类型</td>
            <td>修改</td>
        </tr>
        <!--foreach标签-->
        <j:forEach items="${list}" var="list">
            <tr>
                <td><j:out value="${list.user_id}"></j:out></td>
                <td><j:out value="${list.username}"></j:out></td>
                <td><j:out value="${list.password}"></j:out></td>
                <td><j:out value="${list.user_type}"></j:out></td>
            </tr>
        </j:forEach>
    </table>
    <div align="center">
    <!--如果当前页是第一页那么，不显示a标签，反之显示-->
        <j:if test="${page.nowPage!=0}">
            <a
                href="beforepage.do?pageNow=<j:out value='${page.nowPage}'></j:out>">前一页</a>
        </j:if>
        <j:if test="${page.nowPage==0 }">
    前一页
    </j:if>
        <j:out value="${page.nowPage+1}"></j:out>
        /
        <j:out value="${page.pageCount}"></j:out>
            <!--如果当前页是最后一页那么，不显示a标签，反之显示-->
        <j:if test="${page.nowPage==(page.pageCount-1)}">
         下一页
     </j:if>
        <j:if test="${page.nowPage!=(page.pageCount-1)}">
            <a href="nextpage.do?pageNow=<j:out value='${page.nowPage}'></j:out>">下一页</a>
        </j:if>
    </div>
</body>
</html>

最后附上log4j和spring的web.xml配置，如果web.xml莫名其妙的出错，请按它显示的位置排放，并删除前面的声明，然后恢复。

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<!-- Spring MVC配置 -->
    <!-- ====================================== -->
    <servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 可以自定义servlet.xml配置文件的位置和名称，默认为WEB-INF目录下，名称为[<servlet-name>]-servlet.xml，如spring-servlet.xml 
            <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/spring-servlet.xml</param-value>&nbsp; 
            默认 </init-param> -->
        <!-- -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <!-- Spring配置 -->
    <!-- ====================================== -->
    <listener>
        <listenerclass>
            org.springframework.web.context.ContextLoaderListener
        </listenerclass>
    </listener>
    <context-param>
        <param-name>log4jConfigLocation</param-name>
        <param-value>classpath:log4j.xml</param-value>
    </context-param>
    <!-- 加载log4j配置文件 -->
    <listener>
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
    </listener>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

最后附上pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.paging</groupId>
    <artifactId>ssmpaging</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>ssmpaging Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>3.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>3.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>3.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.11</version>
        </dependency>
        <!--mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.21</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
            <type>jar</type>
        </dependency>
        <!--打印日志 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.6.6</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>3.1.2.RELEASE</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-core-asl</artifactId>
            <version>1.9.11</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.11</version>
        </dependency>
        <!-- netty -->
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>5.0.0.Alpha2</version>
            <scope>compile</scope>
        </dependency> 
    </dependencies>
    <build>
        <finalName>ssmpaging</finalName>
    </build>
</project>