V3.0 完善代码，按条件计算分页，按条件分页查询

- 从表中查找符合条件的记录数

select count(*) from tableName where findKey like ‘%findValue%’;
其它类要调用的sql语句基本相同，只是调用的表名，要查询的关键字及值不一样，故写一个通用的调用方法，此方法其它继承类也要调用，故写进DbConn.java
DbConn.java 数据库连接类

package gccshop.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

//数据库连接类
public class DbConn {
    // 定义一个静态局部量
    private Connection conn = null;
    private PreparedStatement pt = null;
    private ResultSet rs = null;

    // 构造函数
    public DbConn() {
        // try..catch错误捕捉
        try {
            // 加载驱动程序
            Class.forName("com.mysql.jdbc.Driver");
            // 根据账号密码远程连接数据库
            conn = DriverManager.getConnection(
                    "jdbc:mysql://139.199.205.212:3306/u1", "stu", "12345678");
        } catch (ClassNotFoundException e) {
            System.out.println("没有加载到驱动程序");
        } catch (SQLException e) {
            System.out.println("连接出错");
        }
    }

    // 获取连接，仅给测试用
    public Connection getConn() {
        return conn;
    }

    /**
     * 通用增删改
     * 
     * sql:需要执行的任何sql语句
     * 
     * objects：要植入到prepareStatement中去的参数对象数组
     * 
     * result:受影响的记录数
     */
    public int update(String sql, Object[] objects) {
        int result = 0;
        try {
            pt = conn.prepareStatement(sql);
            if (objects != null) {
                for (int i = 0; i < objects.length; i++) {
                    pt.setObject(i + 1, objects[i]); // 下标从1开始的
                }
            }
            result = pt.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 通用查询
     * 
     * sql:需要执行的任何sql语句
     * 
     * objects：要植入到prepareStatement中去的参数对象数组
     * 
     * rs:返回的查询结果，记录集
     */
    public ResultSet query(String sql, Object[] objects) {
        try {
            pt = conn.prepareStatement(sql);
            if (objects != null) {
                for (int i = 0; i < objects.length; i++) {
                    pt.setObject(i + 1, objects[i]);
                }
            }
            rs = pt.executeQuery();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return rs;
    }

    //全字段查询符合条件的记录总数，即所有字段匹配要查询的内容
    //免除用户选择关键字
    /*
     * tableName:要查询的表名
     * 
     * findKeys:要查询的关键字数组
     * 
     * findValue:要模糊查询的匹配词
     */
    public int findTotal(String tableName, String[] findKeys, String findValue) {
        String sql = "select count(*) from " + tableName;
        sql += " where " + findKeys[0] + " like '%" + findValue + "%'";
        if (findKeys.length > 1) {
            for (int i = 1; i < findKeys.length; i++) {
                sql += " or " + findKeys[i] + " like '%" + findValue + "%'";
            }
        }
        int records = 0;
        try {
            rs = query(sql, null);// 原来用父类的query，现在用自己的
            if (rs.next()) {
                records = rs.getInt(1);
            }
        } catch (SQLException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } finally {
            try {
                closeConn();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return records;
    }

    // 关闭连接
    public void closeConn() throws SQLException {

        if (rs != null)
        rs.close();
        if (pt != null)
        pt.close();
    }
}

• SellerDao.java 持久层接口类

package gccshop.dao;

import gccshop.pojo.Seller;

import java.util.ArrayList;

//持久层接口类（用接口中的抽象方法规范统一行为）
public interface SellerDao {

    // 精确查找
    public Seller findEntity(String propName, Object value);

    // 全字段查询符合条件的记录条数
    // findValue：要查询的关键字
    public int findTotal(String findValue);

    // 按条件分页查找
    /*
     * 
     * findValue:要模糊查询的匹配词
     * 
     * pageNo：要显示的第几页
     * 
     * rowsPerPage：每页要显示的记录条数
     */
    public ArrayList<Seller> findEntities(String findValue, int pageNo, int rowsPerPage);
}

• SellerDaoImpl.java 持久层接口实现类

package gccshop.dao.impl;

import gccshop.dao.DbConn;
import gccshop.dao.SellerDao;
import gccshop.pojo.Seller;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

//持久层接口实现类，同時继承数据库连接类，
/**
 * @author Administrator
 * 
 */
public class SellerDaoImpl extends DbConn implements SellerDao {
    // 定义要操作的表
    String tableName = "t_seller";
    // 封装要查询的全字段
    String[] findKeys = { "Id", "shopName", "shopLocation", "golden" };
    //
    private ResultSet rs = null;
    private Seller entity = null;
    private ArrayList<Seller> entityList = null;

    @Override
    public int add(Seller entity) {
        int f = 0;
        String sql = "insert into t_seller(shopName,shopLocation,golden) values(?,?,?)";
        Object[] objects = { entity.getShopName(), entity.getShopLocation(),
                entity.getGolden() };
        f = update(sql, objects);

        try {
            closeConn();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return f;
    }

    // 精確查找
    @Override
    public Seller findEntity(String p, Object o) {
        // 一定要记得新定义一个entity，防备上次查找的结果对本次查找造成干扰
        Seller entity = null;
        String sql = "Select * from t_seller where " + p + "=?";
        Object[] objects = { o };
        try {
            rs = query(sql, objects);
            if (rs.next()) {
                // 如果查找到记录，则完成记录到对象的转换
                entity = new Seller();
                entity.setId(rs.getInt("Id"));
                entity.setGolden(rs.getString("golden"));
                entity.setShopLocation(rs.getString("shopLocation"));
                entity.setShopName(rs.getString("shopName"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                closeConn();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return entity;
    }


    // 全字段查询符合条件的记录数
    // findValue：要查询的关键字
    // 调用父类中的方法并传参实现
    @Override
    public int findTotal(String findValue) {
        return super.findTotal(tableName, findKeys, findValue);
    }

    // 按条件分页查找
    /*
     * findValue:要模糊查询的匹配词
     * pageNo:第几页
     * rowsPerPage:每页要显示的记录数
     */
    @Override
    public ArrayList<Seller> findEntities(String findValue, int pageNo,
            int rowsPerPage) {
        try {
            String sql = " select * from " + tableName;
            sql += " where " + findKeys[0] + " like '%" + findValue + "%' ";
            if (findKeys.length > 1) {
                for (int i = 1; i < findKeys.length; i++) {
                    sql += " or " + findKeys[i] + " like '%" + findValue + "%' ";
                }
            }
            sql += " limit ?,?";
            // 分页查询
            // 第一个？代表起始记录号：为（页编号-1）*每页要显示的记录数
            // 第二个？代表每页要显示的记录数
            // 植入参数
            Object[] objects = { (pageNo - 1) * rowsPerPage, rowsPerPage };
            // 执行查询
            rs = query(sql, objects);
            // 构造对象列表
            entityList = new ArrayList<Seller>();
            // 当有记录时，完成记录集到对象列表的转换
            while (rs.next()) {
                entity = new Seller();// 生成对象
                // 填充对象
                entity.setId(rs.getInt("Id"));
                entity.setGolden(rs.getString("golden"));
                entity.setShopLocation(rs.getString("shopLocation"));
                entity.setShopName(rs.getString("shopName"));
                // 将对象添加到列表
                entityList.add(entity);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                closeConn();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return entityList;
    }
}

• SellerService.java 业务层接口类

package gccshop.service;

import gccshop.pojo.Seller;

import java.util.ArrayList;

//商家业务接口类(用接口统一行为)
public interface SellerService {
    // 根据条件查找
    public Seller findEntity(String propName, Object value);

    // 全字段查询符合条件的记录数
    public int findTotal(String findValue);

    // 按条件分页查找
    /*
     * findValue:要模糊查询的匹配词 pageNo:第几页
     * rowsPerPage:每页要显示的记录数
     */
    public ArrayList<Seller> findEntities(String findValue, int pageNo, int rowsPerPage);

}

• SellerServiceImpl.java 业务层接口实现类

package gccshop.service.impl;

import gccshop.dao.impl.SellerDaoImpl;
import gccshop.pojo.Seller;
import gccshop.service.SellerService;

import java.util.ArrayList;

// 商家业务接口实现类（接口的具体实现）
public class SellerServiceImpl implements SellerService {

    // 调用持久层接口的实现
    private SellerDaoImpl sdi = new SellerDaoImpl();

    @Override
    public Seller findEntity(String p, Object o) {

        return sdi.findEntity(p, o);
    }

    @Override
    // 全字段查询符合条件的记录数
    // findValue：要查询的关键字
    public int findTotal(String findValue) {
        return sdi.findTotal(findValue);
    }

    @Override
    // 按条件分页查找
    /*
     * findValue:要模糊查询的匹配词 pageNo:第几页
     * rowsPerPage:每页要显示的记录数
     */
    public ArrayList<Seller> findEntities(String findValue, int pageNo,
            int rowsPerPage) {
        // TODO Auto-generated method stub
        return sdi.findEntities(findValue, pageNo, rowsPerPage);
    }
}

• TestSellerServiceImpl.java 业务层实现类的测试

package gccshop.test;

import gccshop.pojo.Seller;
import gccshop.service.impl.SellerServiceImpl;

import java.util.ArrayList;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

//测服务层的相关方法
public class TestSellerServiceImpl {
    SellerServiceImpl ssi;
    //定义查询关键字
    String findValue = "test";

    // 测试开始前
    @Before
    public void init() {
        ssi = new SellerServiceImpl();
    }

    // 测试完成后
    @After
    public void destroy() {
        ssi = null;
    }


    // 测试方法
    @Test
    public void findTotal() {
        // 断言相等
        System.out.println(ssi.findTotal(findValue));
    }

    // 测试分页
    @Test
    public void testFindEntities() {
        show(ssi.findEntities(findValue, 1, 40));
    }

    // 查找ID为3的实体，并对其实体的内容进行详细测试
    @Test
    public void findEntity() {      
        Seller s = ssi.findEntity("Id", 3);
        // 断言查找出来的对象的具体内容和预期的值相等，如果任何一个不等，测试不通过
        Assert.assertEquals(3, s.getId());
        Assert.assertEquals("飘零大叔旗舰店", s.getShopName());
        Assert.assertEquals("江苏 泰州", s.getShopLocation());
        Assert.assertEquals("0", s.getGolden());
    }

    //可用此方法输出具体的内容，此方法只参与被调用，不需要测试
    public void show(ArrayList<Seller> list) {
        for (Seller s : list) {
            System.out.println(s.getId() + " " + s.getShopName() + " "
                    + s.getShopLocation() + " " + s.getGolden());
        }
    }
}

• SellerManageServlet .java
  //servlet：是展示层和业务层的桥梁
  //servlet 完成对业务层的调用，实现相应的控制，如需展示数据的生成、整理、包装，请求跳转等
  //展示层可接受servlet传来的数据，进行格式化页面展示

package gccshop.servlet;

import gccshop.pojo.Seller;
import gccshop.service.impl.SellerServiceImpl;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONObject;

public class SellerManageServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    // 调用业务层实现
    SellerServiceImpl ssi = new SellerServiceImpl();
    // 每页固定显示10个，以后如果要修改显示数，改10即可
    private int rowsPerPage = 10;

    // get请求方式
    @Override
    protected void doGet(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }

    // post请求方式
    @Override
    protected void doPost(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        String method = request.getParameter("method");// 动作"show"
        if (method.equals("show")) {
            doShow(request, response);
        }
    }

    /**
     * 此实现方法有一点点儿缺陷， 那就是下面的页链接单击后不能正确显示原来的内容 而是到了新内容，即为""的全搜索
     * 要解决这个问题，可以先将搜索框中的内容保存在localStorage ,刷新后再取出回填，可参阅我的博客中商品类别列表数据的添加
     */
    // 按关键字查询并显示数据到页面上
    public void doShow(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 查询出数据，并生成数据列表
        String pn = request.getParameter("pageNo");
        int pageNo = pn == null ? 1 : Integer.parseInt(pn);
        String fv = request.getParameter("findValue");
        String findValue = fv == null ? "" : fv;
        findValue = new String(findValue.getBytes("iso8859-1"), "utf-8");// 小心汉字问题
        ArrayList<Seller> dataList = ssi.findEntities(findValue, pageNo,
                rowsPerPage);
        // 计算出分页，并生成分页列表[1,2,3,4...12]
        ArrayList<Integer> pageList = new ArrayList<Integer>();
        for (int i = 1; i <= ssi.findTotal(findValue) / rowsPerPage + 1; i++) {
            pageList.add(i);
        }
        // 用json对象封装数据，类似将快递商品sp放入包裹bg
        JSONObject bg = new JSONObject();//
        // 将对应的商品放入包裹，如果没有商品，也要做一次放入操作，只是空包裹。
        if (dataList != null) {
            bg.put("pageList", pageList);// 分页列表，用于页导航
            bg.put("sellers", dataList);// 数据列表，用于表格显示数据
        } else {
            bg.put("pageList", 0);
            bg.put("sellers", null);
        }
        request.setAttribute("sf", bg);// 叫顺风揽件，将包裹递给顺风
        // 顺风发货，去单上正确的买家地址
        request.getRequestDispatcher("manage/seller/sellerManage.jsp").forward(
                request, response);
    }

• sellerManage.jsp 展示层

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>商家管理</title>
        <link rel="stylesheet" href="bootstrap/css/bootstrap.min.css">
        <script type="text/javascript" src="js/jquery.min.js"></script>
        <script type="text/javascript" src="bootstrap/js/bootstrap.min.js"></script>
        <script type="text/javascript" src="js/sellerManage.js"></script>
    </head>
    <body>
        <!--功能区-->
        <div class="container">
            <div class="row clearfix">
                <div class="col-md-8 column">
                    <button class="btn btn-primary" data-toggle="modal" id="sellerAdd">
                        商家入驻
                    </button>
                    <input type="text" id="findValue" placeholder="请输入查询内容（模糊查询）"
                        class="saveHistory" style="margin-left: 20px; width: 200px;">
                    <button class="btn btn-warning" id="search">
                        查询
                    </button>
                </div>
                <div class="col-md-4 column">
                </div>
            </div>
        </div>


        <!--数据表格 -->
        <table class="table table-hover">
            <thead>
                <tr>
                    <th>
                        商家编号
                    </th>
                    <th>
                        商家名称
                    </th>
                    <th>
                        商家地址
                    </th>
                    <th>
                        是否金牌商家
                    </th>
                    <th>
                        操作
                    </th>
                </tr>
            </thead>
            <tbody>
                <!--数据表格展示-->
                <c:forEach items="${sf.sellers}" var="s" varStatus="s1">
                    <tr>
                        <td>
                            <c:out value="${s.id}" />
                        </td>
                        <td>
                            <c:out value="${s.shopName}" />
                        </td>
                        <td>
                            <c:out value="${s.shopLocation}" />
                        </td>
                        <td>
                            <c:if test="${s.golden==1}">
                                <img src="img/goldenSeller.png">
                            </c:if>
                        </td>
                        <td>
                            <a href="#" class="text-success" name="modify">修改</a>
                            <c:if test="${s.id>=10}">
                                <a href="seller?method=del?id=${s.id}" class="text-danger">删除</a>
                            </c:if>
                        </td>
                    </tr>
                </c:forEach>
            </tbody>
        </table>
        <!--分页导航-->
        <ul class="pagination">
            <c:forEach items="${sf.pageList}" var="r" varStatus="r1">
                <li>
                    <a href="#"> <c:out value="${r}" /> </a>
                </li>
            </c:forEach>
        </ul>
    </body>
</html>