数据库连接池及CRUD操作（四）

七.DAO及相关实现类

DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO
作用：为了实现功能的模块化，更有利于代码的维护和升级。
下面是尚DAO使用的体现:

【BaseDAO.java】

public abstract class BaseDao {
    //通用的增删改操作      sql中占位符的个数与可变形参个数长度一样
    public void update(Connection conn,String sql,Object...args){
        PreparedStatement ps= null;

        try {

            //2.预编译sql语句，返回PreparedStatement实例
            ps = conn.prepareStatement(sql);

            //3.填充占位符
            for(int i=0;i<args.length;i++){

                ps.setObject(i+1,args[i]);
            }
            //4.执行操作
            ps.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.closeResource(null,ps);
        }


    }



    //返回一个对象
    public <T>T  getInstance(Connection conn,Class<T> clazz,String sql,Object...args){

        PreparedStatement ps=null;
        ResultSet resultSet=null;
        try {

            conn= JDBCUtils.getConnection();

            ps=conn.prepareStatement(sql);

            for(int i=0;i< args.length;i++){

                ps.setObject(i+1,args[i]);
            }

            resultSet=ps.executeQuery();

            //获取结果集的元数据ResultSetMetaData
            ResultSetMetaData rsmd=resultSet.getMetaData();
            //通过ResultSetMetaData获取结果集中的列数

            int columnCount=rsmd.getColumnCount();

            while(resultSet.next()){
                T t=clazz.newInstance();

                for(int i=0;i<columnCount;i++){

                    Object columnValue=resultSet.getObject(i+1);

                    //获取每个列的列名
                    //String columnName=rsmd.getColumnName(i+1);
                    //获取每个列的别名
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    //给order对象指定的columnName属性，赋值columnValue，通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);

                    field.set(t,columnValue);

                }

                return  t;
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.closeResource(null,ps,resultSet);
        }

        return  null;
    }



    /*
     * 返回多个对象
     * */
    public <T> List<T> getForList(Connection conn,Class<T> clazz, String sql, Object...args){

        PreparedStatement ps=null;
        ResultSet resultSet=null;
        try {
            conn= JDBCUtils.getConnection();

            ps=conn.prepareStatement(sql);

            for(int i=0;i< args.length;i++){

                ps.setObject(i+1,args[i]);
            }

            resultSet=ps.executeQuery();

            //获取结果集的元数据ResultSetMetaData
            ResultSetMetaData rsmd=resultSet.getMetaData();
            //通过ResultSetMetaData获取结果集中的列数

            int columnCount=rsmd.getColumnCount();
            //创建集合对象
            ArrayList<T> list=new ArrayList<T>();

            while(resultSet.next()){
                T t=clazz.newInstance();

                for(int i=0;i<columnCount;i++){

                    Object columnValue=resultSet.getObject(i+1);

                    //获取每个列的列名
                    //String columnName=rsmd.getColumnName(i+1);
                    //获取每个列的别名
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    //给order对象指定的columnName属性，赋值columnValue，通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t,columnValue);
                }

                list.add(t);
            }
            return  list;

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.closeResource(null,ps,resultSet);
        }

        return  null;

    }


    //查询特殊值
    public <E>E getValue(Connection conn,String sql,Object...args) {

        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {

                ps.setObject(i + 1, args[i]);

            }

            rs = ps.executeQuery();

            if (rs.next()) {

                return (E) rs.getObject(1);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {

            JDBCUtils.closeResource(null, ps, rs);
            return null;
        }


    }



    }

【CustomerDAO.java】

public interface CustomerDao {

    //将cust对象添加到数据库中
    void insert(Connection conn, Customers cust);

    //根据id删除表中一条数据
    void deleteById(Connection conn,int id);

    //针对内存中的cust对象，去修改数据表中指定的记录
    void update(Connection conn,Customers cust);

    //根据id查询表中一条数据
    Customers getCustomerById(Connection conn,int id);

    //查询数据集合
    List<Customers> getAll(Connection conn);
    //查询数据条数
    Long getCount(Connection conn);

    //返回数据表中的最大生日

    Date getMaxBirth(Connection conn);



}

【CustomerDAOImpl.java】

public class CustomerDaoImpl extends BaseDao implements CustomerDao{


    @Override
    public void insert(Connection conn, Customers cust) {

        String sql="insert into customers(name,email,birth) values(?,?,?)";
        update(conn,sql,cust.getName(),cust.getEmail(),cust.getBirth());

    }

    @Override
    public void deleteById(Connection conn, int id) {

      String sql="delete from customers where id=?";

      update(conn,sql,id);

    }

    @Override
    public void update(Connection conn, Customers cust) {

        String sql="update customers set name = ?,email= ? where id= ?";
        update(conn,sql,cust.getName(),cust.getEmail(),cust.getId());
    }

    @Override
    public Customers getCustomerById(Connection conn, int id) {

        String sql="select id ,name,email from customers where id=?";
        Customers customers=getInstance(conn,Customers.class,sql,id);
        return  customers;

    }

    @Override
    public List<Customers> getAll(Connection conn) {
        String sql="select id ,name,email from customers";

        List<Customers> list=getForList(conn,Customers.class,sql);
        return  list;

    }

    @Override
    public Long getCount(Connection conn) {

        String sql="select count(*) from customers";
        return getValue(conn,sql);
    }

    @Override
    public Date getMaxBirth(Connection conn) {
        String sql="select max(birth) from customers";
        return getValue(conn,sql);
    }
}

对BaseDao中的查询函数进行优化

public abstract class BaseDao<T> {
    private Class<T> clazz;
    
   {
        Type type = this.getClass().getGenericSuperclass();
        ParameterizedType paramType=(ParameterizedType)type;
        Type[] typeArguments = paramType.getActualTypeArguments();//获取父类的泛型
        clazz= (Class<T>) typeArguments[0];

    }
    

    //返回一个对象
    public T  getInstance(Connection conn,String sql,Object...args){

        PreparedStatement ps=null;
        ResultSet resultSet=null;
        try {

            conn= JDBCUtils.getConnection();

            ps=conn.prepareStatement(sql);

            for(int i=0;i< args.length;i++){

                ps.setObject(i+1,args[i]);
            }

            resultSet=ps.executeQuery();

            //获取结果集的元数据ResultSetMetaData
            ResultSetMetaData rsmd=resultSet.getMetaData();
            //通过ResultSetMetaData获取结果集中的列数

            int columnCount=rsmd.getColumnCount();

            while(resultSet.next()){
                T t=clazz.newInstance();

                for(int i=0;i<columnCount;i++){

                    Object columnValue=resultSet.getObject(i+1);

                    //获取每个列的列名
                    //String columnName=rsmd.getColumnName(i+1);
                    //获取每个列的别名
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    //给order对象指定的columnName属性，赋值columnValue，通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);

                    field.set(t,columnValue);

                }

                return  t;
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.closeResource(null,ps,resultSet);
        }

        return  null;
    }



    /*
     * 返回多个对象
     * */
    public  List<T> getForList(Connection conn, String sql, Object...args){

        PreparedStatement ps=null;
        ResultSet resultSet=null;
        try {
            conn= JDBCUtils.getConnection();

            ps=conn.prepareStatement(sql);

            for(int i=0;i< args.length;i++){

                ps.setObject(i+1,args[i]);
            }

            resultSet=ps.executeQuery();

            //获取结果集的元数据ResultSetMetaData
            ResultSetMetaData rsmd=resultSet.getMetaData();
            //通过ResultSetMetaData获取结果集中的列数

            int columnCount=rsmd.getColumnCount();
            //创建集合对象
            ArrayList<T> list=new ArrayList<T>();

            while(resultSet.next()){
                T t=clazz.newInstance();

                for(int i=0;i<columnCount;i++){

                    Object columnValue=resultSet.getObject(i+1);

                    //获取每个列的列名
                    //String columnName=rsmd.getColumnName(i+1);
                    //获取每个列的别名
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    //给order对象指定的columnName属性，赋值columnValue，通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t,columnValue);
                }

                list.add(t);
            }
            return  list;

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtils.closeResource(null,ps,resultSet);
        }

        return  null;

    }

    

}

修改【CustomerDAO.java】

//根据id查询表中一条数据
Customers getCustomerById(Connection conn,int id);

//查询数据集合
List<Customers> getAll(Connection conn);

修改【CustomerDAOImpl.java】

public class CustomerDaoImpl extends BaseDao<Customers> implements CustomerDao {


    @Override
    public Customers getCustomerById(Connection conn, int id) {

        String sql="select id ,name,email from customers where id=?";
        Customers customers=getInstance(conn,sql,id);
        return  customers;

    }

    @Override
    public List<Customers> getAll(Connection conn) {
        String sql="select id ,name,email from customers";

        List<Customers> list=getForList(conn,sql);
        return  list;

    }
}

八.数据库连接池

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

• 在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：

①在主程序（如servlet、beans）中建立数据库连接
②进行sql操作
③断开数据库连接

• 这种模式开发，存在的问题

①普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection加载到内存中，再验证用户名和密码(得花费0.05s～1s的时间)。需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。数据库的连接资源并没有得到很好的重复利用。若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
②对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。（回忆：何为Java的内存泄漏？）这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。

8.2 数据库连接池技术

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

在这里插入图片描述

工作原理：

数据库连接池技术的优点

1. 资源重用

由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一 方面也增加了系统运行环境的平稳性。

2. 更快的系统反应速度

数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间

3. 新的资源分配手段

对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源

4. 统一的连接管理，避免数据库连接泄漏

在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露

8.3 多种开源的数据库连接池

• JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：

①DBCP是Apache提供的数据库连接池。tomcat 服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持。
② C3P0是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以。hibernate官方推荐使用
Proxool是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一 点
BoneCP是一个开源组织提供的数据库连接池，速度快
Druid 是阿里提供的数据库连接池，据说是集DBCP 、C3P0 、Proxool
优点于一身的数据库连接池，但是 速度不确定是否有BoneCP快

• DataSource 通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接
  池
• DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速
  度。
• 特别注意：

数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close();
但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

8.3.1 C3P0数据库连接池

获取连接方式一

//方式一
@Test
public void testGetConnection() throws Exception {

    //获取冲c3p0的连接 jdbc:mysql://localhost:3306/test?useSSL=false
    ComboPooledDataSource cpds = new ComboPooledDataSource();
    cpds.setDriverClass( "com.mysql.jdbc.Driver" ); //loads the jdbc driver
    cpds.setJdbcUrl( "jdbc:mysql://localhost:3306/test?useSSL=false" );
    cpds.setUser("root");
    cpds.setPassword("123456");
    //初始时的连接数
    cpds.setInitialPoolSize(10);
    Connection conn=cpds.getConnection();


    System.out.println(conn);

    //销毁连接池
    //DataSources.destroy((DataSource) conn);


}

获取连接方式二

 //方式二

 @Test
public void testGetConnection1() throws Exception{
     ComboPooledDataSource cpds = new ComboPooledDataSource("HelloC3p0");

     Connection conn=cpds.getConnection();
     System.out.println(conn);
 }

src下的配置文件为：【c3p0-confifig.xml】

<?xml version="1.0" encoding="UTF-8" ?>
<c3p0-config>
    <!-- This app is massive! -->
    <named-config name="HelloC3p0">
        <!--获取连接的四个基本信息-->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/test?useSSL=false</property>
        <property name="user">root</property>
        <property name="password">123456</property>


        <!--当数据库的连接池中的连接数不够是，c3p0一次性向服务器申请的连接数-->

        <!-- 初始化数据库连接池时连接的数量 -->
        <property name="initialPoolSize">5</property>
        <!-- 数据库连接池中的最小的数据库连接数 -->
        <property name="minPoolSize">5</property>
        <!-- 数据库连接池中的最大的数据库连接数 -->
        <property name="maxPoolSize">1000</property>


        <!-- C3P0 数据库连接池可以维护的 Statement 的个数 -->
        <property name="maxStatements">50</property>
        <!-- 每个连接同时可以使用的 Statement 对象的个数 -->
        <property name="maxStatementsPerConnection">5</property>


    </named-config>
</c3p0-config>

8.3.2 DBCP数据库连接池

• DBCP 是 Apache 软件基金组织下的开源连接池实现，该连接池依赖该组织下的另一个开源系统：Commonpool。如需使用该连接池实现，应在系统中增加如下两个 jar 文件：
  Commons-dbcp.jar：连接池的实现
  Commons-pool.jar：连接池实现的依赖库
• Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。
• 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
• 当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但上面的代码并没有关闭数据库的
  物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。
• 配置属性说明
  

获取连接方式一：

@Test
public  void testGetConnectoin() throws SQLException {

    BasicDataSource source=new BasicDataSource();

    source.setDriverClassName( "com.mysql.jdbc.Driver" ); //loads the jdbc driver
    source.setUrl( "jdbc:mysql://localhost:3306/test?useSSL=false" );
    source.setUsername("root");
    source.setPassword("123456");
    source.setInitialSize(10);
    source.setMaxActive(10);
    Connection conn=source.getConnection();
    System.out.println(conn);

}

获取连接方式二：

//方式一
@Test
public  void testGetConnectoin2() throws Exception {
    Properties pros=new Properties();
    //方式一
    //InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream("dbcp.properties");
    //方式二
    FileInputStream in=new FileInputStream(new File("src/dbcp.properties"));
    pros.load(in);
    DataSource source = (DataSource) BasicDataSourceFactory.createDataSource(pros);
    Connection conn=source.getConnection();
    System.out.println(conn);
    
}

src下的配置文件为：【dbcp.properties】

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

8.3.3 Druid（德鲁伊）数据库连接池

Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，可以说是目前最好的
连接池之一。

@Test
public  void getConnection() throws Exception {

    Properties pros=new Properties();
    InputStream in=ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");

    pros.load(in);
    DataSource source= DruidDataSourceFactory.createDataSource(pros);
    Connection conn=source.getConnection();

    System.out.println(conn);
}

src下的配置文件为：【druid.properties】

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

配置解释：

九.Apache-DBUtils实现CRUD操作

9.1 Apache-DBUtils简介

• commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。
• API介绍：
  org.apache.commons.dbutils.QueryRunner
  org.apache.commons.dbutils.ResultSetHandler
  工具类：org.apache.commons.dbutils.DbUtils
• API包说明：
  -index.html

9.2 主要API的使用

9.2.1 DbUtils

DbUtils ：提供如关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的所有方法都是静态的。主要方法如下：

①public static void close(…) throws java.sql.SQLException：
DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭Connection、Statement和 ResultSet。
②public static void closeQuietly(…): 这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。
③ public static void commitAndClose(Connection conn)throws SQLException： 用来提交连接的事务， 然后关闭连接
④ public static void commitAndCloseQuietly(Connection conn)：
用来提交连接，然后关闭连接，并且在 关闭连接时不抛出SQL异常。
⑤public static void rollback(Connection conn)throws SQLException：允许conn为null，因为方法内部做 了判断
⑥ public static void rollbackAndClose(Connection conn)throws SQLException
⑦rollbackAndCloseQuietly(Connection)
⑧public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异常ClassNotFoundException。

9.2.2 QueryRunner类

• 该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
• QueryRunner类提供了两个构造器：
  默认的构造器需要一个 javax.sql.DataSource 来作参数的构造器
• QueryRunner类的主要方法：

更新

public int update(Connection conn, String sql, Object… params)
throws SQLException:用来执行一个更新（插入、更新或删除）操作。

…
插入

public T insert(Connection conn,String sql,ResultSetHandler rsh,
Object… params) throws SQLException：只支持INSERT语句，其中 rsh - The handler used to create the result object fromthe ResultSet of auto-generated keys. 返回值: An object generated by the handler.即自动生成的键值

…
批处理

public int[] batch(Connection conn,String sql,Object[][] params)throws
SQLException： INSERT, UPDATE, or DELETE语句
public T insertBatch(Connection conn,String sql,ResultSetHandler rsh,Object[][]params)throws SQLException：只支持INSERT语句
…

查询

public Object query(Connection conn, String sql, ResultSetHandler
rsh,Object… params) throws
SQLException：执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理
PreparedStatement 和 ResultSet 的创建和关闭。

使用QueryRunner类提插入数据

/*
* 增删改
* */
@Test
public  void testInsert(){

    Connection conn= null;
    try {
        QueryRunner runner=new QueryRunner();

        conn = JDBCUtils1.testGetConnection3();
        String sql="insert into customers(name,email,birth) values(?,?,?)";

        int insertCount=runner.update(conn,sql,"蔡徐坤","caixukun@qq.com","1998-09-09");
        System.out.println(insertCount+"条记录");
    } catch (SQLException throwables) {
        throwables.printStackTrace();
    }
    JDBCUtils1.closeResource(conn,null);

}

使用QueryRunner类提查询数据

9.2.3 ResultSetHandler接口及实现类

该接口用于处理 java.sql.ResultSet，将数据按要求转换为另一种形式。
ResultSetHandler 接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)。
接口的主要实现类：

①ArrayHandler：把结果集中的第一行数据转成对象数组。
②ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
③BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
④BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
⑤ColumnListHandler：将结果集中某一列的数据存放到List中。
⑥KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。 MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
⑦MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List ScalarHandler：查询单个值对象

/*
* 查询
* BeanHandler:是ResultSetHandler接口的实现类，用于封装表中的一条数据
* */

@Test
public  void testQuery1(){

    Connection conn= null;
    try {

        QueryRunner runner=new QueryRunner();
        conn = JDBCUtils1.testGetConnection3();
        String sql="select id,name,email,birth from customers where id=?";
        BeanHandler<Customers> handler=new BeanHandler<>(Customers.class);
        Customers customers = runner.query(conn, sql, handler, 23);

        System.out.println(customers);


    } catch (SQLException throwables) {
        throwables.printStackTrace();
    }
    JDBCUtils1.closeResource(conn,null);
}

/*
 * 查询
 * BeanHandler:是BeanListHandler接口的实现类，用于封装表中的多条数据
 * */

@Test
public  void testQuery2(){
    Connection conn= null;
    try {
        QueryRunner runner=new QueryRunner();

        conn = JDBCUtils1.testGetConnection3();
        String sql="select id,name,email,birth from customers where id<?";
        BeanListHandler<Customers> listHandler=new BeanListHandler<>(Customers.class);
        List<Customers> list = runner.query(conn, sql, listHandler, 23);


        list.forEach(System.out::println);

    } catch (SQLException throwables) {
        throwables.printStackTrace();
    }
    JDBCUtils1.closeResource(conn,null);
}


/*
 * 查询
 * BeanHandler:是ResultSetHandler接口的实现类，对应表中的一条数据
 * */

@Test
public  void testQuery3(){
    Connection conn= null;
    try {
        QueryRunner runner=new QueryRunner();
        conn = JDBCUtils1.testGetConnection3();
        String sql="select id,name,email,birth from customers where id=?";

        MapHandler handler=new MapHandler();

        Map<String, Object> map = runner.query(conn, sql, handler, 23);

        System.out.println(map);


    } catch (SQLException throwables) {
        throwables.printStackTrace();
    }
    JDBCUtils1.closeResource(conn,null);
}

@Test
public  void testQuery4(){
    Connection conn= null;
    try {
        QueryRunner runner=new QueryRunner();
        conn = JDBCUtils1.testGetConnection3();
        String sql="select id,name,email,birth from customers where id<?";

        MapListHandler listHandler = new MapListHandler();


        final List<Map<String, Object>> lists = runner.query(conn, sql, listHandler, 23);

      lists.forEach(System.out::println);


    } catch (SQLException throwables) {
        throwables.printStackTrace();
    }
    JDBCUtils1.closeResource(conn,null);
}


@Test
public  void testQuery5(){
    Connection conn= null;
    try {
        QueryRunner runner=new QueryRunner();
        conn = JDBCUtils1.testGetConnection3();
       // String sql="select count(*) from customers ";

        String sql="select max(birth) from customers "; 

        ScalarHandler handler=new ScalarHandler();
        Object query = runner.query(conn, sql, handler);
        System.out.println(query);


    } catch (SQLException throwables) {
        throwables.printStackTrace();
    }
    JDBCUtils1.closeResource(conn,null);
}



@Test
public  void testQuery6(){
    Connection conn= null;
    try {
        QueryRunner runner=new QueryRunner();
        conn = JDBCUtils1.testGetConnection3();
        // String sql="select count(*) from customers ";

        String sql="select id,name,email,birth from customers where id = ?";


        ResultSetHandler<Customers> handler=new ResultSetHandler<Customers>(){

            @Override
            public Customers handle(ResultSet resultSet) throws SQLException {

                //return  new Customers(12,"成龙","chenglong@qq.com",new Date(12432444324L));

                if(resultSet.next()){
                    int id=resultSet.getInt("id");
                    String name=resultSet.getString("name");
                    String email=resultSet.getString("email");
                    Date birth=resultSet.getDate("birth");
                    Customers customers=new Customers(id,name,email,birth);
                    return  customers;
                }
                return  null;

            }
        };

        final Customers query = runner.query(conn, sql, handler,23);
        System.out.println(query);


    } catch (SQLException throwables) {
        throwables.printStackTrace();
    }
    JDBCUtils1.closeResource(conn,null);
}