10.2Page模型实现分页

package cn.it.bz.JDBC;
import java.util.ArrayList;
import java.util.List;
//分页查询的实体类
public class Page<T> {
    //当前页
    private int currentPage;
    //每页显示的条数
    private int pageSize;
    //总条数
    private int total;
    //总页数
    private int totalPages;
    //结果集,泛型更具通用性
    private List<T> list;
    public Page() {
    }
    public Page(int currentPage, int pageSize, int total, int totalPages, List<T> list) {
        this.currentPage = currentPage;
        this.pageSize = pageSize;
        this.total = total;
        this.totalPages = totalPages;
        this.list = list;
    }
    public int getCurrentPage() {
        return currentPage;
    }
    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }
    public int getPageSize() {
        return pageSize;
    }
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
    public int getTotal() {
        return total;
    }
    public void setTotal(int total) {
        this.total = total;
    }
    public int getTotalPages() {
        return totalPages;
    }
    public void setTotalPages(int totalPages) {
        this.totalPages = totalPages;
    }
    public List<T> getList() {
        return list;
    }
    public void setList(List<T> list) {
        this.list = list;
    }
}

package cn.it.bz.JDBC;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
//分页查询
public class TestPage {
    //page作用有两个：传递分页参数；存储查询结果。
    public Page<Users> getUsers(Page page){
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        List<Users> list = new ArrayList<Users>();
          try {
              con = JdbcUtils.getConnection();
              ps =  con.prepareStatement("select * from users limit ?,?");
              //绑定参数:(当前页-1)*每页显示的条数
              ps.setInt(1,(page.getCurrentPage()-1)*page.getPageSize());
              ps.setInt(2,page.getPageSize());
              //执行查询
              resultSet = ps.executeQuery();
              while (resultSet.next()) {
                  Users users = new Users();
                  users.setUserid(resultSet.getInt("userid"));
                  users.setUsername(resultSet.getString("username"));
                  users.setUserage(resultSet.getInt("userage"));
                  list.add(users);
              }
              //存结果集
              page.setList(list);
              //查询总条数
              ps = con.prepareStatement("select count(*) from users");
              resultSet = ps.executeQuery();
              while (resultSet.next()) {
                  int total = resultSet.getInt(1);
                  page.setTotal(total);
                  //总页数=总条数/每页显示的条数；不能整除就向上取整。
                  int totalPage = (int)Math.ceil(total / page.getPageSize() * 1.0);
                  page.setTotalPages(totalPage);
              }
          }catch (Exception e) {
              e.printStackTrace();
          }finally {
             JdbcUtils.closeDQLResource(resultSet,ps,con);
          }
        return page;
    }
    public static void main(String[] args) {
            Page page = new Page();
            page.setCurrentPage(2);
            page.setPageSize(20);
            TestPage testPage = new TestPage();
            Page<Users> users = testPage.getUsers(page);
        for (Users users1 : users.getList()) {
            System.out.println(users1);
        }
        System.out.println("当前是第"+page.getCurrentPage()+"页。共"+page.getTotalPages()+"页。");
        System.out.println("当前页有"+page.getPageSize()+"条数据。共"+page.getTotal()+"条数据。");
    }
}

十一、数据库连接池

11.1数据库连接池简介

11.1.1什么是数据库连接池

数据库连接池（Connection pooling）是程序启动时建立足够的数据库连接，并将这些连接组成一个连接池，由程序动态地对池中的连接进行申请，使用，释放。

它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

11.1.2不使用数据库连接池存在的问题

普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection加载到内存中，再验证用户名和密码，所以整个过程比较耗时。
需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。数据库的连接资源并没有得到很好的重复利用。若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。

11.1.3JDBC数据库连接池的必要性

数据库连接池的基本思想：为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

11.1.4数据库连接池的优点

资源重用：由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
更快的系统反应速度：数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间。
新的资源分配手段：对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置实现某一应用最大可用数据库连接数的限制避免某一应用独占所有的数据库资源.
统一的连接管理：避免数据库连接泄露在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露。

11.1.5常用的数据库连接池

c3p0：是一个开源组织提供的数据库连接池，速度相对较慢，稳定性还可以。
DBCP：是Apache提供的数据库连接池。速度相对c3p0较快，但自身存在bug。
Druid：是阿里提供的数据库连接池，据说是集DBCP、c3p0优点于一身的数据库连接池，目前经常使用。

11.2Druid使用

11.2.1Druid使用步骤

1、导入druid-1.2.8.jar包到lib目录下，并引入到项目中

2、在src下创建一个druid.properties类型的文件，并写入

url=jdbc:mysql://localhost:3306/test
driverClassName=com.mysql.cj.jdbc.Driver
username=root
password=123456
initialSize=10
maxActive=20

3、加载配置文件

4、获取连接池对象

5、通过连接池对象获取连接

11.2.2druid配置信息

配置	缺省值	说明
name		配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是："DataSource-" + System.identityHashCode(this)
url		连接数据库的url。
username		连接数据库的用户名。
password		连接数据库的密码。
driverClassName	根据url自动识别	这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)
initialSize	0	初始化时建立物理连接的个数。
maxActive	8	最大连接池数量
minIdle		最小连接池数量
maxWait		获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
poolPreparedStatements	false	是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
maxOpenPreparedStatements	-1	要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
validationQuery		用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
testOnBorrow	true	申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturn	false	归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testWhileIdle	false	建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
timeBetweenEvictionRunsMillis		有两个含义： 1) Destroy线程会检测连接的间隔时间2) testWhileIdle的判断依据，详细看testWhileIdle属性的说明
numTestsPerEvictionRun		不再使用，一个DruidDataSource只支持一个EvictionRun
minEvictableIdleTimeMillis
connectionInitSqls		物理连接初始化的时候执行的sql
exceptionSorter	根据dbType自动识别	当数据库抛出一些不可恢复的异常时，抛弃连接
filters		属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
proxyFilters		类型是List<com.alibaba.druid.filter.Filter>，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系

11.2.3获取数据库连接

package cn.it.bz.JDBC;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;
//Druid连接池
public class TestDruid {
    public static void main(String[] args) throws Exception {
        //加载配置字节输入流
        InputStream resourceAsStream = TestDruid.class.getClassLoader().getResourceAsStream("cn/it/bz/JDBC/druid.properties");
        //创建配置文件工具类
        Properties properties = new Properties();
        //加载配置文件
        properties.load(resourceAsStream);
        //获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
        //获取连接
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }
}

11.2.4基于Druid封装工具类

package cn.it.bz.JDBC;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.rmi.ConnectIOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JdbcDruidUtil {
    //数据库连接池对象
    private static DataSource dataSource;
    //初始化
    static {
        try {
            //获取读取配置文件的字节输入流对象
            InputStream resourceAsStream = JdbcDruidUtil.class.getClassLoader().getResourceAsStream("cn/it/bz/JDBC/druid.properties");
            //创建配置文件工具类
            Properties properties = new Properties();
            //加载配置文件
            properties.load(resourceAsStream);
            //创建连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取数据库连接对象
    public static Connection getConnection(){
        Connection con = null;
        try {
            con = dataSource.getConnection();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return con;
    }
    //归还连接对象
    public static void closeConnection(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //提交事务
    public  static void commit(Connection conn) {
        if (conn != null) {
            try {
                conn.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //事务回滚
    public static void rollback(Connection conn) {
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //关闭statement对象（preparedStatement）
    public static void closeStatement(Statement stmt) {
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //关闭resultSet
    public static void closeResultSet(ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //关闭DML操作时的资源
    public static void closeDMLResource(Statement ps, Connection con){
        closeStatement(ps);//先关闭statement对象
        closeConnection(con);//再关闭Connection对象
    }
    //关闭DQL时的资源
    public static void closeDQLResource(ResultSet rs, Statement stmt, Connection conn) {
        closeResultSet(rs);//先关闭ResultSet
        closeStatement(stmt);//再关闭Statement
        closeConnection(conn);//最后关闭Connection
    }
}

十二、应用程序分层

12.1应用程序分层简介

应用程序分层是指通过创建不同的包来实现项目的分层，将项目中的代码根据功能做具体划分，并存放在不同的包下。

三层结构

三层结构就是将整个业务应用划分为：表述层、业务逻辑层、数据访问层。区分层次的目的即为了“高内聚低耦合”的思想。在软件体系架构设计中，分层式结构是最常见，也是最重要的一种结构。

分层优点

分层结构将应用系统划分为若干层，每一层只解决问题的一部分，通过各层的协作提供整体解决方案。大的问题被分解为一系列相对独立的子问题，局部化在每一层中，这样就有效的降低了单个问题的规模和复杂度，实现了复杂系统的第一步也是最为关键的一步分解。
分层结构具有良好的可扩展性，为应用系统的演化增长提供了一个灵活的支持，具有良好的可扩展性。增加新的功能时，无须对现有的代码做修改，业务逻辑可以得到最大限度的重用。
分层结构易于维护。在对系统进行分解后，不同的功能被封装在不同的层中，层与层之间的耦合显著降低。因此在修改某个层的代码时，只要不涉及层与层之间的接口，就不会对其他层造成严重影响。

分层命名

表述层：web或controller

业务层：service

数据访问层：dao (Data Access Object)

JAVA进阶 JDBC技术学习笔记（四）