List of usage examples for org.apache.commons.pool2.impl GenericObjectPool GenericObjectPool
public GenericObjectPool(PooledObjectFactory<T> factory)
GenericObjectPool using defaults from GenericObjectPoolConfig . From source file:com.github.brandtg.switchboard.MysqlReplicator.java
@Override public void start() throws Exception { // DBCP2 pool ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(jdbcString, user, password); ObjectName poolName = new ObjectName(JdbcBasedLogIndex.class.getCanonicalName(), URLEncoder.encode(jdbcString, ENCODING), "replicatorConnectionPool"); PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, poolName);/*from w w w . j a v a2 s . c om*/ ObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<PoolableConnection>( poolableConnectionFactory); poolableConnectionFactory.setPool(connectionPool); this.dataSource = new PoolingDataSource<PoolableConnection>(connectionPool); LOG.info("Opened connection pool to {} as {}", jdbcString, user); // Replication applier applier = new MysqlReplicationApplier(inputStream, dataSource); super.start(); }
From source file:kr.co.bitnine.octopus.frame.ConnectionManager.java
private ObjectPool<PoolableConnection> createPool(String connectionString) { // A ConnectionFactory that the pool will use to create Connections. ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectionString, null); // PoolableConnectionFactory wraps the real Connections with the // classes that implement the pooling functionality. PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, null);/*from ww w. jav a2 s .c o m*/ poolableConnectionFactory.setValidationQuery("SELECT 1"); // Actual pool of connections. GenericObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<>(poolableConnectionFactory); int connMax = getConfig().getInt(OctopusConfiguration.MASTER_CONNECTION_POOL_MAX, 8); connectionPool.setMaxTotal(connMax); connectionPool.setTestOnBorrow(true); // Set the factory's pool property to the owning pool. poolableConnectionFactory.setPool(connectionPool); return connectionPool; }
From source file:info.pancancer.arch3.persistence.PostgreSQL.java
public PostgreSQL(HierarchicalINIConfiguration settings) { if (dataSource == null) { try {//from www . j a va2s . c om String nullConfigs = ""; String host = settings.getString(Constants.POSTGRES_HOST); if (host == null) { nullConfigs += "postgresHost "; } String user = settings.getString(Constants.POSTGRES_USERNAME); if (user == null) { nullConfigs += "postgresUser "; } String pass = settings.getString(Constants.POSTGRES_PASSWORD); if (pass == null) { nullConfigs += "postgresPass "; } String db = settings.getString(Constants.POSTGRES_DBNAME); if (db == null) { nullConfigs += "postgresDBName "; } String maxConnections = settings.getString(Constants.POSTGRES_MAX_CONNECTIONS, "5"); if (nullConfigs.trim().length() > 0) { throw new NullPointerException("The following configuration values are null: " + nullConfigs + ". Please check your configuration file."); } Class.forName("org.postgresql.Driver"); String url = "jdbc:postgresql://" + host + "/" + db; LOG.debug("PostgreSQL URL is: " + url); Properties props = new Properties(); props.setProperty("user", user); props.setProperty("password", pass); // props.setProperty("ssl","true"); props.setProperty("initialSize", "5"); props.setProperty("maxActive", maxConnections); ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(url, props); PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory( connectionFactory, null); poolableConnectionFactory.setValidationQuery("select count(*) from job;"); ObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<>(poolableConnectionFactory); poolableConnectionFactory.setPool(connectionPool); dataSource = new PoolingDataSource<>(connectionPool); } catch (ClassNotFoundException e) { throw new RuntimeException(e); } } }
From source file:dgw.mt940.db.util.PoolingDataSourceExample.java
public static DataSource setupDataSource(String connectURI) { ///*from ww w . j ava 2 s . c om*/ // First, we'll create a ConnectionFactory that the // pool will use to create Connections. // We'll use the DriverManagerConnectionFactory, // using the connect string passed in the command line // arguments. // ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI, null); // // Next we'll 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 we'll need a ObjectPool that serves as the // actual pool of connections. // // We'll use a GenericObjectPool instance, although // any ObjectPool implementation will suffice. // ObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<PoolableConnection>( poolableConnectionFactory); // Set the factory's pool property to the owning pool poolableConnectionFactory.setPool(connectionPool); // // Finally, we create the PoolingDriver itself, // passing in the object pool we created. // PoolingDataSource<PoolableConnection> dataSource = new PoolingDataSource<>(connectionPool); return dataSource; }
From source file:PoolingDataSourceExample.java
public static DataSource setupDataSource(String connectURI) { ///* w ww . ja va2 s . com*/ // First, we'll create a ConnectionFactory that the // pool will use to create Connections. // We'll use the DriverManagerConnectionFactory, // using the connect string passed in the command line // arguments. // ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI, null); // // Next we'll 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 we'll need a ObjectPool that serves as the // actual pool of connections. // // We'll use a GenericObjectPool instance, although // any ObjectPool implementation will suffice. // ObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<>(poolableConnectionFactory); // Set the factory's pool property to the owning pool poolableConnectionFactory.setPool(connectionPool); // // Finally, we create the PoolingDriver itself, // passing in the object pool we created. // PoolingDataSource<PoolableConnection> dataSource = new PoolingDataSource<>(connectionPool); return dataSource; }
From source file:ddf.ldap.ldaplogin.LdapModuleTest.java
@Before public void startup() throws LdapException { server = TestServer.getInstance();// w w w. j ava 2 s .co m LdapLoginConfig ldapLoginConfig = new LdapLoginConfig(null); ConnectionFactory ldapConnectionFactory = ldapLoginConfig .createLdapConnectionFactory(TestServer.getUrl("ldap"), false); module = TestModule.getInstance(TestServer.getClientOptions(), new GenericObjectPool<>(new LdapConnectionPooledObjectFactory(ldapConnectionFactory))); }
From source file:eu.peppol.persistence.jdbc.OxalisDataSourceFactoryDbcpImpl.java
/** * Creates a DataSource with connection pooling as provided by Apache DBCP * * @return a DataSource//from www . ja v a 2s . c om */ DataSource configureAndCreateDataSource(RepositoryConfiguration configuration) { log.debug("Configuring DataSource wrapped in a Database Connection Pool, using custom loader"); String jdbcDriverClassPath = configuration.getJdbcDriverClassPath(); log.debug("Loading JDBC Driver with custom class path: " + jdbcDriverClassPath); // Creates a new class loader, which will be used for loading our JDBC driver URLClassLoader urlClassLoader = getOxalisClassLoaderForJdbc(jdbcDriverClassPath); String className = configuration.getJdbcDriverClassName(); String connectURI = configuration.getJdbcConnectionUri().toString(); String userName = configuration.getJdbcUsername(); String password = configuration.getJdbcPassword(); log.debug("className=" + className); log.debug("connectURI=" + connectURI); log.debug("userName=" + userName); log.debug("password=" + password); // Loads the JDBC Driver in a separate class loader Driver driver = getJdbcDriver(jdbcDriverClassPath, urlClassLoader, className); Properties properties = new Properties(); properties.put("user", userName); properties.put("password", password); // DBCP factory which will produce JDBC Driver instances ConnectionFactory driverConnectionFactory = new DriverConnectionFactory(driver, connectURI, properties); // DBCP Factory holding the pooled connection, which are created by the driver connection factory and held in the supplied pool ObjectName dataSourceJmxName = null; try { dataSourceJmxName = new ObjectName("no.difi.oxalis", "connectionPool", "OxalisDB"); } catch (MalformedObjectNameException e) { throw new IllegalStateException(e.getMessage(), e); } PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(driverConnectionFactory, dataSourceJmxName); String validationQuery = configuration.getValidationQuery(); if (validationQuery != null) { poolableConnectionFactory.setValidationQuery(validationQuery); } // DBCP object pool holding our driver connections GenericObjectPool<PoolableConnection> genericObjectPool = new GenericObjectPool<PoolableConnection>( poolableConnectionFactory); poolableConnectionFactory.setPool(genericObjectPool); genericObjectPool.setMaxTotal(100); genericObjectPool.setMaxIdle(30); genericObjectPool.setMaxWaitMillis(10000); genericObjectPool.setTestOnBorrow(true); // Test the connection returned from the pool genericObjectPool.setTestWhileIdle(true); // Test idle instances visited by the pool maintenance thread and destroy any that fail validation genericObjectPool.setTimeBetweenEvictionRunsMillis(60 * 60 * 1000); // Test every hour // Creates the actual DataSource instance PoolingDataSource poolingDataSource = new PoolingDataSource(genericObjectPool); return poolingDataSource; }
From source file:JDBCPool.dbcp.demo.offical.PoolingDriverExample.java
/** * ?connectURI?PoolingDriver// w w w .j a va 2s. c o m * @param connectURI * @throws Exception */ public static void setupDriver(String connectURI) throws Exception { // First, we'll create a ConnectionFactory that the pool will use to create Connections. // We'll use the DriverManagerConnectionFactory, using the connect string passed in the command line arguments. ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI, null); // Next, we'll 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 we'll need a ObjectPool that serves as the actual pool of connections. // We'll use a GenericObjectPool instance, although any ObjectPool implementation will suffice. ObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<>(poolableConnectionFactory); // Set the factory's pool property to the owning pool poolableConnectionFactory.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. // }
From source file:PoolingDriverExample.java
public static void setupDriver(String connectURI) throws Exception { ///*from ww w.j ava2 s . c o m*/ // First, we'll create a ConnectionFactory that the // pool will use to create Connections. // We'll use the DriverManagerConnectionFactory, // using the connect string passed in the command line // arguments. // ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI, null); // // Next, we'll 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 we'll need a ObjectPool that serves as the // actual pool of connections. // // We'll use a GenericObjectPool instance, although // any ObjectPool implementation will suffice. // ObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<>(poolableConnectionFactory); // Set the factory's pool property to the owning pool poolableConnectionFactory.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. // }
From source file:PoolingDriverExample.java
public static void setupDriver(String connectURI) throws Exception { ////from w ww.j a v a 2 s. c o m // First, we'll create a ConnectionFactory that the // pool will use to create Connections. // We'll use the DriverManagerConnectionFactory, // using the connect string passed in the command line // arguments. // ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI, null); // // Next, we'll 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 we'll need a ObjectPool that serves as the // actual pool of connections. // // We'll use a GenericObjectPool instance, although // any ObjectPool implementation will suffice. // ObjectPool<PoolableConnection> connectionPool = new GenericObjectPool<>(poolableConnectionFactory); // // 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. // }