记录javaWeb分页的实现遇到的问题

后端代码的实现---->>>

目录结构的实现---->>

代码

servlet,主要用请求转发,(请求行中携带一些关于查询的一些细信息)

package com.gavin.controller;

import com.gavin.dao.FilmImp.FilmDaoImp;
import com.gavin.pojo.Film;
import com.gavin.pojo.PageBean;
import service.FilmService;
import service.imp.FilmServiceImp;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

@WebServlet(urlPatterns = "/ShowFilmController.do")
public class ShowFilmController extends HttpServlet {
    private FilmDaoImp filmImp = new FilmDaoImp();
private FilmService filmService= new FilmServiceImp();

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//         接收数据
        String currentPage1 = req.getParameter("currentPage");
        String pageSize1 = req.getParameter("pageSize");
        //转换成需要的类型
        //页码数
        int currentPage = Integer.parseInt(currentPage1);
        //页大小
        int pageSize = Integer.parseInt(pageSize1);
//        业务处理---查找数据
        PageBean<Film> pageBean = filmService.findByPage(currentPage, pageSize);

//将数据放入请求域
        req.setAttribute("pageBean", pageBean);


//        响应数据,页面跳转
        req.getRequestDispatcher("showFilm.jsp").forward(req, resp);


    }

}

接口----

import java.util.List;

public interface FilmDao {
 /*   List<Film> findAll() ;
*/
    List<Film> findByPage(int currentPage, int pageSize);
Integer findTotalSize();


}

查询方法抽取

package com.gavin.dao.FilmImp;


import com.gavin.pojo.Film;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Ma HaiYang
 * @Description: MircoMessage:Mark_7001
 */
public abstract class BaseDao {
    public int baseUpdate(String sql,Object ... args){
        Connection connection = null;
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
                int rows=0;
        try{
            connection = ConnectionPool.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            //设置参数
            for (int i = 0; i <args.length ; i++) {
                preparedStatement.setObject(i+1, args[i]);
            }
            //执行CURD
            rows =preparedStatement.executeUpdate();// 这里不需要再传入SQL语句
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(null != preparedStatement){
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            ConnectionPool.returnConnection(connection);
        }
        return rows;
    }


    public List baseQuery(Class clazz, String sql, Object ... args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        List list=new ArrayList<>() ;
        try{
            connection = ConnectionPool.getConnection();
            connection.setAutoCommit(false);
            preparedStatement = connection.prepareStatement(sql);//这里预编译SQL语句"select * from film limit 0,10;"
            //设置参数
            for (int i = 0; i <args.length ; i++) {
                preparedStatement.setObject(i+1, args[i]);
            }
            //System.out.println(sql);
            //执行CURD
            resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句----为什么resultset 为null返回size=0
            connection.commit();
            // 根据字节码获取所有 的属性
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                field.setAccessible(true);// 设置属性可以 访问
            }

            while(resultSet.next()){
                // 通过反射创建对象
                Object obj = clazz.newInstance();//默认在通过反射调用对象的空参构造方法
                for (Field field : fields) {// 临时用Field设置属性
                    String fieldName = field.getName();// empno  ename job .... ...
                    Object data = resultSet.getObject(fieldName);
                    field.set(obj,data);
                }
                list.add(obj);

            }

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

            FilmDaoImp.closeLink(resultSet,preparedStatement,connection);
            return list;

    }


    public Integer baseQueryInt(String sql,Object ... args) {
        Connection connection = null;
        PreparedStatement preparedStatement=null;
        ResultSet resultSet=null;
       Integer count=0;
        try{
            connection = ConnectionPool.getConnection();
            preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
            //设置参数
            for (int i = 0; i <args.length ; i++) {
                preparedStatement.setObject(i+1, args[i]);
            }
            //执行CURD
            resultSet = preparedStatement.executeQuery();// 这里不需要再传入SQL语句
            // 根据字节码获取所有 的属性
            while(resultSet.next()){
                // 通过反射创建对象
                count = resultSet.getInt(1);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            FilmDaoImp.closeLink(resultSet,preparedStatement,connection);
            return count;
        }

    }
}

连接池

package com.gavin.dao.FilmImp;

import org.apache.log4j.Logger;
import util.UtilTool;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;


public class ConnectionPool {
    //准备连接用的
    private static String DRIVER ;
   private static String URL ;
    private static String USER;
    private static String PASSWORD ;
    //准备一个池子用于盛放连接
    private static LinkedList<Connection> pool;
    //初始化大小
    private static int initSize ;
    //限制池子的最大大小
    private static int maxSize ;
    //加载该连接池类信息时就初始化了pool,pool中存放了5个连接实例
    private static Logger logger=null;

    static {
       logger= Logger.getLogger(ConnectionPool.class);
     UtilTool util= new UtilTool("/jdbc.properties");
       DRIVER = util.getProperties("DRIVER");
       URL = util.getProperties("URL");
        USER = util.getProperties("USER");
       PASSWORD= util.getProperties("PASSWORD");
       initSize=Integer.parseInt(util.getProperties("iniSize"));
        maxSize=Integer.parseInt(util.getProperties("maxSize"));
        //加载驱动
        try {

            Class.forName(DRIVER);
        } catch (ClassNotFoundException e) {
           logger.fatal("驱动加载失败",e);

        }
        //开辟空间用于初始化连接池
       pool = new LinkedList<Connection>();
       //往池子中添加5个连接实例
       for (int i = 0; i < initSize; i++) {
       Connection connection = initConnection();
        pool.addLast(connection);
            }
        }
        //初始化一个connection;
public static Connection initConnection(){
Connection connection = null;
    try {
        connection=DriverManager.getConnection(URL, USER, PASSWORD);
    } catch (SQLException e) {
        logger.error("初始化连接失败",e);
    }
return connection;

}
    //用于获得连接的方法
    public static Connection getConnection() {
        //怎么获得呢?
        //当连接池中有连接的时候,直接从里面取用
        Connection connection;
        if (pool.size() != 0) {
            connection = pool.removeFirst();
            logger.info("连接池中--"+connection.hashCode()+"被取走了");


        } else {//当连接池中没有的时候,创建一个
             connection = initConnection();
            logger.info("连接池已空--"+connection.hashCode()+"被创建了");


        }
        return connection;
    }

    //用户还回去的方法
    public static void returnConnection(Connection connection){

//什么时候往回还,要求池子内少于五个的时候我才接收
        //检测
        if(null!=connection) {//不为空

                try {//检测
                    if (!connection.isClosed()) {//连接未关闭的话
                        //检测
                        //如果池子中少于10个则可以添加进去--始终保证最大化缓冲池
                        if (pool.size() <= maxSize) {
                            //向池中增加该连接
                            connection.setAutoCommit(true);
                            pool.addLast(connection);//
                            logger.info("归还的连接"+connection.hashCode()+"符合要求,归还成功");

                        }else{//如果归还后池子中连接数大于10,则将该链接关闭
                            logger.info("池子中已满"+connection.hashCode()+"--将被关闭");

                            connection.close();
                            logger.info("池子中已满"+connection.hashCode()+"--被关闭");
                        }
                    }else{//连接关闭
                        logger.warn("归还的连接不能使用,归还失败");

                    }
                } catch (SQLException e) {
                    logger.warn("连接关闭失败");
                }

        }else{
            logger.warn("连接不能使用,归还失败");

        }

    }
    //测试连接池
    /*public static void main(String[] args) {
        Connection connection = getConnection();
        Connection connection1 = getConnection();
        try {
            connection1.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        getConnection();
        getConnection();
        getConnection();
        getConnection();
        returnConnection(connection);
        returnConnection(null);
        returnConnection(connection1);
    }*/
}

实现方法

package com.gavin.dao.FilmImp;


import com.gavin.dao.FilmDao;
import com.gavin.pojo.Film;

import java.sql.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class FilmDaoImp extends BaseDao implements FilmDao {
    static List<Film> list = new ArrayList<>();
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;

   /* @Override
    public List<Film> findAll() {
        try {
            String SQL = "select * from film;";
            connection = ConnectionPool.getConnection();
            preparedStatement = connection.prepareStatement(SQL);
            resultSet = preparedStatement.executeQuery();
            if (null != resultSet) {
                while (resultSet.next()) {
                    Integer film_id = resultSet.getInt("film_id");
                    String title = resultSet.getString("title");
                    String description = resultSet.getString("description");
                    Date release_year = resultSet.getDate("release_year");
                    Integer rental_duration = resultSet.getInt("rental_duration");
                    Double rental_rate = resultSet.getDouble("rental_rate");
                    Integer length = resultSet.getInt("length");
                    Double replacement_cost = resultSet.getDouble("replacement_cost");
                    String rating = resultSet.getString("rating");
                    String special_feature = resultSet.getString("special_feature");

                    Film film = new Film(film_id, title, description, release_year, rental_duration, rental_rate, length, replacement_cost, rating, special_feature);
                    list.add(film);
                }

            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            closeLink(resultSet, preparedStatement, connection);
        }
        return list;
    }
*/
    /**
     * @param currentPage  当前页
     * @param pageSize     页大小
     * @return
     */
    @Override
    public List findByPage(int currentPage, int pageSize) {
        String sql = "select * from film limit ?,?;";
       //从哪条记录开始
        //页大小
        List list = baseQuery(Film.class, sql,(currentPage - 1) * pageSize,pageSize);
        return list;
    }

    @Override
    public Integer findTotalSize() {
        String sql = "select count(?) from film ";
        Integer TotalSize = baseQueryInt(sql, 1);


        return TotalSize;
    }

    public static void closeLink(ResultSet resultSet, PreparedStatement preparedStatement, Connection connection) {

        try {
            if (null != resultSet)
                resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (null != preparedStatement)
                preparedStatement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        if (null != connection)
            ConnectionPool.returnConnection(connection);
    }
}

实体类封装

package com.gavin.pojo;

import java.io.Serializable;
import java.util.Date;

public class Film implements Serializable {

//    private static final long serialVersionUID = 95594597L;
    //属性
    private   Long film_id;
    private String title;
    private String description;
    private Date release_year;
    private  Long rental_duration ;
    private  Double rental_rate ;
    private Long length;
    private  Double replacement_cost;
    private String rating;
    private String special_features;

    public Film() {
    }
//构造


    public Film(Long film_id, String title, String description, Date release_year, Long rental_duration, Double rental_rate, Long length, Double replacement_cost, String rating, String special_features) {
        this.film_id = film_id;
        this.title = title;
        this.description = description;
        this.release_year = release_year;
        this.rental_duration = rental_duration;
        this.rental_rate = rental_rate;
        this.length = length;
        this.replacement_cost = replacement_cost;
        this.rating = rating;
        this.special_features = special_features;
    }

    public Long getFilm_id() {
        return film_id;
    }

    public void setFilm_id(Long film_id) {
        this.film_id = film_id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Date getRelease_year() {
        return release_year;
    }

    public void setRelease_year(Date release_year) {
        this.release_year = release_year;
    }

    public Long getRental_duration() {
        return rental_duration;
    }

    public void setRental_duration(Long rental_duration) {
        this.rental_duration = rental_duration;
    }

    public Double getRental_rate() {
        return rental_rate;
    }

    public void setRental_rate(Double rental_rate) {
        this.rental_rate = rental_rate;
    }

    public Long getLength() {
        return length;
    }

    public void setLength(Long length) {
        this.length = length;
    }

    public Double getReplacement_cost() {
        return replacement_cost;
    }

    public void setReplacement_cost(Double replacement_cost) {
        this.replacement_cost = replacement_cost;
    }

    public String getRating() {
        return rating;
    }

    public void setRating(String rating) {
        this.rating = rating;
    }

    public String getSpecial_features() {
        return special_features;
    }

    public void setSpecial_features(String special_features) {
        this.special_features = special_features;
    }

    @Override
    public String toString() {
        return "Film{" +
                "film_id=" + film_id +
                ", title='" + title + '\'' +
                ", description='" + description + '\'' +
                ", release_year=" + release_year +
                ", rental_duration=" + rental_duration +
                ", rental_rate=" + rental_rate +
                ", length=" + length +
                ", replacement_cost=" + replacement_cost +
                ", rating='" + rating + '\'' +
                ", special_feature='" + special_features + '\'' +
                '}';
    }
}

封装分页数据

package com.gavin.pojo;

import java.io.Serializable;
import java.util.List;

public class PageBean<T>  implements Serializable {
private List<T> data;
private Integer totalSize;//总记录
private Integer pageSize;//页大小
private Integer totalPage;//总页数
private Integer currentPage;//当前页

    public PageBean() {
    }

    public PageBean(List<T> data, Integer totalSize, Integer pageSize, Integer totalPage, Integer currentPage) {
        this.data = data;
        this.totalSize = totalSize;
        this.pageSize = pageSize;
        this.totalPage = totalPage;
        this.currentPage = currentPage;
    }

    public List<T> getData() {
        return data;
    }

    public void setData(List<T> data) {
        this.data = data;
    }

    public Integer getTotalSize() {
        return totalSize;
    }

    public void setTotalSize(Integer totalSize) {
        this.totalSize = totalSize;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public Integer getTotalPage() {
        return totalPage;
    }

    public void setTotalPage(Integer totalPage) {
        this.totalPage = totalPage;
    }

    public Integer getCurrentPage() {
        return currentPage;
    }

    public void setCurrentPage(Integer currentPage) {
        this.currentPage = currentPage;
    }
}

接口

import com.gavin.pojo.Film;
import com.gavin.pojo.PageBean;

public interface FilmService {
    PageBean<Film> findByPage(int currentPage, int pageSize);


}

接口实现

package service.imp;
import com.gavin.dao.FilmImp.FilmDaoImp;
import com.gavin.dao.FilmDao;
import com.gavin.pojo.Film;
import com.gavin.pojo.PageBean;
import service.FilmService;

import java.util.List;

public class FilmServiceImp implements FilmService {

    //private FilmService filmDao = new FilmServiceImp();


    //    查找数据并将分页数据封装
    @Override
    public PageBean<Film> findByPage(int currentPage, int pageSize) {
//        怎么查找?
//        通过filmDao接口中的方法
         FilmDao filmDao = new FilmDaoImp();
        查询 该页所有数据,比如第一页,10条数据
       List<Film> data = filmDao.findByPage(currentPage, pageSize);
        Integer totalSize = filmDao.findTotalSize();
        //计算总页数
        Integer totalPage = totalSize % pageSize == 0 ? totalSize : totalSize / pageSize + 1;
        //当前页
        //页大小
        PageBean<Film> pageBean = new PageBean<>(data, totalSize, pageSize, totalPage, currentPage);


        return pageBean;
    }
}

记录一下在过程中遇到的一点小问题

错误日志-----
原因时在封装对象进入List集合时由于用的时Object,对于整型会自动转为Long,而是不时Integer

修改实体类中的相应数据类型为Long就可以了;(由于考虑到有些数据可能为null,所以最好要用包装类;