Java c3p0 oracle 数据库连接池 代码实现 （二）

最新推荐文章于 2025-05-16 10:21:00 发布
转载 最新推荐文章于 2025-05-16 10:21:00 发布 · 1.2k 阅读 · 0
文章标签：

#数据库连接池 #c3p0 #oracle #java #exception #parameters

本文介绍了一个Java实现的数据库访问类，该类提供了多种执行SQL语句的方法，包括单条SQL执行、批量执行以及带参数的SQL执行，并实现了SQL查询功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

DatabaseAccessImpl.java
package com.database;
import java.io.*;
import java.sql.*;
import java.util.*;
import org.apache.commons.logging.*;
public class DatabaseAccessImpl implements DatabaseAccessInterface {
private static Log log = LogFactory.getLog(DatabaseAccessImpl.class);
public void executeSQL(String sqlStatement) throws SQLException {
    Connection connection = null;
    PreparedStatement statement = null;
    try {
      connection = DBConnectionManager.getConnection();
      connection.setAutoCommit(true);
      statement = connection.prepareStatement(sqlStatement);
      statement.execute();
    } catch (SQLException ex) {
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return;
}

public void executeSQL(String sqlStatement, Object parameters[]) throws SQLException {
    Connection connection = null;
    PreparedStatement statement = null;
    try {
      connection = DBConnectionManager.getConnection();
      connection.setAutoCommit(true);
      statement = connection.prepareStatement(sqlStatement);
      // 获取执行数据
      if (parameters != null && parameters.length > 0) {
        for (int i = 0; i < parameters.length; i++) {
          statement.setObject(i + 1, parameters[i]);
        }
      }
      statement.execute();
    } catch (SQLException ex) {
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return;
}

public void executeSQL(String sqlStatement, List parameters) throws SQLException {
    Connection connection = null;
    PreparedStatement statement = null;
    try {
      connection = DBConnectionManager.getConnection();
      connection.setAutoCommit(true);
      statement = connection.prepareStatement(sqlStatement);
      // 获取执行数据
      int listsize = parameters.size();
      for (int i = 0; i < listsize; i++) { statement.setObject(i + 1, parameters.get(i)); }
      statement.execute();
    } catch (SQLException ex) {
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return;
}

public void executeSQL(String[] sqlStatement) throws SQLException {
    Connection connection = null;
    PreparedStatement statement = null;
    if (sqlStatement == null || sqlStatement.length == 0) {
      throw new SQLException();
    }
    try {
      connection = DBConnectionManager.getConnection();
      connection.setAutoCommit(false);
      int slength = sqlStatement.length;// 事务中sql语句的个数
      for (int i = 0; i < slength; i++) {
        statement = connection.prepareStatement(sqlStatement[i]);
        statement.execute();
      }
      connection.commit();
    } catch (SQLException ex) {
      connection.rollback();
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      connection.rollback();
      ex.printStackTrace();
    } finally {
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return;
}

public void executeSQL(String[] sqlStatement, List parameters) throws SQLException {
    Connection connection = null;
    PreparedStatement statement = null;
    if (sqlStatement == null || sqlStatement.length == 0) {
      throw new SQLException();
    }
    try {
      connection = DBConnectionManager.getConnection();
      connection.setAutoCommit(false);
      int slength = sqlStatement.length;// 事务中sql语句的个数
      for (int i = 0; i < slength; i++) {
        statement = connection.prepareStatement(sqlStatement[i]);
        if (parameters != null) {
          Object[] pm = (Object[]) parameters.get(i);
          // 获取执行数据
          int pmsize = 0;// 每条sql数据对应的参数个数
          if (pm != null) {
            pmsize = pm.length;
          }
          for (int j = 0; j < pmsize; j++) {
            statement.setObject(j + 1, pm[j]);
          }
        }
        statement.execute();
      }
      connection.commit();
    } catch (SQLException ex) {
      connection.rollback();
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      connection.rollback();
      ex.printStackTrace();
    } finally {
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return;
}

public Vector executeQuerySQL(String sqlStatement) throws SQLException {
    Vector resultVector = new Vector();
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet rs = null;
    try {
      connection = DBConnectionManager.getConnection(); // 获取数据库连接对象
      connection.setAutoCommit(false);
      statement = connection.prepareStatement(sqlStatement); // 获取statement对象
      statement.execute();
      rs = statement.getResultSet(); // 获取查询记录集
      HashMap rowItem;
      for (; rs.next(); resultVector.add(rowItem)) {
        rowItem = new HashMap();
        int columnCount = rs.getMetaData().getColumnCount();
        for (int i = 1; i <= columnCount; i++) {
          Object cell = rs.getObject(i);
          if (cell == null) {
            cell = "";
          } else if (cell instanceof Blob) {
            try {
              InputStreamReader in = new InputStreamReader(((Blob) cell).getBinaryStream());
              char bufferString[] = new char[5000];
              int readCharCount = in.read(bufferString);
              StringBuffer bolbStringBuffer = new StringBuffer("");
              for (; readCharCount == 5000; readCharCount = in.read(bufferString)) {
                bolbStringBuffer.append(bufferString, 0, readCharCount);
              }
              if (readCharCount != -1) {
                bolbStringBuffer.append(bufferString, 0, readCharCount);
              }
              cell = bolbStringBuffer.toString();
              in.close();
            } catch (Exception ex) {
              ex.printStackTrace();
            }
          }
          rowItem.put(rs.getMetaData().getColumnName(i), cell);
        }
      }
    } catch (SQLException ex) {
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      try {
        rs.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return resultVector;
}

public Vector executeQuerySQL(String sqlStatement, Object parameters[]) throws SQLException {
    Vector resultVector = new Vector();
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet rs = null;
    try {
      connection = DBConnectionManager.getConnection(); // 获取数据库连接对象
      connection.setAutoCommit(false);
      statement = connection.prepareStatement(sqlStatement); // 获取statement对象
      // 获取查询参数
      if (parameters != null && parameters.length > 0) {
        for (int i = 0; i < parameters.length; i++) {
          statement.setObject(i + 1, parameters[i]);
        }
      }
      statement.execute();
      rs = statement.getResultSet(); // 获取查询记录集
      HashMap rowItem;
      for (; rs.next(); resultVector.add(rowItem)) {
        rowItem = new HashMap();
        int columnCount = rs.getMetaData().getColumnCount();
        for (int i = 1; i <= columnCount; i++) {
          Object cell = rs.getObject(i);
          if (cell == null) {
            cell = "";
          } else if (cell instanceof Blob) {
            try {
              InputStreamReader in = new InputStreamReader(((Blob) cell).getBinaryStream());
              char bufferString[] = new char[5000];
              int readCharCount = in.read(bufferString);
              StringBuffer bolbStringBuffer = new StringBuffer("");
              for (; readCharCount == 5000; readCharCount = in.read(bufferString)) {
                bolbStringBuffer.append(bufferString, 0, readCharCount);
              }
              if (readCharCount != -1) {
                bolbStringBuffer.append(bufferString, 0, readCharCount);
              }
              cell = bolbStringBuffer.toString();
              in.close();
            } catch (Exception ex) {
              ex.printStackTrace();
              log.error(ex.getMessage());
            }
          }
          rowItem.put(rs.getMetaData().getColumnName(i), cell);
        }
      }
    } catch (SQLException ex) {
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      try {
        rs.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return resultVector;
}

public Vector executeQuerySQL(String sqlStatement, List parameters) throws SQLException {
    Vector resultVector = new Vector();
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet rs = null;
    try {
      connection = DBConnectionManager.getConnection(); // 获取数据库连接对象
      connection.setAutoCommit(false);
      statement = connection.prepareStatement(sqlStatement); // 获取statement对象
      // 获取查询数据
      int listsize = parameters.size();
      for (int i = 0; i < listsize; i++) {
        statement.setObject(i + 1, parameters.get(i));
      }
      statement.execute();
      rs = statement.getResultSet(); // 获取查询记录集
      HashMap rowItem;
      for (; rs.next(); resultVector.add(rowItem)) {
        rowItem = new HashMap();
        int columnCount = rs.getMetaData().getColumnCount();
        for (int i = 1; i <= columnCount; i++) {
          Object cell = rs.getObject(i);
          if (cell == null) {
            cell = "";
          } else if (cell instanceof Blob) {
            try {
              InputStreamReader in = new InputStreamReader(((Blob) cell).getBinaryStream());
              char bufferString[] = new char[5000];
              int readCharCount = in.read(bufferString);
              StringBuffer bolbStringBuffer = new StringBuffer("");
              for (; readCharCount == 5000; readCharCount = in.read(bufferString)) {
                bolbStringBuffer.append(bufferString, 0, readCharCount);
              }
              if (readCharCount != -1) {
                bolbStringBuffer.append(bufferString, 0, readCharCount);
              }
              cell = bolbStringBuffer.toString();
              in.close();
            } catch (Exception ex) {
              ex.printStackTrace();
            }
          }
          rowItem.put(rs.getMetaData().getColumnName(i), cell);
        }
      }
    } catch (SQLException ex) {
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      try {
        rs.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return resultVector;
}

public String getSequenceNum(String tableName) throws SQLException {
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet rs = null;
    String squenceNumber = "";
    String sequenceStatement = "select " + tableName + "_seq.nextval from dual";
    try {
      connection = DBConnectionManager.getConnection();
      statement = connection.prepareStatement(sequenceStatement);
      rs = statement.executeQuery();
      rs.next();
      squenceNumber = rs.getBigDecimal(1).toString();
    } catch (SQLException ex) {
      ex.printStackTrace();
      throw ex;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      try {
        rs.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        statement.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
      try {
        connection.close();
      } catch (SQLException ex) {
        ex.printStackTrace();
      }
    }
    return squenceNumber;
}
}

C3P0数据库连接池【JAVA】-oracle数据库为例
Demon的专栏
01-05 2万+
java项目中数据库的连接池选用了C3P0,个人感觉还是挺好用的，目前没有发现什么问题，主要是配置上的结合，今天总结一下如何使用及通用配置解析。 1.第三方jar 我使用的是 c3p0-0.9.2-pre4.jar 2. 刚开始使用这个的时候，由于项目比较紧张，我采用的是set方式来进行配置，其实后来一了解，繁琐了很多，当初的方式如下： //数据库连接池 使用C3P0数据库连接池 p
数据库连接池c3p0jar包
09-10
总的来说，C3P0作为一款成熟的数据库连接池，对于Java开发者来说，是一个值得信赖的工具，可以帮助我们更有效地管理和使用数据库连接，提升应用程序的性能和可靠性。在实际项目中，根据具体需求合理配置C3P0，可以更...
c3p0 连接oracle数据库必备jar包.rar
07-08
c3p0 连接池 连接oracle数据库必备jar包
java c3p0方式连接oracle mysql 的basedao
清叶 的专栏
09-21 1534
带有main方式 测试  ： package cn.com.systop.common; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException
Java数据库连接池c3p0和Oracle JDBC驱动配置与应用
最新发布
weixin_36328210的博客
05-16 621
c3p0是一个开源的JDBC连接池，它提供了简单易用的方式来管理数据库连接。在Java企业级应用中，数据库连接池是数据库交互中不可或缺的一部分，它有助于提高性能和资源利用效率。c3p0连接池能够缓存多个数据库连接，允许应用程序快速取得和释放连接，从而减少了频繁的数据库连接和断开所带来的开销。本章将深入探讨c3p0连接池的基本概念、它为什么对现代Java应用如此重要，以及如何在项目中充分利用它来提高性能。
java c3p0配置oracle_Java c3p0 oracle 数据库连接池 代码实现 （一）
weixin_39681644的博客
03-06 280
编译及运行环境：winxp+jdk5.0+eclipse3.2+oracle9i所需jar包：oracle9.jar(oralce驱动器)c3p0-0.9.1.2.jarlog4j-1.2.8.jarcommons-logging.jarSystemConfigResources.properties #oracle configDRIVER_NAME=oracle.jdbc.driver.Ora...
java c3p0 oracle_使用C3P0连接Oracle报错
weixin_42282482的博客
03-04 324
错误信息：java.sql.SQLException: Connections could not be acquired from the underlying database!at com.mchange.v2.sql.SqlUtils.toSQLException(SqlUtils.java:118)at com.mchange.v2.c3p0.impl.C3P0PooledConnect...
c3p0数据库连接池案例
11-28
总的来说，c3p0数据库连接池案例提供了一个完整的示例，涵盖了从配置到使用的全过程，有助于加深对数据库连接池概念的理解，并提升你在Java项目中的数据库管理能力。通过实践这个案例，你可以掌握如何更高效、更稳定...
数据库连接池c3p0所需jar包
11-23
- **commons-pool**：Apache Commons Pool是通用的对象池服务，可以用于创建各种资源的池化，包括C3P0在内的数据库连接池在底层使用了这个库来实现对象的管理和复用。 在实际开发中，你通常会将这些JAR包添加到项目...
c3p0下载 数据库连接池jar包
12-11
数据库连接池jar包 内置了c3p0-config.xml配置文件 jar包在lib中 c3p0-0.9.5.5.jar c3p0-oracle-thin-extras-0.9.5.5.jar mchange-commons-java-0.2.19.jar
C3P0数据库连接池
11-06
C3P0数据库连接池是一种开源的Java数据库连接池组件，它允许应用程序高效地管理和...总的来说，C3P0数据库连接池是Java应用程序实现高效数据库访问的重要工具，通过合理配置和使用，能够显著提升系统的稳定性和性能。
c3p0数据库连接池所需jar包c3p0-oracle-thin-extras-0.9.1.2.rar
07-26
c3p0数据库连接池所需jar包，c3p0数据库连接池所需jar包c3p0-oracle-thin-extras-0.9.1.2、c3p0-0.9.1.2.jar、c3p0-0.9.1.2-jdk1.3.jar 　　1、首先在项目下创建一个文件夹，保存我们的jar包。在项目名上右击，依次点击【New】-->【Floder】，打开新建文件夹窗口 　　2、输入文件夹名称【lib】，点击【ok】。我们通常在lib文件夹中存放从外部引入的jar包 　　3、找到我们要引入的jar包，鼠标选中jar包，然后按住鼠标左键不放，把jar包拖到lib文件夹中。或先复制jar包，然后在lib文件夹上右击，选择复制。此时，打开选择框，我们选择默认的【copy files】，点击【OK】关闭。然后我们就可以在lib文件夹下看到我们复制成功的jar包。 　　4、此时，只是把jar包复制到项目中，还不能使用。我们再在项目名上右击，依次选择【Build Path】-->【Configure Build Path...】。 　　5、在打开的窗口中，先选中【Libraries】页，再从右边的按钮中点击【add JARs...】 　　6、在打开的窗口中，我们依次展开本项目的项目和lib文件夹，然后选中我们刚才复制到项目中的jar包，然后点击【OK】关闭窗口 　　7、此时，我们在刚才打开的【Libraries】页中可以看到我们引入的jar包的名称。点击【OK】确认。 　　8、此时，在Eclipse中，我们就可以使用这个jar包了。
c3p0-0.9.1.jar 和连接oracle的驱动classes12.jar
07-31
使用c3p0连接oracle时的驱动jar和c3p0的jar包，本人亲自验证过。具体配置信息可查找http://blog.youkuaiyun.com/hanchangning19890201
Oracle-Driver(支持c3p0等连接池)
12-18
Oracle连接池驱动包,本人亲测支持c3p0等主流数据库连接池.
C3P0 jar包，还有oracle的jdbc连接jar包
08-16
其中包含C3P0的jar包，本人测试使用了oracle数据库，因此里面还有oracle jdbc的驱动jar包
java-3分钟解决c3p0连接oracle数据库到使用数据库
此后如竟没有炬火我便是唯一的光
06-29 1073
明确jdk版本 找寻对应的JDBC jar包 Oracle数据库JDBC driver 版本 与 JDK版本的关系导入对应的jdbc jar包编写配置文件
c3p0 配置的方式连接postgres
yk583443123的博客
03-16 1432
1、写配置文件，注意配置的名字与属性 <?xml version="1.0" encoding="utf-8" ?> <c3p0-config> <named-config name="testc3p0"> <property name="user">postgres </property> &...
更改C3P0连接池的XML配置
05-27 4529
看了一堆博客文章，更改c3p0的xml文件的路径使用以下方式 System.setProperty("com.mchange.v2.c3p0.cfg.xml","resources/settings/c3p0-config.xml"); 按照以上方式配置后一直报 caused by: Connections could not be acquired from the underly
Spring中为postgresql配置C3P0数据源
iteye_10114的博客
09-21 1563
C3P0是一个开放源代码的JDBC数据源实现项目，JDBC3和JDBC2扩展规范说明的 Connection 和Statement 池。下面是使用C3P0配置一个 PostgreSQL数据源：Sring applicationContext.xml 配置代码:  1&lt;bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledD...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值