新乡做网站的公司有那些,页面永久升级,18款禁用app软件免费下载,酒店建设网站的优势有哪些DBCP组件
许多Apache项目支持与关系型数据库进行交互。为每个用户创建一个新连接可能很耗时#xff08;通常需要多秒钟的时钟时间#xff09;#xff0c;以执行可能需要毫秒级时间的数据库事务。对于一个公开托管在互联网上的应用程序#xff0c;在同时在线用户数量可能非…DBCP组件
许多Apache项目支持与关系型数据库进行交互。为每个用户创建一个新连接可能很耗时通常需要多秒钟的时钟时间以执行可能需要毫秒级时间的数据库事务。对于一个公开托管在互联网上的应用程序在同时在线用户数量可能非常大的情况下为每个用户打开一个连接可能是不可行的。因此开发人员通常希望在所有当前应用程序用户之间共享一组“池化”的打开连接。在任何给定时间实际执行请求的用户数量通常只是活跃用户总数的非常小的百分比在请求处理期间是唯一需要数据库连接的时间。应用程序本身登录到DBMS并在内部处理任何用户账户问题。
已经有几个数据库连接池可用包括Apache产品内部和其他地方。这个Commons包提供了一个机会来协调创建和维护一个高效、功能丰富的包以Apache许可证发布。
commons-dbcp2依赖于commons-pool2中的代码以提供底层的对象池机制。
不同版本
DBCP现在有四个不同的版本支持不同版本的JDBC。
它的工作原理如下
开发中
DBCP 2.5.0及以上版本在Java 8JDBC 4.2及以上版本下编译和运行。
DBCP 2.4.0在Java 7JDBC 4.1及以上版本下编译和运行。
运行中
应用程序运行在Java 8及以上版本的情况下应使用DBCP 2.5.0及以上版本的二进制文件。 应用程序在Java 7下运行时应使用DBCP 2.4.0的二进制文件。 DBCP 2基于Apache Commons Pool并提供了与DBCP 1.x相比性能增强、JMX支持以及许多其他新功能。升级到2.x的用户应该注意到Java包名称已更改以及Maven坐标已更改因为DBCP 2.x与DBCP 1.x不是二进制兼容的。用户还应该注意一些配置选项例如maxActive到maxTotal已更名以与Commons Pool使用的新名称对齐。
入门例子
您可以从我们的下载页面下载源代码和二进制文件。
或者您可以从中央 Maven 存储库中提取它
maven 引入
dependencygroupIdorg.apache.commons/groupIdartifactIdcommons-dbcp2/artifactIdversion2.9.0/version
/dependency
代码 https://github.com/apache/commons-dbcp/tree/HEAD/doc BasicDataSourceExample
这个是最基本的例子不涉及任何池化能力。
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;import javax.sql.DataSource;//
// Here are the dbcp-specific classes.
// Note that they are only used in the setupDataSource
// method. In normal use, your classes interact
// only with the standard JDBC API
//
import org.apache.commons.dbcp2.BasicDataSource;//
// Heres a simple example of how to use the BasicDataSource.
////
// Note that this example is very similar to the PoolingDriver
// example.//
// To compile this example, youll want:
// * commons-pool-2.3.jar
// * commons-dbcp-2.1.jar
// in your classpath.
//
// To run this example, youll want:
// * commons-pool-2.3.jar
// * commons-dbcp-2.1.jar
// * commons-logging-1.2.jar
// in your classpath.
//
//
// Invoke the class using two arguments:
// * the connect string for your underlying JDBC driver
// * the query youd like to execute
// Youll also want to ensure your underlying JDBC driver
// is registered. You can use the jdbc.drivers
// property to do this.
//
// For example:
// java -Djdbc.driversorg.h2.Driver \
// -classpath commons-pool2-2.3.jar:commons-dbcp2-2.1.jar:commons-logging-1.2.jar:h2-1.3.152.jar:. \
// BasicDataSourceExample \
// jdbc:h2:~/test \
// SELECT 1
//
public class BasicDataSourceExample {public static void main(String[] args) {// First we set up the BasicDataSource.// Normally this would be handled auto-magically by// an external configuration, but in this example well// do it manually.//System.out.println(Setting up data source.);DataSource dataSource setupDataSource(args[0]);System.out.println(Done.);//// Now, we can use JDBC DataSource as we normally would.//Connection conn null;Statement stmt null;ResultSet rset null;try {System.out.println(Creating connection.);conn dataSource.getConnection();System.out.println(Creating statement.);stmt conn.createStatement();System.out.println(Executing statement.);rset stmt.executeQuery(args[1]);System.out.println(Results:);int numcols rset.getMetaData().getColumnCount();while(rset.next()) {for(int i1;inumcols;i) {System.out.print(\t rset.getString(i));}System.out.println();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (rset ! null)rset.close();} catch (Exception e) {}try {if (stmt ! null)stmt.close();} catch (Exception e) {}try {if (conn ! null)conn.close();} catch (Exception e) {}}}public static DataSource setupDataSource(String connectURI) {BasicDataSource ds new BasicDataSource();ds.setDriverClassName(org.h2.Driver);ds.setUrl(connectURI);return ds;}public static void printDataSourceStats(DataSource ds) {BasicDataSource bds (BasicDataSource) ds;System.out.println(NumActive: bds.getNumActive());System.out.println(NumIdle: bds.getNumIdle());}public static void shutdownDataSource(DataSource ds) throws SQLException {BasicDataSource bds (BasicDataSource) ds;bds.close();}
}
PoolingDataSourceExample
这里的 datasource 是池化的。
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;//
// Here are the dbcp-specific classes.
// Note that they are only used in the setupDataSource
// method. In normal use, your classes interact
// only with the standard JDBC API
//
import org.apache.commons.pool2.ObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.dbcp2.ConnectionFactory;
import org.apache.commons.dbcp2.PoolableConnection;
import org.apache.commons.dbcp2.PoolingDataSource;
import org.apache.commons.dbcp2.PoolableConnectionFactory;
import org.apache.commons.dbcp2.DriverManagerConnectionFactory;//
// Heres a simple example of how to use the PoolingDataSource.
////
// Note that this example is very similar to the PoolingDriver
// example. In fact, you could use the same pool in both a
// PoolingDriver and a PoolingDataSource
////
// To compile this example, youll want:
// * commons-pool2-2.3.jar
// * commons-dbcp2-2.1.jar
// in your classpath.
//
// To run this example, youll want:
// * commons-pool2-2.3.jar
// * commons-dbcp2-2.1.jar
// * commons-logging-1.2.jar
// * the classes for your (underlying) JDBC driver
// in your classpath.
//
// Invoke the class using two arguments:
// * the connect string for your underlying JDBC driver
// * the query youd like to execute
// Youll also want to ensure your underlying JDBC driver
// is registered. You can use the jdbc.drivers
// property to do this.
//
// For example:
// java -Djdbc.driversorg.h2.Driver \
// -classpath commons-pool2-2.3.jar:commons-dbcp2-2.1.jar:commons-logging-1.2.jar:h2-1.3.152.jar:. \
// PoolingDataSourceExample \
// jdbc:h2:~/test \
// SELECT 1
//
public class PoolingDataSourceExample {public static void main(String[] args) {//// First we load the underlying JDBC driver.// You need this if you dont use the jdbc.drivers// system property.//System.out.println(Loading underlying JDBC driver.);try {Class.forName(org.h2.Driver);} catch (ClassNotFoundException e) {e.printStackTrace();}System.out.println(Done.);//// Then, we set up the PoolingDataSource.// Normally this would be handled auto-magically by// an external configuration, but in this example well// do it manually.//System.out.println(Setting up data source.);DataSource dataSource setupDataSource(args[0]);System.out.println(Done.);//// Now, we can use JDBC DataSource as we normally would.//Connection conn null;Statement stmt null;ResultSet rset null;try {System.out.println(Creating connection.);conn dataSource.getConnection();System.out.println(Creating statement.);stmt conn.createStatement();System.out.println(Executing statement.);rset stmt.executeQuery(args[1]);System.out.println(Results:);int numcols rset.getMetaData().getColumnCount();while(rset.next()) {for(int i1;inumcols;i) {System.out.print(\t rset.getString(i));}System.out.println();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (rset ! null)rset.close();} catch (Exception e) {}try {if (stmt ! null)stmt.close();} catch (Exception e) {}try {if (conn ! null)conn.close();} catch (Exception e) {}}}// 这里的 datasource 是池化的。public static DataSource setupDataSource(String connectURI) {//// First, well create a ConnectionFactory that the// pool will use to create Connections.// Well use the DriverManagerConnectionFactory,// using the connect string passed in the command line// arguments.//ConnectionFactory connectionFactory new DriverManagerConnectionFactory(connectURI, null);//// Next well create the PoolableConnectionFactory, which wraps// the real Connections created by the ConnectionFactory with// the classes that implement the pooling functionality.//PoolableConnectionFactory poolableConnectionFactory new PoolableConnectionFactory(connectionFactory, null);//// Now well need a ObjectPool that serves as the// actual pool of connections.//// Well use a GenericObjectPool instance, although// any ObjectPool implementation will suffice.//ObjectPoolPoolableConnection connectionPool new GenericObjectPool(poolableConnectionFactory);// Set the factorys pool property to the owning poolpoolableConnectionFactory.setPool(connectionPool);//// Finally, we create the PoolingDriver itself,// passing in the object pool we created.//PoolingDataSourcePoolableConnection dataSource new PoolingDataSource(connectionPool);return dataSource;}
}
PoolingDriverExample.java
这里用的是 dbcp 的驱动实现池化的
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;import org.apache.commons.dbcp2.ConnectionFactory;
import org.apache.commons.dbcp2.DriverManagerConnectionFactory;
import org.apache.commons.dbcp2.PoolableConnection;
import org.apache.commons.dbcp2.PoolableConnectionFactory;
import org.apache.commons.dbcp2.PoolingDriver;
//
// Here are the dbcp-specific classes.
// Note that they are only used in the setupDriver
// method. In normal use, your classes interact
// only with the standard JDBC API
//
import org.apache.commons.pool2.ObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPool;//
// Heres a simple example of how to use the PoolingDriver.
//// To compile this example, youll want:
// * commons-pool-2.3.jar
// * commons-dbcp-2.1.jar
// in your classpath.
//
// To run this example, youll want:
// * commons-pool-2.3.jar
// * commons-dbcp-2.1.jar
// * commons-logging-1.2.jar
// in your classpath.
//
// Invoke the class using two arguments:
// * the connect string for your underlying JDBC driver
// * the query youd like to execute
// Youll also want to ensure your underlying JDBC driver
// is registered. You can use the jdbc.drivers
// property to do this.
//
// For example:
// java -Djdbc.driversorg.h2.Driver \
// -classpath commons-pool2-2.3.jar:commons-dbcp2-2.1.jar:commons-logging-1.2.jar:h2-1.3.152.jar:. \
// PoolingDriverExample \
// jdbc:h2:~/test \
// SELECT 1
//
public class PoolingDriverExample {public static void main(String[] args) {//// First we load the underlying JDBC driver.// You need this if you dont use the jdbc.drivers// system property.//System.out.println(Loading underlying JDBC driver.);try {Class.forName(org.h2.Driver);} catch (ClassNotFoundException e) {e.printStackTrace();}System.out.println(Done.);//// Then we set up and register the PoolingDriver.// Normally this would be handled auto-magically by// an external configuration, but in this example well// do it manually.//System.out.println(Setting up driver.);try {setupDriver(args[0]);} catch (Exception e) {e.printStackTrace();}System.out.println(Done.);//// Now, we can use JDBC as we normally would.// Using the connect string// jdbc:apache:commons:dbcp:example// The general form being:// jdbc:apache:commons:dbcp:name-of-pool//Connection conn null;Statement stmt null;ResultSet rset null;try {System.out.println(Creating connection.);conn DriverManager.getConnection(jdbc:apache:commons:dbcp:example);System.out.println(Creating statement.);stmt conn.createStatement();System.out.println(Executing statement.);rset stmt.executeQuery(args[1]);System.out.println(Results:);int numcols rset.getMetaData().getColumnCount();while(rset.next()) {for(int i1;inumcols;i) {System.out.print(\t rset.getString(i));}System.out.println();}} catch (SQLException e) {e.printStackTrace();} finally {try {if (rset ! null)rset.close();} catch (Exception e) {}try {if (stmt ! null)stmt.close();} catch (Exception e) {}try {if (conn ! null)conn.close();} catch (Exception e) {}}// Display some pool statisticstry {printDriverStats();} catch (Exception e) {e.printStackTrace();}// closes the pooltry {shutdownDriver();} catch (Exception e) {e.printStackTrace();}}public static void setupDriver(String connectURI) throws Exception {//// First, well create a ConnectionFactory that the// pool will use to create Connections.// Well use the DriverManagerConnectionFactory,// using the connect string passed in the command line// arguments.//ConnectionFactory connectionFactory new DriverManagerConnectionFactory(connectURI, null);//// Next, well create the PoolableConnectionFactory, which wraps// the real Connections created by the ConnectionFactory with// the classes that implement the pooling functionality.//PoolableConnectionFactory poolableConnectionFactory new PoolableConnectionFactory(connectionFactory, null);//// Now well need a ObjectPool that serves as the// actual pool of connections.//// Well use a GenericObjectPool instance, although// any ObjectPool implementation will suffice.//ObjectPoolPoolableConnection connectionPool new GenericObjectPool(poolableConnectionFactory);// Set the factorys pool property to the owning poolpoolableConnectionFactory.setPool(connectionPool);//// Finally, we create the PoolingDriver itself...//Class.forName(org.apache.commons.dbcp2.PoolingDriver);PoolingDriver driver (PoolingDriver) DriverManager.getDriver(jdbc:apache:commons:dbcp:);//// ...and register our pool with it.//driver.registerPool(example, connectionPool);//// Now we can just use the connect string jdbc:apache:commons:dbcp:example// to access our pool of Connections.//}public static void printDriverStats() throws Exception {PoolingDriver driver (PoolingDriver) DriverManager.getDriver(jdbc:apache:commons:dbcp:);ObjectPool? extends Connection connectionPool driver.getConnectionPool(example);System.out.println(NumActive: connectionPool.getNumActive());System.out.println(NumIdle: connectionPool.getNumIdle());}public static void shutdownDriver() throws Exception {PoolingDriver driver (PoolingDriver) DriverManager.getDriver(jdbc:apache:commons:dbcp:);driver.closePool(example);}
}
