From 7e25ec08623381e1490d714f4f7f0dae6d7e48b0 Mon Sep 17 00:00:00 2001 From: wenshao Date: Tue, 6 Sep 2011 14:04:08 +0000 Subject: [PATCH] =?UTF-8?q?C3P0=E5=85=BC=E5=AE=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit git-svn-id: http://code.alibabatech.com/svn/druid/trunk@658 b9813039-fb51-4c41-a8b9-e21c2acb5095 --- .../druid/pool/DruidC3P0WrapDataSource.java | 358 ++++++++++++++++++ .../pool/TestIdle3_Concurrent_Starvation.java | 6 +- 2 files changed, 361 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/alibaba/druid/pool/DruidC3P0WrapDataSource.java diff --git a/src/main/java/com/alibaba/druid/pool/DruidC3P0WrapDataSource.java b/src/main/java/com/alibaba/druid/pool/DruidC3P0WrapDataSource.java new file mode 100644 index 0000000000..758040b208 --- /dev/null +++ b/src/main/java/com/alibaba/druid/pool/DruidC3P0WrapDataSource.java @@ -0,0 +1,358 @@ +package com.alibaba.druid.pool; + +import java.io.PrintWriter; +import java.sql.Connection; +import java.sql.SQLException; + +import javax.sql.DataSource; + +public class DruidC3P0WrapDataSource implements DataSource { + + private DruidDataSource dataSource; + + public DruidC3P0WrapDataSource(){ + dataSource = new DruidDataSource(); + } + + @Override + public PrintWriter getLogWriter() throws SQLException { + return dataSource.getLogWriter(); + } + + @Override + public void setLogWriter(PrintWriter out) throws SQLException { + dataSource.setLogWriter(out); + } + + @Override + public void setLoginTimeout(int seconds) throws SQLException { + dataSource.setLoginTimeout(seconds); + } + + @Override + public int getLoginTimeout() throws SQLException { + return dataSource.getLoginTimeout(); + } + + @SuppressWarnings("unchecked") + @Override + public T unwrap(Class iface) throws SQLException { + if (iface == DruidC3P0WrapDataSource.class) { + return (T) this; + } + + return dataSource.unwrap(iface); + } + + @Override + public boolean isWrapperFor(Class iface) throws SQLException { + if (iface == DruidC3P0WrapDataSource.class) { + return true; + } + + return dataSource.isWrapperFor(iface); + } + + @Override + public Connection getConnection() throws SQLException { + return dataSource.getConnection(); + } + + @Override + public Connection getConnection(String username, String password) throws SQLException { + return dataSource.getConnection(username, password); + } + + public String getUser() { + return dataSource.getUsername(); + } + + public void setUser(String user) { + dataSource.setUsername(user); + } + + public String getPassword() { + return dataSource.getPassword(); + } + + public void setPassword(String password) { + dataSource.setPassword(password); + } + + public int getCheckoutTimeout() { + return (int) dataSource.getMaxWait(); + } + + public void setCheckoutTimeout(int checkoutTimeout) { + dataSource.setMaxWait(checkoutTimeout); + } + + public boolean isAutoCommitOnClose() { + return dataSource.isDefaultAutoCommit(); + } + + public void setAutoCommitOnClose(boolean autoCommitOnClose) { + this.dataSource.setDefaultAutoCommit(autoCommitOnClose); + } + + public int getIdleConnectionTestPeriod() { + return (int) dataSource.getTimeBetweenEvictionRunsMillis(); + } + + public void setIdleConnectionTestPeriod(int idleConnectionTestPeriod) { + dataSource.setTimeBetweenEvictionRunsMillis(idleConnectionTestPeriod); + } + + public int getInitialPoolSize() { + return dataSource.getInitialSize(); + } + + public void setInitialPoolSize(int initialPoolSize) { + dataSource.setInitialSize(initialPoolSize); + } + + public int getMaxIdleTime() { + return (int) dataSource.getMinEvictableIdleTimeMillis(); + } + + public void setMaxIdleTime(int maxIdleTime) { + dataSource.setMinEvictableIdleTimeMillis(maxIdleTime); + } + + public int getMaxPoolSize() { + return dataSource.getMaxActive(); + } + + public void setMaxPoolSize(int maxPoolSize) { + dataSource.setMaxActive(maxPoolSize); + } + + public int getMinPoolSize() { + return dataSource.getMinIdle(); + } + + public void setMinPoolSize(int minPoolSize) { + dataSource.setMinIdle(minPoolSize); + } + + public boolean isTestConnectionOnCheckout() { + return dataSource.isTestOnBorrow(); + } + + public void setTestConnectionOnCheckout(boolean testConnectionOnCheckout) { + dataSource.setTestOnBorrow(testConnectionOnCheckout); + } + + public boolean isTestConnectionOnCheckin() { + return dataSource.isTestOnReturn(); + } + + public void setTestConnectionOnCheckin(boolean testConnectionOnCheckin) { + dataSource.setTestOnReturn(testConnectionOnCheckin); + } + + public String getPreferredTestQuery() { + return dataSource.getValidationQuery(); + } + + public void setPreferredTestQuery(String preferredTestQuery) { + dataSource.setValidationQuery(preferredTestQuery); + } + + // /////////////// + + private int maxStatementsPerConnection; + private String overrideDefaultUser; + private String overrideDefaultPassword; + private int propertyCycle; + private boolean breakAfterAcquireFailure; + private boolean usesTraditionalReflectiveProxies; + private String userOverridesAsString; + private int maxAdministrativeTaskTime; + private int maxIdleTimeExcessConnections; + private int maxConnectionAge; + private String connectionCustomizerClassName; + private int unreturnedConnectionTimeout; + private boolean debugUnreturnedConnectionStackTraces; + private String factoryClassLocation; + private int acquireIncrement = 1; + private int acquireRetryDelay; + private int acquireRetryAttempts; + + private String connectionTesterClassName; + private String automaticTestTable; + private int maxStatements; + + public int getMaxStatements() { + return maxStatements; + } + + public void setMaxStatements(int maxStatements) { + this.maxStatements = maxStatements; + } + + public int getMaxStatementsPerConnection() { + return maxStatementsPerConnection; + } + + public void setMaxStatementsPerConnection(int maxStatementsPerConnection) { + this.maxStatementsPerConnection = maxStatementsPerConnection; + } + + public String getConnectionTesterClassName() { + return connectionTesterClassName; + } + + public void setConnectionTesterClassName(String connectionTesterClassName) { + this.connectionTesterClassName = connectionTesterClassName; + } + + public String getAutomaticTestTable() { + return automaticTestTable; + } + + public void setAutomaticTestTable(String automaticTestTable) { + this.automaticTestTable = automaticTestTable; + } + + private boolean forceIgnoreUnresolvedTransactions; + + public boolean isForceIgnoreUnresolvedTransactions() { + return forceIgnoreUnresolvedTransactions; + } + + public void setForceIgnoreUnresolvedTransactions(boolean forceIgnoreUnresolvedTransactions) { + this.forceIgnoreUnresolvedTransactions = forceIgnoreUnresolvedTransactions; + } + + public boolean isUsesTraditionalReflectiveProxies() { + return usesTraditionalReflectiveProxies; + } + + public void setUsesTraditionalReflectiveProxies(boolean usesTraditionalReflectiveProxies) { + this.usesTraditionalReflectiveProxies = usesTraditionalReflectiveProxies; + } + + public String getUserOverridesAsString() { + return userOverridesAsString; + } + + public void setUserOverridesAsString(String userOverridesAsString) { + this.userOverridesAsString = userOverridesAsString; + } + + public int getMaxAdministrativeTaskTime() { + return maxAdministrativeTaskTime; + } + + public void setMaxAdministrativeTaskTime(int maxAdministrativeTaskTime) { + this.maxAdministrativeTaskTime = maxAdministrativeTaskTime; + } + + public int getMaxIdleTimeExcessConnections() { + return maxIdleTimeExcessConnections; + } + + public void setMaxIdleTimeExcessConnections(int maxIdleTimeExcessConnections) { + this.maxIdleTimeExcessConnections = maxIdleTimeExcessConnections; + } + + public int getMaxConnectionAge() { + return maxConnectionAge; + } + + public void setMaxConnectionAge(int maxConnectionAge) { + this.maxConnectionAge = maxConnectionAge; + } + + public String getConnectionCustomizerClassName() { + return connectionCustomizerClassName; + } + + public void setConnectionCustomizerClassName(String connectionCustomizerClassName) { + this.connectionCustomizerClassName = connectionCustomizerClassName; + } + + public int getUnreturnedConnectionTimeout() { + return unreturnedConnectionTimeout; + } + + public void setUnreturnedConnectionTimeout(int unreturnedConnectionTimeout) { + this.unreturnedConnectionTimeout = unreturnedConnectionTimeout; + } + + public boolean isDebugUnreturnedConnectionStackTraces() { + return debugUnreturnedConnectionStackTraces; + } + + public void setDebugUnreturnedConnectionStackTraces(boolean debugUnreturnedConnectionStackTraces) { + this.debugUnreturnedConnectionStackTraces = debugUnreturnedConnectionStackTraces; + } + + public String getFactoryClassLocation() { + return factoryClassLocation; + } + + public void setFactoryClassLocation(String factoryClassLocation) { + this.factoryClassLocation = factoryClassLocation; + } + + public int getAcquireIncrement() { + return acquireIncrement; + } + + public void setAcquireIncrement(int acquireIncrement) { + this.acquireIncrement = acquireIncrement; + } + + public int getAcquireRetryAttempts() { + return acquireRetryAttempts; + } + + public void setAcquireRetryAttempts(int acquireRetryAttempts) { + this.acquireRetryAttempts = acquireRetryAttempts; + } + + public int getAcquireRetryDelay() { + return acquireRetryDelay; + } + + public void setAcquireRetryDelay(int acquireRetryDelay) { + this.acquireRetryDelay = acquireRetryDelay; + } + + public String getOverrideDefaultUser() { + return overrideDefaultUser; + } + + public void setOverrideDefaultUser(String overrideDefaultUser) { + this.overrideDefaultUser = overrideDefaultUser; + } + + public String getOverrideDefaultPassword() { + return overrideDefaultPassword; + } + + public void setOverrideDefaultPassword(String overrideDefaultPassword) { + this.overrideDefaultPassword = overrideDefaultPassword; + } + + public int getPropertyCycle() { + return propertyCycle; + } + + public void setPropertyCycle(int propertyCycle) { + this.propertyCycle = propertyCycle; + } + + public boolean isBreakAfterAcquireFailure() { + return breakAfterAcquireFailure; + } + + public void setBreakAfterAcquireFailure(boolean breakAfterAcquireFailure) { + this.breakAfterAcquireFailure = breakAfterAcquireFailure; + } + + // //////////////// + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/TestIdle3_Concurrent_Starvation.java b/src/test/java/com/alibaba/druid/bvt/pool/TestIdle3_Concurrent_Starvation.java index 939ca9fd7f..d759b1b6ec 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/TestIdle3_Concurrent_Starvation.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/TestIdle3_Concurrent_Starvation.java @@ -26,8 +26,8 @@ public class TestIdle3_Concurrent_Starvation extends TestCase { dataSource.setUrl("jdbc:mock:xxx"); dataSource.setDriver(driver); dataSource.setInitialSize(1); - dataSource.setMaxActive(100); - dataSource.setMaxIdle(100); + dataSource.setMaxActive(14); + dataSource.setMaxIdle(14); dataSource.setMinIdle(1); dataSource.setMinEvictableIdleTimeMillis(300 * 1000); // 300 / 10 dataSource.setTimeBetweenEvictionRunsMillis(180 * 1000); // 180 / 10 @@ -65,7 +65,7 @@ public class TestIdle3_Concurrent_Starvation extends TestCase { } for (int i = 0; i < 1; ++i) { - final int threadCount = 100; + final int threadCount = 5; concurrent(threadCount); }