List of usage examples for org.apache.commons.dbcp PoolableConnectionFactory PoolableConnectionFactory
public PoolableConnectionFactory(ConnectionFactory connFactory, ObjectPool pool, KeyedObjectPoolFactory stmtPoolFactory, String validationQuery, boolean defaultReadOnly, boolean defaultAutoCommit)
From source file:org.openpythia.dbconnection.ConnectionPoolUtils.java
/** * Configures an Apache DBCP pool called POOL_NAME. For the given connectionUrl * and connectionProperties.// w w w . j a v a 2 s . c o m * * @param connectionUrl the connection url * @param connectionProperties the connectionProperties */ public static void configurePool(String connectionUrl, Properties connectionProperties) throws SQLException { try { ConnectionFactory connectionFactory = new DriverConnectionFactory(JDBCHandler.getOracleJDBCDriver(), connectionUrl, connectionProperties); userName = connectionProperties.getProperty("user"); GenericObjectPool connectionPool = new GenericObjectPool(); connectionPool.setFactory( new PoolableConnectionFactory(connectionFactory, connectionPool, null, null, false, true)); Class.forName(POOLING_DRIVER); PoolingDriver driver = (PoolingDriver) DriverManager.getDriver(POOL_DRIVER_URL); driver.registerPool(POOL_NAME, connectionPool); Connection connection = DriverManager.getConnection(POOL_DRIVER_URL + POOL_NAME); connection.close(); hasBeenSuccessfullyConfigured = true; } catch (ClassNotFoundException e) { throw new RuntimeException(e); } }
From source file:org.pentaho.agilebi.platform.InstaviewDatasourceService.java
public DataSource getDataSource(String dsName) throws DBDatasourceServiceException { DatabaseMeta databaseMeta = databaseMetaMap.get(dsName); if (knownPools.contains(dsName)) { try {//from ww w .ja v a2 s. c o m DatabaseMetaDataSource dataSource = new DatabaseMetaDataSource(dsName); return dataSource; } catch (Exception e) { throw new DBDatasourceServiceException(e); } } // nothing in the pool so create a new pool Domain domain = null; try { XmiParser parser = new XmiParser(); FileInputStream fis = new FileInputStream(new File(dsName)); domain = parser.parseXmi(fis); } catch (Exception e) { throw new DBDatasourceServiceException(e); } if (domain.getPhysicalModels().size() == 0 || !(domain.getPhysicalModels().get(0) instanceof SqlPhysicalModel)) { throw new DBDatasourceServiceException("No SQL Physical Model Available"); } SqlPhysicalModel model = (SqlPhysicalModel) domain.getPhysicalModels().get(0); databaseMeta = ThinModelConverter.convertToLegacy(model.getId(), model.getDatasource()); ConnectionFactory cf = new DatabaseMetaConnectionFactory(databaseMeta); GenericObjectPool.Config config = new GenericObjectPool.Config(); config.testOnBorrow = true; gPool.setConfig(config); PoolableConnectionFactory pcf = new PoolableConnectionFactory(cf, gPool, kopf, "select 1", false, true); try { // for(int i = 0; i < 5; i++) { // gPool.addObject(); // } // PoolingDataSource pds = new PoolingDataSource(gPool); PoolingDriver pd = new PoolingDriver(); pd.registerPool(dsName, gPool); for (int i = 0; i < 5; i++) { gPool.addObject(); } } catch (Exception e) { throw new DBDatasourceServiceException(e); } Database database = new Database(databaseMeta); try { database.connect(); } catch (Exception e) { throw new DBDatasourceServiceException(e); } Connection connection = database.getConnection(); knownPools.add(dsName); databaseMetaMap.put(dsName, databaseMeta); return new DatabaseMetaDataSource(dsName); }
From source file:org.pentaho.di.core.database.ConnectionPoolUtil.java
private static void createPool(LogChannelInterface log, DatabaseMeta databaseMeta, String partitionId, int initialSize, int maximumSize) throws KettleDatabaseException { log.logBasic(BaseMessages.getString(PKG, "Database.CreatingConnectionPool", databaseMeta.getName())); GenericObjectPool gpool = new GenericObjectPool(); gpool.setMaxIdle(-1);//w w w. j av a 2 s. c o m gpool.setWhenExhaustedAction(GenericObjectPool.WHEN_EXHAUSTED_GROW); gpool.setMaxActive(maximumSize); String clazz = databaseMeta.getDriverClass(); try { Class.forName(clazz).newInstance(); } catch (Exception e) { throw new KettleDatabaseException(BaseMessages.getString(PKG, "Database.UnableToLoadConnectionPoolDriver.Exception", databaseMeta.getName(), clazz), e); } String url; String userName; String password; try { url = databaseMeta.environmentSubstitute(databaseMeta.getURL(partitionId)); userName = databaseMeta.environmentSubstitute(databaseMeta.getUsername()); password = databaseMeta.environmentSubstitute(databaseMeta.getPassword()); } catch (RuntimeException e) { url = databaseMeta.getURL(partitionId); userName = databaseMeta.getUsername(); password = databaseMeta.getPassword(); } password = Encr.decryptPasswordOptionallyEncrypted(password); // Get the list of pool properties Properties originalProperties = databaseMeta.getConnectionPoolingProperties(); // Add user/pass originalProperties.setProperty("user", Const.NVL(userName, "")); originalProperties.setProperty("password", Const.NVL(password, "")); // Now, replace the environment variables in there... Properties properties = new Properties(); Iterator<Object> iterator = originalProperties.keySet().iterator(); while (iterator.hasNext()) { String key = (String) iterator.next(); String value = originalProperties.getProperty(key); properties.put(key, databaseMeta.environmentSubstitute(value)); } // Create factory using these properties. // ConnectionFactory cf = new DriverManagerConnectionFactory(url, properties); new PoolableConnectionFactory(cf, gpool, null, null, false, false); for (int i = 0; i < initialSize; i++) { try { gpool.addObject(); } catch (Exception e) { throw new KettleDatabaseException( BaseMessages.getString(PKG, "Database.UnableToPreLoadConnectionToConnectionPool.Exception"), e); } } pd.registerPool(databaseMeta.getName(), gpool); log.logBasic(BaseMessages.getString(PKG, "Database.CreatedConnectionPool", databaseMeta.getName())); }
From source file:org.pentaho.platform.engine.services.connection.datasource.dbcp.PooledDatasourceHelper.java
public static PoolingDataSource setupPooledDataSource(IDatabaseConnection databaseConnection) throws DBDatasourceServiceException { PoolingDataSource poolingDataSource = null; String driverClass = null;//from w w w . j a v a 2 s. c om String url = null; try { if (databaseConnection.getAccessType().equals(DatabaseAccessType.JNDI)) { throw new DBDatasourceServiceException(Messages.getInstance().getErrorString( "PooledDatasourceHelper.ERROR_0008_UNABLE_TO_POOL_DATASOURCE_IT_IS_JNDI", databaseConnection.getName())); } ICacheManager cacheManager = PentahoSystem.getCacheManager(null); IDatabaseDialectService databaseDialectService = PentahoSystem.get(IDatabaseDialectService.class); if (databaseDialectService == null) { throw new DBDatasourceServiceException(Messages.getInstance().getErrorString( "PooledDatasourceHelper.ERROR_0005_UNABLE_TO_POOL_DATASOURCE_NO_DIALECT_SERVICE", databaseConnection.getName())); } IDatabaseDialect dialect = databaseDialectService.getDialect(databaseConnection); if (dialect == null || dialect.getDatabaseType() == null) { throw new DBDatasourceServiceException(Messages.getInstance().getErrorString( "PooledDatasourceHelper.ERROR_0004_UNABLE_TO_POOL_DATASOURCE_NO_DIALECT", databaseConnection.getName())); } if (databaseConnection.getDatabaseType().getShortName().equals("GENERIC")) { //$NON-NLS-1$ driverClass = databaseConnection.getAttributes() .get(GenericDatabaseDialect.ATTRIBUTE_CUSTOM_DRIVER_CLASS); if (StringUtils.isEmpty(driverClass)) { throw new DBDatasourceServiceException(Messages.getInstance().getErrorString( "PooledDatasourceHelper.ERROR_0006_UNABLE_TO_POOL_DATASOURCE_NO_CLASSNAME", databaseConnection.getName())); } } else { driverClass = dialect.getNativeDriver(); if (StringUtils.isEmpty(driverClass)) { throw new DBDatasourceServiceException(Messages.getInstance().getErrorString( "PooledDatasourceHelper.ERROR_0007_UNABLE_TO_POOL_DATASOURCE_NO_DRIVER", databaseConnection.getName())); } } try { url = dialect.getURLWithExtraOptions(databaseConnection); } catch (DatabaseDialectException e) { url = null; } // Read default connection pooling parameter String maxdleConn = PentahoSystem.getSystemSetting("dbcp-defaults/max-idle-conn", null); //$NON-NLS-1$ String minIdleConn = PentahoSystem.getSystemSetting("dbcp-defaults/min-idle-conn", null); //$NON-NLS-1$ String maxActConn = PentahoSystem.getSystemSetting("dbcp-defaults/max-act-conn", null); //$NON-NLS-1$ String validQuery = null; String whenExhaustedAction = PentahoSystem.getSystemSetting("dbcp-defaults/when-exhausted-action", //$NON-NLS-1$ null); String wait = PentahoSystem.getSystemSetting("dbcp-defaults/wait", null); //$NON-NLS-1$ String testWhileIdleValue = PentahoSystem.getSystemSetting("dbcp-defaults/test-while-idle", null); //$NON-NLS-1$ String testOnBorrowValue = PentahoSystem.getSystemSetting("dbcp-defaults/test-on-borrow", null); //$NON-NLS-1$ String testOnReturnValue = PentahoSystem.getSystemSetting("dbcp-defaults/test-on-return", null); //$NON-NLS-1$ // property initialization boolean testWhileIdle = !StringUtil.isEmpty(testWhileIdleValue) ? Boolean.parseBoolean(testWhileIdleValue) : false; boolean testOnBorrow = !StringUtil.isEmpty(testOnBorrowValue) ? Boolean.parseBoolean(testOnBorrowValue) : false; boolean testOnReturn = !StringUtil.isEmpty(testOnReturnValue) ? Boolean.parseBoolean(testOnReturnValue) : false; int maxActiveConnection = !StringUtil.isEmpty(maxActConn) ? Integer.parseInt(maxActConn) : -1; long waitTime = !StringUtil.isEmpty(wait) ? Integer.parseInt(wait) : -1; byte whenExhaustedActionType = !StringUtil.isEmpty(whenExhaustedAction) ? Byte.parseByte(whenExhaustedAction) : GenericObjectPool.WHEN_EXHAUSTED_BLOCK; int minIdleConnection = !StringUtil.isEmpty(minIdleConn) ? Integer.parseInt(minIdleConn) : -1; int maxIdleConnection = !StringUtil.isEmpty(maxdleConn) ? Integer.parseInt(maxdleConn) : -1; // setting properties according to user specifications Map<String, String> attributes = databaseConnection.getConnectionPoolingProperties(); if (attributes.containsKey(IDBDatasourceService.MAX_ACTIVE_KEY) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MAX_ACTIVE_KEY))) { maxActiveConnection = Integer.parseInt(attributes.get(IDBDatasourceService.MAX_ACTIVE_KEY)); } if (attributes.containsKey(IDBDatasourceService.MAX_WAIT_KEY) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MAX_WAIT_KEY))) { waitTime = Integer.parseInt(attributes.get(IDBDatasourceService.MAX_WAIT_KEY)); } if (attributes.containsKey(IDBDatasourceService.MIN_IDLE_KEY) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MIN_IDLE_KEY))) { minIdleConnection = Integer.parseInt(attributes.get(IDBDatasourceService.MIN_IDLE_KEY)); } if (attributes.containsKey(IDBDatasourceService.MAX_IDLE_KEY) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.MAX_IDLE_KEY))) { maxIdleConnection = Integer.parseInt(attributes.get(IDBDatasourceService.MAX_IDLE_KEY)); } if (attributes.containsKey(IDBDatasourceService.QUERY_KEY)) { validQuery = attributes.get(IDBDatasourceService.QUERY_KEY); } if (attributes.containsKey(IDBDatasourceService.TEST_ON_BORROW)) { testOnBorrow = Boolean.parseBoolean(attributes.get(IDBDatasourceService.TEST_ON_BORROW)); } if (attributes.containsKey(IDBDatasourceService.TEST_ON_RETURN)) { testOnReturn = Boolean.parseBoolean(attributes.get(IDBDatasourceService.TEST_ON_RETURN)); } if (attributes.containsKey(IDBDatasourceService.TEST_WHILE_IDLE)) { testWhileIdle = Boolean.parseBoolean(attributes.get(IDBDatasourceService.TEST_WHILE_IDLE)); } poolingDataSource = new PoolingDataSource(); Class.forName(driverClass); // As the name says, this is a generic pool; it returns basic Object-class objects. GenericObjectPool pool = new GenericObjectPool(null); // if removedAbandoned = true, then an AbandonedObjectPool object will take GenericObjectPool's place if (attributes.containsKey(IDBDatasourceService.REMOVE_ABANDONED) && true == Boolean.parseBoolean(attributes.get(IDBDatasourceService.REMOVE_ABANDONED))) { AbandonedConfig config = new AbandonedConfig(); config.setRemoveAbandoned( Boolean.parseBoolean(attributes.get(IDBDatasourceService.REMOVE_ABANDONED))); if (attributes.containsKey(IDBDatasourceService.LOG_ABANDONED)) { config.setLogAbandoned( Boolean.parseBoolean(attributes.get(IDBDatasourceService.LOG_ABANDONED))); } if (attributes.containsKey(IDBDatasourceService.REMOVE_ABANDONED_TIMEOUT) && NumberUtils.isNumber(attributes.get(IDBDatasourceService.REMOVE_ABANDONED_TIMEOUT))) { config.setRemoveAbandonedTimeout( Integer.parseInt(attributes.get(IDBDatasourceService.REMOVE_ABANDONED_TIMEOUT))); } pool = new AbandonedObjectPool(null, config); } pool.setWhenExhaustedAction(whenExhaustedActionType); // Tuning the connection pool pool.setMaxActive(maxActiveConnection); pool.setMaxIdle(maxIdleConnection); pool.setMaxWait(waitTime); pool.setMinIdle(minIdleConnection); pool.setTestWhileIdle(testWhileIdle); pool.setTestOnReturn(testOnReturn); pool.setTestOnBorrow(testOnBorrow); pool.setTestWhileIdle(testWhileIdle); if (attributes.containsKey(IDBDatasourceService.TIME_BETWEEN_EVICTION_RUNS_MILLIS) && NumberUtils .isNumber(attributes.get(IDBDatasourceService.TIME_BETWEEN_EVICTION_RUNS_MILLIS))) { pool.setTimeBetweenEvictionRunsMillis( Long.parseLong(attributes.get(IDBDatasourceService.TIME_BETWEEN_EVICTION_RUNS_MILLIS))); } /* * ConnectionFactory creates connections on behalf of the pool. Here, we use the DriverManagerConnectionFactory * because that essentially uses DriverManager as the source of connections. */ ConnectionFactory factory = null; if (url.startsWith("jdbc:mysql:")) { Properties props = new Properties(); props.put("user", databaseConnection.getUsername()); props.put("password", databaseConnection.getPassword()); props.put("socketTimeout", "0"); props.put("connectTimeout", "5000"); factory = new DriverManagerConnectionFactory(url, props); } else { factory = new DriverManagerConnectionFactory(url, databaseConnection.getUsername(), databaseConnection.getPassword()); } boolean defaultReadOnly = attributes.containsKey(IDBDatasourceService.DEFAULT_READ_ONLY) ? Boolean.parseBoolean(attributes.get(IDBDatasourceService.TEST_WHILE_IDLE)) : false; // default to false boolean defaultAutoCommit = attributes.containsKey(IDBDatasourceService.DEFAULT_AUTO_COMMIT) ? Boolean.parseBoolean(attributes.get(IDBDatasourceService.DEFAULT_AUTO_COMMIT)) : true; // default to true KeyedObjectPoolFactory kopf = null; if (attributes.containsKey(IDBDatasourceService.POOL_PREPARED_STATEMENTS) && true == Boolean .parseBoolean(attributes.get(IDBDatasourceService.POOL_PREPARED_STATEMENTS))) { int maxOpenPreparedStatements = -1; // unlimited if (attributes.containsKey(IDBDatasourceService.MAX_OPEN_PREPARED_STATEMENTS) && NumberUtils .isNumber(attributes.get(IDBDatasourceService.MAX_OPEN_PREPARED_STATEMENTS))) { maxOpenPreparedStatements = Integer .parseInt(attributes.get(IDBDatasourceService.MAX_OPEN_PREPARED_STATEMENTS)); } kopf = new GenericKeyedObjectPoolFactory(null, pool.getMaxActive(), pool.getWhenExhaustedAction(), pool.getMaxWait(), pool.getMaxIdle(), maxOpenPreparedStatements); } /* * Puts pool-specific wrappers on factory connections. For clarification: "[PoolableConnection]Factory," not * "Poolable[ConnectionFactory]." */ PoolableConnectionFactory pcf = new PoolableConnectionFactory(factory, // ConnectionFactory pool, // ObjectPool kopf, // KeyedObjectPoolFactory validQuery, // String (validation query) defaultReadOnly, // boolean (default to read-only?) defaultAutoCommit // boolean (default to auto-commit statements?) ); if (attributes.containsKey(IDBDatasourceService.DEFAULT_TRANSACTION_ISOLATION) && !IDBDatasourceService.TRANSACTION_ISOLATION_NONE_VALUE .equalsIgnoreCase(attributes.get(IDBDatasourceService.DEFAULT_TRANSACTION_ISOLATION))) { Isolation isolationLevel = Isolation .valueOf(attributes.get(IDBDatasourceService.DEFAULT_TRANSACTION_ISOLATION)); if (isolationLevel != null) { pcf.setDefaultTransactionIsolation(isolationLevel.value()); } } if (attributes.containsKey(IDBDatasourceService.DEFAULT_CATALOG)) { pcf.setDefaultCatalog(attributes.get(IDBDatasourceService.DEFAULT_CATALOG)); } /* * initialize the pool to X connections */ Logger.debug(PooledDatasourceHelper.class, "Pool defaults to " + maxActiveConnection + " max active/" + maxIdleConnection + "max idle" //$NON-NLS-3$ + "with " + waitTime + "wait time"//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-4$ //$NON-NLS-5$ + " idle connections."); //$NON-NLS-1$ for (int i = 0; i < maxIdleConnection; ++i) { pool.addObject(); } Logger.debug(PooledDatasourceHelper.class, "Pool now has " + pool.getNumActive() + " active/" + pool.getNumIdle() + " idle connections."); //$NON-NLS-3$ //$NON-NLS-2$ //$NON-NLS-3$ /* * All of this is wrapped in a DataSource, which client code should already know how to handle (since it's the * same class of object they'd fetch via the container's JNDI tree */ poolingDataSource.setPool(pool); if (attributes.containsKey(IDBDatasourceService.ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED)) { poolingDataSource.setAccessToUnderlyingConnectionAllowed(Boolean.parseBoolean( attributes.get(IDBDatasourceService.ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED))); } // store the pool, so we can get to it later cacheManager.putInRegionCache(IDBDatasourceService.JDBC_POOL, databaseConnection.getName(), pool); return (poolingDataSource); } catch (Exception e) { throw new DBDatasourceServiceException(e); } }
From source file:org.pentaho.reporting.engine.classic.extensions.modules.connections.PooledDatasourceHelper.java
public static PoolingDataSource setupPooledDataSource(final IDatabaseConnection databaseConnection) throws DatasourceServiceException { try {/* w w w. jav a 2 s . c om*/ final DataSourceCacheManager cacheManager = ClassicEngineBoot.getInstance().getObjectFactory() .get(DataSourceCacheManager.class); final IDatabaseDialectService databaseDialectService = ClassicEngineBoot.getInstance() .getObjectFactory().get(IDatabaseDialectService.class); final IDatabaseDialect dialect = databaseDialectService.getDialect(databaseConnection); final String driverClass; if (GENERIC.equals(databaseConnection.getDatabaseType().getShortName())) { //$NON-NLS-1$ driverClass = databaseConnection.getAttributes() .get(GenericDatabaseDialect.ATTRIBUTE_CUSTOM_DRIVER_CLASS); } else { driverClass = dialect.getNativeDriver(); } String url; try { url = dialect.getURLWithExtraOptions(databaseConnection); } catch (DatabaseDialectException e) { url = null; } // Read default connection pooling parameter final String maxdleConn = getSystemSetting("dbcp-defaults.max-idle-conn"); //$NON-NLS-1$ final String minIdleConn = getSystemSetting("dbcp-defaults.min-idle-conn"); //$NON-NLS-1$ final String maxActConn = getSystemSetting("dbcp-defaults.max-act-conn"); //$NON-NLS-1$ String validQuery = null; final String whenExhaustedAction = getSystemSetting("dbcp-defaults.when-exhausted-action"); //$NON-NLS-1$ final String wait = getSystemSetting("dbcp-defaults.wait"); //$NON-NLS-1$ final String testWhileIdleValue = getSystemSetting("dbcp-defaults.test-while-idle"); //$NON-NLS-1$ final String testOnBorrowValue = getSystemSetting("dbcp-defaults.test-on-borrow"); //$NON-NLS-1$ final String testOnReturnValue = getSystemSetting("dbcp-defaults.test-on-return"); //$NON-NLS-1$ final boolean testWhileIdle = !StringUtils.isEmpty(testWhileIdleValue) && Boolean.parseBoolean(testWhileIdleValue); final boolean testOnBorrow = !StringUtils.isEmpty(testOnBorrowValue) && Boolean.parseBoolean(testOnBorrowValue); final boolean testOnReturn = !StringUtils.isEmpty(testOnReturnValue) && Boolean.parseBoolean(testOnReturnValue); int maxActiveConnection = -1; long waitTime = -1; byte whenExhaustedActionType = -1; final int minIdleConnection = !StringUtils.isEmpty(minIdleConn) ? Integer.parseInt(minIdleConn) : -1; final int maxIdleConnection = !StringUtils.isEmpty(maxdleConn) ? Integer.parseInt(maxdleConn) : -1; final Map<String, String> attributes = databaseConnection.getAttributes(); if (attributes.containsKey(DataBaseConnectionAttributes.MAX_ACTIVE_KEY)) { maxActiveConnection = Integer.parseInt(attributes.get(DataBaseConnectionAttributes.MAX_ACTIVE_KEY)); } else { if (!StringUtils.isEmpty(maxActConn)) { maxActiveConnection = Integer.parseInt(maxActConn); } } if (attributes.containsKey(DataBaseConnectionAttributes.MAX_WAIT_KEY)) { waitTime = Integer.parseInt(attributes.get(DataBaseConnectionAttributes.MAX_WAIT_KEY)); } else { if (!StringUtils.isEmpty(wait)) { waitTime = Long.parseLong(wait); } } if (attributes.containsKey(DataBaseConnectionAttributes.QUERY_KEY)) { validQuery = attributes.get(DataBaseConnectionAttributes.QUERY_KEY); } if (!StringUtils.isEmpty(whenExhaustedAction)) { whenExhaustedActionType = Byte.parseByte(whenExhaustedAction); } else { whenExhaustedActionType = GenericObjectPool.WHEN_EXHAUSTED_BLOCK; } final PoolingDataSource poolingDataSource = new PoolingDataSource(); // As the name says, this is a generic pool; it returns basic Object-class objects. final GenericObjectPool pool = new GenericObjectPool(null); pool.setWhenExhaustedAction(whenExhaustedActionType); // Tuning the connection pool pool.setMaxActive(maxActiveConnection); pool.setMaxIdle(maxIdleConnection); pool.setMaxWait(waitTime); pool.setMinIdle(minIdleConnection); pool.setTestWhileIdle(testWhileIdle); pool.setTestOnReturn(testOnReturn); pool.setTestOnBorrow(testOnBorrow); pool.setTestWhileIdle(testWhileIdle); /* * ConnectionFactory creates connections on behalf of the pool. Here, we use the DriverManagerConnectionFactory * because that essentially uses DriverManager as the source of connections. */ final Properties properties = new Properties(); properties.setProperty("user", databaseConnection.getUsername()); properties.setProperty("password", databaseConnection.getPassword()); final ConnectionFactory factory = new DriverConnectionFactory(getDriver(dialect, driverClass, url), url, properties); /* * Puts pool-specific wrappers on factory connections. For clarification: "[PoolableConnection]Factory," not * "Poolable[ConnectionFactory]." */ // This declaration is used implicitly. // noinspection UnusedDeclaration final PoolableConnectionFactory pcf = new PoolableConnectionFactory(factory, // ConnectionFactory pool, // ObjectPool null, // KeyedObjectPoolFactory validQuery, // String (validation query) false, // boolean (default to read-only?) true // boolean (default to auto-commit statements?) ); /* * initialize the pool to X connections */ logger.debug("Pool defaults to " + maxActiveConnection + " max active/" + maxIdleConnection + "max idle" + "with " + waitTime + "wait time"//$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ + " idle connections."); //$NON-NLS-1$ for (int i = 0; i < maxIdleConnection; ++i) { pool.addObject(); } logger.debug( "Pool now has " + pool.getNumActive() + " active/" + pool.getNumIdle() + " idle connections."); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ /* * All of this is wrapped in a DataSource, which client code should already know how to handle (since it's the * same class of object they'd fetch via the container's JNDI tree */ poolingDataSource.setPool(pool); // store the pool, so we can get to it later cacheManager.getDataSourceCache().put(databaseConnection.getName(), poolingDataSource); return (poolingDataSource); } catch (Exception e) { throw new DatasourceServiceException(e); } }
From source file:org.plasma.sdo.jdbc.connect.RDBConnectionManager.java
/** * /*from ww w .j a v a2 s . co m*/ * @param connectURI * - JDBC Connection URI * @param username * - JDBC Connection username * @param password * - JDBC Connection password * @param minIdle * - Minimum number of idel connection in the connection pool * @param maxActive * - Connection Pool Maximum Capacity (Size) * @throws Exception */ private static DataSource setup(String connectURI, String username, String password, int minIdle, int maxActive, Map<String, String> props) throws Exception { // // Create an ObjectPool that serves as the // actual pool of connections. // // Use a GenericObjectPool instance, although // any ObjectPool implementation will suffice. // GenericObjectPool.Config config = createGenericObjectPoolConfig(props); GenericObjectPool connectionPool = new GenericObjectPool(null, config); connectionPool.setMinIdle(minIdle); connectionPool.setMaxActive(maxActive); RDBConnectionManager._pool = connectionPool; // We keep it for two reasons // #1 We need it for statistics/debugging // #2 PoolingDataSource does not have getPool() // method, for some obscure, weird reason. // // Create a ConnectionFactory that the // pool will use to create Connections. // Use the DriverManagerConnectionFactory, // using the connect string from configuration // ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI, username, password); // // 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, connectionPool, null, null, false, true); String value = getValue(DBCP_VALIDATIONQUERY, props); if (value != null) { try { poolableConnectionFactory.setValidationQuery(value); } catch (Exception e) { throw new JDBCServiceException(e); } } PoolingDataSource dataSource = new PoolingDataSource(connectionPool); return dataSource; }
From source file:org.ralasafe.db.DataSourceProviderDbcpImpl.java
public void setup(Properties prop) { this.prop = prop; GenericObjectPool.Config conPoolCfg = new GenericObjectPool.Config(); conPoolCfg.maxActive = Integer.parseInt(prop.getProperty("connectionPoolMaxSize", "15")); conPoolCfg.maxIdle = Integer.parseInt(prop.getProperty("connectionPoolMaxIdle", "8")); conPoolCfg.maxWait = Integer.parseInt(prop.getProperty("connectionPoolMaxWait", "60000")); conPoolCfg.minIdle = Integer.parseInt(prop.getProperty("connectionPoolMinSize", "2")); ObjectPool connectionPool = new GenericObjectPool(null, conPoolCfg); try {//from w w w . j a v a2 s . c om Class.forName(prop.getProperty("jdbcDriver")); } catch (ClassNotFoundException e) { e.printStackTrace(); throw new RuntimeException(); } ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(prop.getProperty("jdbcUrl"), prop.getProperty("jdbcUser"), prop.getProperty("jdbcPassword")); new PoolableConnectionFactory(connectionFactory, connectionPool, null, null, false, true); PoolingDataSource dataSource = new PoolingDataSource(connectionPool); ds = dataSource; }
From source file:org.restlet.ext.jdbc.JdbcClientHelper.java
/** * Creates a connection pool for a given connection configuration. * // w w w .j a v a2 s . c o m * @param uri * The connection URI. * @param properties * The connection properties. * @return The new connection pool. */ public static ObjectPool createConnectionPool(String uri, Properties properties) { // Create an ObjectPool that will serve as the actual pool of // connections ObjectPool result = new GenericObjectPool(null); // Create a ConnectionFactory that the pool will use to create // Connections ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(uri, properties); // 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, result, null, null, false, false); // To remove warnings poolableConnectionFactory.getPool(); return result; }
From source file:org.rimudb.pool.DBCPConnectionManager.java
public void connect(String user, String password) throws Exception { // Load the jdbc driver Class.forName(poolConfiguration.getJdbcDriver()); // Create an ObjectPool that serves as the actual pool of connections. connectionPool = new GenericObjectPool(null); connectionPool.setMaxActive(99999);/*from w ww . j a v a 2 s . c om*/ connectionPool.setTimeBetweenEvictionRunsMillis(poolConfiguration.getTimeBetweenEvictionRunsSecs() * 1000L); connectionPool.setMaxActive(poolConfiguration.getMaxActive()); connectionPool.setMinEvictableIdleTimeMillis(poolConfiguration.getMinEvictableIdleTimeSecs() * 1000L); connectionPool.setMinIdle(poolConfiguration.getMinIdle()); connectionPool.setMaxIdle(poolConfiguration.getMaxIdle()); connectionPool.setMaxWait(poolConfiguration.getMaxWaitSecs() * 1000L); // Create a Properties object for the connection factory Properties props = new Properties(); // Pass all the properties from the configuration into the connection factory properties if (poolConfiguration.getProperties() != null) { props.putAll(poolConfiguration.getProperties()); } // Set user and password if (user != null && password != null) { props.setProperty("user", user); props.setProperty("pasword", password); } props.setProperty("poolPreparedStatements", "" + poolConfiguration.getStatementCaching()); // Create a ConnectionFactory that the pool will use to create Connections. ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(poolConfiguration.getJdbcURL(), props); KeyedObjectPoolFactory stmtPoolFactory = null; if (poolConfiguration.getStatementCaching()) { stmtPoolFactory = new GenericKeyedObjectPoolFactory(null); } // 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, connectionPool, stmtPoolFactory, null, false, true); // Create the PoolingDriver itself Class.forName("org.apache.commons.dbcp.PoolingDriver"); PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:"); // Register the pool driver.registerPool(dbConfig.getDatabaseID(), connectionPool); }
From source file:org.s23m.cell.repository.RelationalDatabaseRepository.java
private static void initializeConnectionPool() { final Properties props = new Properties(); props.setProperty("user", ConfigValues.getValue("Repository.REPOSITORY_ACCOUNT")); props.setProperty("password", ConfigValues.getValue("Repository.REPOSITORY_PW")); props.setProperty("rewriteBatchedStatements", "true"); final ConnectionFactory cf = new DriverManagerConnectionFactory( ConfigValues.getValue("Repository.REPOSITORY_CONNECTION_STRING"), props); final KeyedObjectPoolFactory keyedObjecPoolFacto = new GenericKeyedObjectPoolFactory(null, MAX_ACTIVE_CONNECTION); new PoolableConnectionFactory(cf, RepositoryHolder.CONNECTION_POOL, keyedObjecPoolFacto, null, false, true); for (int i = 0; i < INITIAL_CONNECTION_POOL_SIZE; i++) { try {/*from w w w . ja va 2 s . co m*/ RepositoryHolder.CONNECTION_POOL.addObject(); } catch (final Exception e) { } } new PoolingDriver().registerPool(REPOSITORY_CONNECTION_POOL_ID, RepositoryHolder.CONNECTION_POOL); RepositoryHolder.setConnectionPoolInitialized(true); }