JdbcUtils最终版（使用common-dbutil、编写TxQueryRunner、处理多线程）

落日映苍穹つ 2021-06-15 20:36 319阅读 0赞

我自己都很懵逼，不知道自己干了啥。

好像主要是为了分离service层和dao层的工作，还得让他们使用同一个connection。然后编写了一个TxqueryRunner进一步封装整合，最后还处理了多线程并发访问的问题。
我要疯了。
先把代码贴上，留着慢慢消化。

JDBCUtils：

  1. package com.veeja.jdbc;
  3. //import java.io.InputStream;
  4. import java.sql.Connection;
  5. //import java.sql.DriverManager;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.sql.Statement;
  9. //import java.util.Properties;
  11. import javax.sql.DataSource;
  13. import com.mchange.v2.c3p0.ComboPooledDataSource;
  15. public class JDBCUtils { 
  16.     // static String driverClass = null;
  17.     // static String url = null;
  18.     // static String user = null;
  19.     // static String passwd = null;
  20.     //
  21.     // static { 
  22.     // try { 
  23.     // // 1. 创建一个属性配置对象
  24.     // Properties properties = new Properties();
  25.     //
  26.     // // 2. 把properties文件转化为inputstream流
  27.     //
  28.     // // 方法一：如果把properties文件放在工程的根目录下，可以使用下面的语句读取这个文件
  29.     // // InputStream is = new FileInputStream("jdbc.properties");
  30.     //
  31.     // // 方法二：使用类加载器，去读取src目录下的资源文件
  32.     // InputStream is = JDBCUtils.class.getClassLoader()
  33.     // .getResourceAsStream("jdbc.properties");
  34.     //
  35.     // // 3. 导入输入流。
  36.     // properties.load(is);
  37.     //
  38.     // // 4. 读取属性
  39.     // driverClass = properties.getProperty("driverClass");
  40.     // url = properties.getProperty("url");
  41.     // user = properties.getProperty("user");
  42.     // passwd = properties.getProperty("passwd");
  43.     // } catch (Exception e) { 
  44.     // e.printStackTrace();
  45.     // }
  46.     // }
  48.     // /**
  49.     // * 注册驱动
  50.     // */
  51.     // private static void registerDriver() { 
  52.     // // DriverManager.registerDriver(new com.mysql.jdbc.Driver());
  53.     // try { 
  54.     // Class.forName(driverClass);
  55.     // } catch (ClassNotFoundException e) { 
  56.     // e.printStackTrace();
  57.     // }
  58.     // }
  60.     public static ComboPooledDataSource dataSource = new ComboPooledDataSource();
  62.     /** * 返回连接处建立的数据库连接 * * @return * @throws SQLException */
  63.     public static Connection getConnection() throws SQLException { 
  64.         Connection connection = tl.get();
  65.         // 当connection不为null的时候表示事务已经开始了。
  66.         if (connection != null)
  67.             return connection;
  69.         return dataSource.getConnection();
  71.         // Connection conn = null;
  72.         // try { 
  73.         // // 2. 建立连接 参数1：协议+访问数据库 参数2：用户名 参数3：密码
  74.         // conn = DriverManager.getConnection(url, user, passwd);
  75.         // } catch (Exception e) { 
  76.         // e.printStackTrace();
  77.         // }
  78.         // System.out.println("获取数据库连接connection");
  79.         // return conn;
  80.     }
  82.     /** * 返回连接池对象 */
  83.     public DataSource getDataSource() { 
  84.         return dataSource;
  85.     }
  87.     /** * 释放资源 * * @param conn * @param st * @param rs */
  88.     public static void release(Connection connection, Statement statement,
  89.             ResultSet resultSet) { 
  90.         closeRs(resultSet);
  91.         closeSt(statement);
  92.         closeConn(connection);
  93.     }
  95.     // 释放ResultSet对象
  96.     private static void closeRs(ResultSet resultSet) { 
  97.         System.out.println("释放ResultSet对象");
  98.         try { 
  99.             if (resultSet != null) { 
  100.                 resultSet.close();
  101.             }
  102.         } catch (SQLException e) { 
  103.             e.printStackTrace();
  104.         } finally { 
  105.             resultSet = null;
  106.         }
  107.     }
  109.     // 释放Statement对象
  110.     private static void closeSt(Statement statement) { 
  111.         System.out.println("释放Statement对象。");
  112.         try { 
  113.             if (statement != null) { 
  114.                 statement.close();
  115.             }
  116.         } catch (SQLException e) { 
  117.             e.printStackTrace();
  118.         } finally { 
  119.             statement = null;
  120.         }
  121.     }
  123.     // 释放数据库连接。
  124.     private static void closeConn(Connection connection) { 
  125.         System.out.println("释放数据库连接。");
  126.         try { 
  127.             if (connection != null) { 
  128.                 connection.close();
  129.             }
  130.         } catch (SQLException e) { 
  131.             e.printStackTrace();
  132.         } finally { 
  133.             connection = null;
  134.         }
  135.     }
  137.     // 事务专用连接！
  138.     private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
  140.     /** * 开启事务，获取一个connection，设置它的setAutoCommit(false)。 还要保证DAO中使用的连接使我们刚刚创建的。 * * @throws SQLException */
  141.     public static void beginTransaction() throws SQLException { 
  142.         Connection connection = tl.get();
  143.         if (connection != null) { 
  144.             throw new SQLException("事务已经开启了，请不要重复开启事务！");
  145.         }
  146.         // 创建一个connection，设置为手动提交
  147.         // 把这个connection给dao用
  148.         // 还要让commitTransaction或者rollbackTransaction可以获取到。
  149.         connection = getConnection();
  150.         connection.setAutoCommit(false);
  152.         tl.set(connection);// 把当前线程的连接保存起来
  153.     }
  155.     /** * 提交事务，获取beginTransaction提供的Connection，然后调用commit方法 * * @throws SQLException */
  156.     public static void commitTransaction() throws SQLException { 
  157.         Connection connection = tl.get();// 获取当前线程的连接
  158.         if (connection == null) { 
  159.             throw new SQLException("事务还没有开启，无法提交事务！");
  160.         }
  161.         connection.commit();
  162.         connection.close();
  163.         // 把它设置为null，表示事务已经结束了。再次调用getConnection()返回的就不是connection了
  164.         // connection = null;
  165.         tl.remove();// 从tl中移除了
  166.     }
  168.     /** * 回滚事务，获取beginTransaction提供的Connection，然后调用rollback方法 * * @throws SQLException */
  169.     public static void roolbackTransaction() throws SQLException { 
  170.         Connection connection = tl.get();// 获取当前线程的连接
  171.         if (connection == null) { 
  172.             throw new SQLException("事务还没有开启，无法回滚事务！");
  173.         }
  174.         connection.rollback();
  175.         connection.close();
  176.         // 把它设置为null，表示事务已经结束了。再次调用getConnection()返回的就不是connection了
  177.         // connection = null;
  178.         tl.remove();
  179.     }
  181.     /** * 释放连接 * * @param connection * @throws SQLException */
  182.     public static void releaseConnection(Connection connection)
  183.             throws SQLException { 
  184.         Connection connection1 = tl.get();
  185.         /** * 判断是否为事务专用连接，如果是，就不关闭。 如果是事务专用连接，那么就要关闭连接。 */
  186.         // 如果connection=null,说明现在没有事务，那么connection一定不是事务专用连接
  187.         if (connection1 == null) { 
  188.             connection1.close();
  189.         }
  190.         // 如果connection！=null ，说明事务开启了，那么需要判断是否为事务专用连接.
  191.         // 如果参数连接与connection是否相等，如果不相等，说明不是事务专用连接
  192.         if (connection1 != null) { 
  193.             connection1.close();
  194.         }
  195.     }
  196. }

TxQueryRunner

覆写父类中所有没有使用connection的方法。

  1. package com.veeja.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.SQLException;
  6. import org.apache.commons.dbutils.QueryRunner;
  7. import org.apache.commons.dbutils.ResultSetHandler;
  9. /** * * 这个类中的方法，自己来处理连接的问题 . 无需外界传递! * 通过JdbcUtils.getConnection()得到连接! * 有可能是事务连接，也可能是普通的连接! * JdbcUtils.releaseConnection()完成对连接的释放! 如果是普通连接，关闭之! * * @author Veeja.Liu * @emial veejaliu@gmail.com * */
  11. public class TxQueryRunner extends QueryRunner { 
  13.     public int[] batch(String sql, Object[][] params) throws SQLException { 
  14.         // 1.得到连接
  15.         // 2.执行父类方法,传递连接对象
  16.         // 3. 释放连接
  17.         // 4. 返回值
  18.         Connection connection = JDBCUtils.getConnection();
  19.         int[] result = super.batch(connection, sql, params);
  20.         JDBCUtils.releaseConnection(connection);
  21.         return result;
  23.     }
  25.     public Object query(String sql, Object param, ResultSetHandler rsh)
  26.             throws SQLException { 
  27.         // 1.得到连接
  28.         // 2.执行父类方法,传递连接对象
  29.         // 3. 释放连接
  30.         // 4. 返回值
  31.         Connection connection = JDBCUtils.getConnection();
  32.         Object result = super.query(connection, sql, param, rsh);
  33.         JDBCUtils.releaseConnection(connection);
  34.         return result;
  35.     }
  37.     public Object query(String sql, Object[] params, ResultSetHandler rsh)
  38.             throws SQLException { 
  39.         // 1.得到连接
  40.         // 2.执行父类方法,传递连接对象
  41.         // 3. 释放连接
  42.         // 4. 返回值
  43.         Connection connection = JDBCUtils.getConnection();
  44.         Object result = super.query(connection, sql, params, rsh);
  45.         JDBCUtils.releaseConnection(connection);
  46.         return result;
  47.     }
  49.     public Object query(String sql, ResultSetHandler rsh, Object[] params)
  50.             throws SQLException { 
  51.         // 1.得到连接
  52.         // 2.执行父类方法,传递连接对象
  53.         // 3. 释放连接
  54.         // 4. 返回值
  55.         Connection connection = JDBCUtils.getConnection();
  56.         Object result = super.query(connection, sql, rsh, params);
  57.         JDBCUtils.releaseConnection(connection);
  58.         return result;
  59.     }
  61.     public Object query(String sql, ResultSetHandler rsh) throws SQLException { 
  62.         // 1.得到连接
  63.         // 2.执行父类方法,传递连接对象
  64.         // 3. 释放连接
  65.         // 4. 返回值
  66.         Connection connection = JDBCUtils.getConnection();
  67.         Object result = super.query(connection, sql, rsh);
  68.         JDBCUtils.releaseConnection(connection);
  69.         return result;
  70.     }
  72.     public int update(String sql) throws SQLException { 
  73.         // 1.得到连接
  74.         // 2.执行父类方法,传递连接对象
  75.         // 3. 释放连接
  76.         // 4. 返回值
  77.         Connection connection = JDBCUtils.getConnection();
  78.         int result = super.update(connection, sql);
  79.         JDBCUtils.releaseConnection(connection);
  80.         return result;
  81.     }
  83.     public int update(String sql, Object param) throws SQLException { 
  84.         // 1.得到连接
  85.         // 2.执行父类方法,传递连接对象
  86.         // 3. 释放连接
  87.         // 4. 返回值
  88.         Connection connection = JDBCUtils.getConnection();
  89.         int result = super.update(connection, sql, param);
  90.         JDBCUtils.releaseConnection(connection);
  91.         return result;
  92.     }
  94.     public int update(String sql, Object[] params) throws SQLException { 
  95.         // 1.得到连接
  96.         // 2.执行父类方法,传递连接对象
  97.         // 3. 释放连接
  98.         // 4. 返回值
  99.         Connection connection = JDBCUtils.getConnection();
  100.         int result = super.update(connection, sql, params);
  101.         JDBCUtils.releaseConnection(connection);
  102.         return result;
  103.     }
  104. }

Dao

这里的测试并不规范。

  1. package com.veeja.jdbc;
  2. import java.sql.SQLException;
  3. import org.apache.commons.dbutils.QueryRunner;
  4. public class UserDao { 
  5.     public static void main(String[] args) throws SQLException { 
  6.         Integer id = new Integer(1);
  7.         String name = "aaaa";
  8.         update(name, id);
  9.     }
  10.     public static void update(String name, Integer id) throws SQLException { 
  11.         QueryRunner qRunner = new TxQueryRunner();
  12.         String sql = "update student set name = ? where id = ?";
  13.         Object[] params = {  name, id };
  14.         qRunner.update(sql, params);
  15.     }
  16. }

发表评论

表情：
评论列表 （有 0 条评论，319人围观）

还没有评论，来说两句吧...

相关阅读