数据库事务处理与资源池

-- 查看autocommit自动提交是否关闭
> SHOW VARIABLES LIKE 'autocommit';  
"autocommit"	"ON"

-- 当前终端临时关闭自动提交
> SET autocommit = off;

-- 开始事务处理
> START TRANSACTION;

-- 提交或者回滚事务
commit;     --- 提交事务， 数据将会写到磁盘上的数据库
rollback ;  --- 数据回滚，回到最初的状态。

CREATE TABLE account(
    `id` INT PRIMARY KEY AUTO_INCREMENT,
    `name` VARCHAR(64) NOT NULL,
    `money` FLOAT DEFAULT 0
);

INSERT INTO account VALUES (null,'WeiyiGeek',1000),(null,'muzi',1000);

package top.weiyigeek.Web;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.junit.Test;
import top.weiyigeek.Util.db;

public class Test_transaction {
  @Test
  public void transaction() {
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
      conn = db.getConn();
      
      //1.连接:事务默认就是自动提交的。 关闭自动提交。
      conn.setAutoCommit(false);
      
      String sql = "update account set money = money - ? where id = ?";
      ps = conn.prepareStatement(sql);
      
      //2.扣钱:扣ID为1 的100块钱
      ps.setInt(1, 100);
      ps.setInt(2, 1);
      ps.executeUpdate();
      
      //3.设置的异常，查看事务提交的影响
      int a = 10 /0 ;
      
      //4.加钱， 给ID为2 加100块钱
      ps.setInt(1, -100);
      ps.setInt(2, 2);
      ps.executeUpdate();
      
      //5.成功： 提交事务。
      conn.commit();
      
    } catch (SQLException e) {
      try {
        //6.在3步骤会产生异常则进入catch{} 将回滚事务
        conn.rollback();
        System.out.println("nSQL 事务提交异常，已自动回滚事务!");
      } catch (SQLException e1) {
        e1.printStackTrace();
      }
      e.printStackTrace();
      
    }finally {
      db.release(conn, ps, rs);
    }
  }
}

-- 查询
SQL > select @@tx_isolation;
-- +-----------------+
-- | @@tx_isolation  |
-- +-----------------+
-- | REPEATABLE-READ |
-- +-----------------+
-- 1 row in set (0.00 sec)

-- 修设置当前窗口的事务隔离级别为
SQL > set session transaction isolation level read uncommitted;
-- Query OK, 0 rows affected (0.00 sec)

-- 1.修改当前隔离级别为`read uncommitted`
db_window-1 > set session transaction isolation level read uncommitted;
-- Query OK, 0 rows affected (0.00 sec)

-- 2.查询是否修改成功
db_window-1 > select @@tx_isolation;
+------------------+
| @@tx_isolation   |
+------------------+
| READ-UNCOMMITTED |
+------------------+
1 row in set (0.00 sec)

-- 3.终端2的隔离级别默认就是可重复读
db_window-2 > select @@tx_isolation;
+-----------------+
| @@tx_isolation  |
+-----------------+
| REPEATABLE-READ |
+-----------------+
1 row in set (0.00 sec)

db_window-2 > update account set money = money + 100 where id = 1;
Query OK, 1 row affected (0.11 sec)
Rows matched: 1  Changed: 1  Warnings: 0

-- 4.开启事务
db_window-2 > start transaction;
Query OK, 0 rows affected (0.00 sec)
db_window-1 > start transaction;
Query OK, 0 rows affected (0.00 sec)


db_window-2 > update account set money = money - 100 where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

-- 5.终端1读取了终端2还未提交的数据
db_window-1 > select * from account;
| id | name      | money |
|  1 | WeiyiGeek |  1100 |
|  2 | muzi      |  900 |


-- 6.提交事务（实际终端1已经从内存中读取了数据）
db_window-2 > commit;

-- 1.设置终端1的隔离级别
db_window-1 > set session transaction isolation level read committed;
Query OK, 0 rows affected (0.00 sec)

db_window-1 > select @@tx_isolation;
+----------------+
| @@tx_isolation |
+----------------+
| READ-COMMITTED |
+----------------+
1 row in set (0.00 sec)

-- 2.终端1开启事务
db_window-1 > start transaction;
Query OK, 0 rows affected (0.00 sec)

-- 3.终端1查询原始数据
db_window-1 > select * from account;
+----+-----------+-------+
| id | name      | money |
+----+-----------+-------+
|  1 | WeiyiGeek |  1000 |
|  2 | muzi      |  1000 |
+----+-----------+-------+
2 rows in set (0.00 sec)

-- 4.终端2开始事务
db_window-2 > select @@tx_isolation;
+-----------------+
| @@tx_isolation  |
+-----------------+
| REPEATABLE-READ |
+-----------------+
1 row in set (0.00 sec)

db_window-2 > start transaction;
Query OK, 0 rows affected (0.00 sec)


-- 5.终端2执行更操作
db_window-2 > update account set money = money - 100 where id = 1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

db_window-2 > update account set money = money + 100 where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

-- 6.终端1执行查询操作（数据没有变化）
db_window-1 > select * from account;
+----+-----------+-------+
| id | name      | money |
+----+-----------+-------+
|  1 | WeiyiGeek |  1000 |
|  2 | muzi      |  1000 |
+----+-----------+-------+
2 rows in set (0.00 sec)

-- 7.终端2执行commit
db_window-2 > commit;
Query OK, 0 rows affected (0.05 sec)

-- 8.提交后终端1查询数据发现已改变
db_window-1 > select * from account;
+----+-----------+-------+
| id | name      | money |
+----+-----------+-------+
|  1 | WeiyiGeek |   900 |
|  2 | muzi      |  1100 |
+----+-----------+-------+
2 rows in set (0.00 sec)

-- 1.终端1设置隔离性可重复读并查看当前隔离性
db_window-1 > set session transaction isolation level repeatable read;
Query OK, 0 rows affected (0.00 sec)

db_window-1 > select @@tx_isolation;
+-----------------+
| @@tx_isolation  |
+-----------------+
| REPEATABLE-READ | 
+-----------------+
1 row in set (0.00 sec)

-- 2.终端1显示原始数据
db_window-1 > select * from account;
+----+-----------+-------+
| id | name      | money |
+----+-----------+-------+
|  1 | WeiyiGeek |  1000 |
|  2 | muzi      |  1000 |
+----+-----------+-------+
2 rows in set (0.00 sec)

-- 3.终端1开始事务
db_window-1 > start transaction;
Query OK, 0 rows affected (0.00 sec)


-- 4.终端2查看当前隔离性以及开启事务
db_window-2 > select @@tx_isolation;
+-----------------+
| @@tx_isolation  |
+-----------------+
| REPEATABLE-READ |
+-----------------+
1 row in set (0.00 sec)

db_window-2 > start transaction;
Query OK, 0 rows affected (0.00 sec)

-- 5.终端2执行更新操作
db_window-2 > update account set money = money - 100 where id = 1;
Query OK, 1 row affected (0.06 sec)
Rows matched: 1  Changed: 1  Warnings: 0

db_window-2 > update account set money = money + 100 where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

-- 6.终端1执行查询语句结果任然未改变
db_window-1 > select * from account;
+----+-----------+-------+
| id | name      | money |
+----+-----------+-------+
|  1 | WeiyiGeek |  1000 |
|  2 | muzi      |  1000 |
+----+-----------+-------+
2 rows in set (0.00 sec)

-- 7.终端2执行提交数据
db_window-2 > commit;
Query OK, 0 rows affected (0.08 sec)


-- 8.终端1执行查询数据任然无变化(查询结果和以前的查询结果一致不会发生改变。)
db_window-1 > select * from account;
+----+-----------+-------+
| id | name      | money |
+----+-----------+-------+
|  1 | WeiyiGeek |  1000 |
|  2 | muzi      |  1000 |
+----+-----------+-------+
2 rows in set (0.00 sec)

-- 1.终端1设置 Serializable 可串行化隔离级别
db_window-1 > set session transaction isolation level serializable;
Query OK, 0 rows affected (0.00 sec)

db_window-1 > select @@tx_isolation;
+----------------+
| @@tx_isolation |
+----------------+
| SERIALIZABLE   |
+----------------+
1 row in set (0.00 sec)

-- 2.终端2当前隔离性
db_window-2 > select @@tx_isolation;
+-----------------+
| @@tx_isolation  |
+-----------------+
| REPEATABLE-READ |
+-----------------+
1 row in set (0.00 sec)

-- 3.终端1查询原始数据
db_window-1 > select * from account;
| id | name      | money |
|  1 | WeiyiGeek |  1000 |
|  2 | muzi      |  1000 |

-- 4.终端2先开启事务
db_window-2 > start transaction;
Query OK, 0 rows affected (0.00 sec)

-- 5.终端1其次开启事务
db_window-1 > start transaction;
Query OK, 0 rows affected (0.00 sec)


-- 6.终端2执行增删改查SQL(没有任何问题)
db_window-2 > insert into account values (null,'mariadb',1000);
Query OK, 1 row affected (0.00 sec)


-- 7.终端1等待终端2的事务执行完成后执行，否则会阻塞包括(CURD)
db_window-1 > update account set money = money - 100 where id = 3;
-- 等待终端2Commit提交事务 
Query OK, 1 row affected (46.09 sec)
Rows matched: 1  Changed: 1  Warnings: 0

-- 8.终端2的事务执行完成后，上面那条update语句才可以执行
db_window-2 > commit;
Query OK, 0 rows affected (0.07 sec)

-- 9.终端1此时可执行任意的CURD语句
db_window-1 > select * from account;
+----+-----------+-------+
| id | name      | money |
+----+-----------+-------+
|  1 | WeiyiGeek |  1000 |
|  2 | muzi      |  1000 |
|  3 | mariadb   |   900 |
+----+-----------+-------+
3 rows in set (0.00 sec)

// 调用连接池使用:/User/src/top/weiyigeek/Web/Test_Pool.java
public class Test_Pool {
  @Test
  public void testPool() throws SQLException {
    Connection conn = null;
    PreparedStatement ps =null;
    //注意这里需要避免重复申请对象所以需要使用单例;
    CustomDatasource ds = CustomDatasource.getInstance();
    try {
      //获取资源池的链接对象
      conn = ds.getConnection();
      String sql = "SELECT * FROM user LIMIT 0,10";
      ps = conn.prepareStatement(sql);
      ResultSet rs = ps.executeQuery();
      while(rs.next()) {
        System.out.println("ID: " + rs.getInt("id") + " , Name = " + rs.getString("name")+", 登录时间 = " + rs.getDate("uptime"));
      }
      rs.close();
    } catch (Exception e) {
      // TODO: handle exception
      e.printStackTrace();
    } finally {
      try {
        //关闭PreparedStatementd对象
        ps.close();
      } catch (Exception e2) {
        // TODO: handle exception
        e2.printStackTrace();
      }
      //归还对象
      //ds.addBack(conn); //采用装饰后便不使用此种方法
      conn.close();
    }
  }
}

/**
 * @Desc:装饰设计模式数据库连接关闭归还
 * @author WeiyiGeek
 * @CreatTime 下午2:48:41
 */
public class ConnectionWrap implements Connection {
  //1.构造方法接入connection连接以及连接池集合
  Connection connection = null;
  List <Connection> list ;
  public ConnectionWrap(Connection connection , List <Connection> list) {
    super();
    this.connection = connection;
    this.list = list;
  }
  
  //2.解析预处理SQL语句
  @Override
  public PreparedStatement prepareStatement(String sql) throws SQLException {
    return connection.prepareStatement(sql);
  }
  
  //3.重写Close方法
  @Override
  public void close() throws SQLException {
    // TODO Auto-generated method stub
    //connection.close(); //还可以调用原本的close
    System.out.println("有人来归还连接对象了> 归还之前，池子里面可用连接数："+list.size());
    list.add(connection);
    System.out.println("有人来归还连接对象了> 归还之后，池子里面可用连接数："+list.size());
    }

    ......   
}

import top.weiyigeek.Util.db;
public class CustomDatasource implements DataSource {
  // 数据库资源池建立的方法
  //0.创建本类对象并且对外提供公共的访问方法
  private static CustomDatasource s = new CustomDatasource();
  public static CustomDatasource getInstance() {
    return s;
  }
  // 1.建立存储连接池对象的集合
  List <Connection> list = new ArrayList<Connection>();
  
   public CustomDatasource()  {
     //2.建立连接对象存储到资源池中
     for(int i = 0; i < 10;i++) {
      Connection conn;
      try {
        conn = db.getConn();
        list.add(conn);
      } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
     }
  }
  
  //3.连接池对外公布的获取连接的方法 
  @Override
  public Connection getConnection() throws SQLException {
    // TODO Auto-generated method stub
    //4.判断资源池是否用完是则添加3个连接对象到资源池(当然资源池是有限制的)
     if (list.size() == 0 ) {
       try {
         for(int i = 0; i < 5; i++)
           list.add(db.getConn());
      } catch (SQLException e) {
        e.printStackTrace();
      }
     }
    //返还并移出第一个元素
    Connection conn = list.remove(0); 
    //修饰模式在把这个对象抛出去的时候， 对这个对象进行包装。(重点值得学习)
    Connection connection = new ConnectionWrap(conn, list);
    return connection;
  }

  
  //5.归还连接对象
  public void addBack(Connection conn) {
    list.add(conn);
  }

    .....
}

package top.weiyigeek.DBCP;
/**
 * 
 * @Desc: OBCP Apache 开源数据连接管理框架的使用
 * @author WeiyiGeek
 * @CreatTime 下午12:45:22
 */
public class OBCPDemo1 {
  @SuppressWarnings("resource")
  @Test
  public void testOBCP () {
    //1.构建数据源对象
    BasicDataSource dataSource = new BasicDataSource();
    
    //2.得到连接对象
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    
    //3.数据库配置（手动）
    dataSource.setDriverClassName("org.mariadb.jdbc.Driver");
    //主协议 子协议 数据库IP:Port 数据库
    dataSource.setUrl("jdbc:mariadb://127.0.0.1:3306/student");
    dataSource.setUsername("root");
    dataSource.setPassword("");
    
    try {
      conn = dataSource.getConnection();
      //4.解析SQL语句
      ps = conn.prepareStatement("SELECT * FROM user ORDER BY id DESC LIMIT 0,?");
      ps.setInt(1, 10);
      rs = ps.executeQuery();
      while(rs.next()) {
        System.out.println(rs.getInt("id") + " ---- " + rs.getString("name") +  " ---- " + rs.getInt("grade"));
      }
      rs.close();
    } catch (SQLException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } finally {
      //db.release(conn, ps, rs);
      //释放资源建议重写close方法
    }
  }
}

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbc
username=root
password=

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000


#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=utf8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

/**
 * 
 * @Desc: OBCP读取配置文件来配置数据库连接
 * @author WeiyiGeek
 * @CreatTime 下午1:26:18
 */
public class OBCPDemo2 {
  
  @Test
  public void testDemo2() throws Exception {
    //1.利用Properties读取配置文件中数据
    Properties prop = new Properties();
    InputStream is = this.getClass().getClassLoader().getResourceAsStream("dbcp.properties");  //将项目中的jdbc.properties读取进输入流
    prop.load(is);

    //2.构建连接对象
    BasicDataSourceFactory factory = new BasicDataSourceFactory();
    DataSource datasource = factory.createDataSource(prop);  //引入properties文件
    
    //3.得到连接对象
    Connection conn = datasource.getConnection();
    PreparedStatement ps = conn.prepareStatement("SELECT * FROM user LIMIT 0,10");
    ResultSet rs = ps.executeQuery();
    
    //4.打印出来从数据库中读取的数据
    while(rs.next()) {
      System.out.println(rs.getInt("id") + " ---- " + rs.getString("name") +  " ---- " + rs.getInt("grade"));
    }
    
    //5.关闭连接
    System.out.println("连接关闭");
    rs.close();
    ps.close();
    conn.close();
  }
}

import top.weiyigeek.Util.db;
import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Demo1 {
  @Test
  public void Demo1() throws PropertyVetoException,Exception {
    //1.创建DataSource
    ComboPooledDataSource cpds = new ComboPooledDataSource();
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    
    //2.设置数据库连接信息
    cpds.setDriverClass("org.mariadb.jdbc.Driver");
    cpds.setJdbcUrl("jdbc:mariadb://127.0.0.1:3306/student");
    cpds.setUser("root");
    cpds.setPassword("");

    //3.得到连接对象
    conn = cpds.getConnection();
    ps = conn.prepareStatement("SELECT * FROM user LIMIT 0,?");
    ps.setInt(1, 20);

    //4.执行SQL查询
    rs = ps.executeQuery();
    System.out.println("序号 - 姓名 - 年级");
    while (rs.next()) {
      System.out.println(rs.getInt("id") + " - " + rs.getString("name") + " - " + rs.getShort("grade"));
    }
    
    //5.关闭连接
    db.release(conn, ps, rs);
  }
}

<c3p0-config>
  <default-config>
    <property name="driverClass">org.mariadb.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mariadb://127.0.0.1:3306/student</property>
    <property name="user">root</property>
    <property name="password"></property>

    <property name="automaticTestTable">con_test</property>
    <property name="checkoutTimeout">30000</property>
    <property name="idleConnectionTestPeriod">30</property>
    <property name="initialPoolSize">10</property>
    <property name="maxIdleTime">30</property>
    <property name="maxPoolSize">100</property>
    <property name="minPoolSize">10</property>
    <property name="maxStatements">200</property>

    <user-overrides user="test-user">
      <property name="maxPoolSize">10</property>
      <property name="minPoolSize">1</property>
      <property name="maxStatements">0</property>
    </user-overrides>
  </default-config>
<!--可以配置多种数据库-->
  <named-config name="mysql">
    <property name="driverClass">org.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/student</property>
    <property name="user">root</property>
    <property name="password"></property>
  </named-config>

<!--可以配置多种数据库-->
  <named-config name="oracle">
    <property name="driverClass">oracle.jdbc.driver.OracleDriver</property>
    <property name="jdbcUrl">jdbc:oracle:thin:@192.168.10.25:1521:student</property>
    <property name="user">master</property>
    <property name="password"></property>
  </named-config>
</c3p0-config>

package top.weiyigeek.C3P0;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.junit.Test;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import top.weiyigeek.Util.db;
/**
 * 
 * @Desc: C3P0 通过xml文件配置读取数据库连接以及连接池配置(实际与Demo1差不不大)
 * @author WeiyiGeek
 * @CreatTime 下午2:38:55
 */
public class C3P0Demo2 {
  
  @Test
  public void demo2() throws SQLException {
    //1.创建DataSource并且读取设置数据库连接信息（c3p0-config.xml）
    ComboPooledDataSource cpds = new ComboPooledDataSource();
    //ComboPooledDataSource cpds = new ComboPooledDataSource("oracle"); //可以指定配置文件中连接指定的数据库
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;

    //2.得到连接对象
    conn = cpds.getConnection();
    ps = conn.prepareStatement("SELECT count(*) FROM user");

    //3.执行SQL查询
    rs = ps.executeQuery();
    System.out.println("序号 - 姓名 - 年级");
    while (rs.next()) {
      System.out.println("学生总数: "+rs.getInt(1) );
    }
    //4.关闭连接
    db.release(conn, ps, rs);
  }
}

三月 19, 2020 2:44:34 下午 com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource getPoolManager
信息: Initializing c3p0 pool... com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 3, acquireRetryAttempts -> 30, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> con_test, breakAfterAcquireFailure -> false, checkoutTimeout -> 30000, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, dataSourceName -> 1hgevwha81v0n140s2kcd6|33b37288, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> org.mariadb.jdbc.Driver, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, identityToken -> 1hgevwha81v0n140s2kcd6|33b37288, idleConnectionTestPeriod -> 30, initialPoolSize -> 10, jdbcUrl -> jdbc:mariadb://127.0.0.1:3306/student, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 30, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 100, maxStatements -> 200, maxStatementsPerConnection -> 0, minPoolSize -> 10, numHelperThreads -> 3, numThreadsAwaitingCheckoutDefaultUser -> 0, preferredTestQuery -> null, properties -> {user=******, password=******}, propertyCycle -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, usesTraditionalReflectiveProxies -> false ]
序号 - 姓名 - 年级
学生总数: 84
已关闭数据库连接并释放资源

import com.mchange.v2.c3p0.ComboPooledDataSource;
/***
 * @Desc: 数据库连接工具类采用c3p0的方式（精简我们的代码）
 * @author WeiyiGeek
 * @CreatTime 下午1:28:57
 */
public class db1 {
  static ComboPooledDataSource cpds = null;
  static {
    cpds = new ComboPooledDataSource();
  }
  
  /**
	 * 获取C3P0中的链接对象
	 * @return Connection
	 */
  public static Connection getConn() throws SQLException {
    return cpds.getConnection();
  }
  
  /**
	 * Fun:关闭数据库连接并释放资源 （注意点:关闭的顺序）
	 * @param conn
	 * @param st
	 * @param rs
	 */
  public static void release(Connection conn,Statement st, ResultSet rs) {
    closeRs(rs);
    closeSt(st);
    closeConn(conn);
    System.out.println("n已关闭数据库连接并释放资源n");
  }
  
  //私有静态方法-释放查询结果集
  private static void closeRs(ResultSet rs) {
      try {
        if(rs != null)
          rs.close();
      } catch (SQLException e) {
        e.printStackTrace();
      } finally {
        rs = null;
      }
    }
    
  //私有静态方法-释放statement对象
  private static void closeSt(Statement st) {
      try {
        if(st != null)
          st.close();
      } catch (SQLException e) {
        e.printStackTrace();
      } finally {
        st = null;
      }
    }
    
  //私有静态方法-关闭数据库连接
  private static void closeConn(Connection conn) {
    try {
      if(conn != null)
        conn.close();
    } catch (SQLException e) {
      e.printStackTrace();
    } finally {
      conn = null;
    }
  }
}

Person res = qr.query("select * from person", new BeanHandler<Person>(Person.class));    
List<Person> lp = runner.query("SELECT * FROM person ", new BeanListHandler<Person>(Person.class));

package top.weiyigeek.DBUtil;
public class Account {
  private int id;
  private String name;
  private float money;
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public float getMoney() {
    return money;
  }
  public void setMoney(float money) {
    this.money = money;
  }
  
  @Override
  public String toString() {
    return "Account [序号=" + id + ", 姓名=" + name + ", 工资=" + money + "]";
  } 
}

package top.weiyigeek.DBUtil;

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

import javax.sql.DataSource;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import com.mchange.v2.c3p0.ComboPooledDataSource;

/*
 * Function: DButil CURD 案例实现 
 */
public class DBUtilDemo1 {
  //调用实现
  public static void main(String[] args) throws SQLException {
    ComboPooledDataSource cpds = new ComboPooledDataSource();
    //示例1.插入测试
    if(insert(cpds)>0) {
      System.out.println("插入成功");
    }else {
      System.err.println("插入失败");
    }
    
    //示例2.测试删除
    if(delete(cpds)>0) {
      System.out.println("删除成功");
    }else {
      System.err.println("删除失败");
    }
    
    //示例3.测试更新
    if(update(cpds)>0) {
      System.out.println("更新成功");
    }else {
      System.err.println("更新失败");
    }
    
    
    //示例4.测试匿名实现类进行返回查询结果
    Account account = queryone(cpds);
    System.out.println(account.toString());
    
    
    //示例5.通过DBuntil中ResultSetHandler实现接口来返回结果;
    List<Account> ls = querytwo(cpds);
    for(Account worker:ls) {
      System.out.println(worker.toString());
    }

  }
  
  //（1）Function:如方法名称测试SQL插入语句
  public static int insert(DataSource cpds) throws SQLException {
    QueryRunner qr = new QueryRunner(cpds);
    int flag = qr.update("INSERT INTO account VALUES (null,?,?)","张伟",1024);
    return flag;
  }
  
  //（2）Function:如方法名称测试SQL删除语句
  public static int delete(DataSource cpds) throws SQLException {
    QueryRunner qr = new QueryRunner(cpds);
    int flag = qr.update("DELETE FROM account where name = ?","张伟");
    return flag;
  }
  
  //（3）Function:如方法名称测试SQL更新语句
  public static int update(DataSource cpds) throws SQLException {
    QueryRunner qr = new QueryRunner(cpds);
    int flag = qr.update("UPDATE account SET money=money+100 where id = ? and name = ?",1,"WeiyiGeek");
    return flag;
  }
  
  //（4）Function:如方法名称测试SQL查询语句
  public static Account queryone(DataSource cpds) throws SQLException {
    QueryRunner qr = new QueryRunner(cpds);
    //匿名类实现
    Account account = qr.query("SELECT * FROM account WHERE id = ?", new ResultSetHandler<Account>() {
      @Override
      public Account handle(ResultSet rs) throws SQLException {
        // TODO Auto-generated method stub
        Account account = new Account();
        while(rs.next()) {
          int id = rs.getInt("id");
          String name = rs.getString("name");
          float money = (float)rs.getInt("money");
          account.setId(id);
          account.setName(name);
          account.setMoney(money);
        }
        return account;
      }
    }, 1);
    
    return account;
  }
  
  //（5）采用ResultSetHandler中的，resultset转换为其他对象进行实现。
  public static List<Account> querytwo(DataSource cpds) throws SQLException {
    QueryRunner qr = new QueryRunner(cpds);
    //- BeanHander - 返回一个对象;
    //- BeanListHander - 返回一个装有对象的集合;
    List<Account> list= qr.query("SELECT * FROM account", new BeanListHandler<Account>(Account.class));
    return list;
  }
}