Java PGPoolingDataSource类代码示例

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
@BeforeClass(alwaysRun = true)
static public void setUpDataSource() throws Exception {
    File propertiesFile = new File("config/application.properties");
    if (!propertiesFile.exists()) {
        throw new IllegalStateException(
                "Missing configuration file, please create config/application.properties based on sample.");
    }
    Properties props = new Properties();
    try (FileInputStream fis = new FileInputStream(propertiesFile)) {
        props.load(fis);
    }

    PGPoolingDataSource dataSource = new PGPoolingDataSource();
    dataSource.setServerName(props.getProperty("db.server"));
    dataSource.setDatabaseName(props.getProperty("db.database"));
    dataSource.setUser(props.getProperty("db.user"));
    dataSource.setPassword(props.getProperty("db.password"));
    dataSource.setPortNumber(Integer.parseInt(props.getProperty("db.port")));
    BaseITest.dataSource = dataSource;
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
@Override
public DataSource getDataSource() {
    URI uri = getURIFromEnv();
    String host = uri.getHost();
    int port = uri.getPort();
    String db = uri.getPath().substring(1);
    String username = uri.getUserInfo().split(":")[0];
    String password = uri.getUserInfo().split(":")[1];

    PGPoolingDataSource ds = new PGPoolingDataSource();
    ds.setSsl(true);
    ds.setSslMode("verify-full");
    ds.setUser(username);
    ds.setServerName(host);
    ds.setPortNumber(port);
    ds.setPassword(password);
    ds.setDatabaseName(db);
    ds.setInitialConnections(0);
    Integer maxConnections = getMaxConnectionsFromEnv();
    if(maxConnections != null)
        ds.setMaxConnections(maxConnections);
    return ds;
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
private DataSource lookup( String name )
{
    Configuration map = configurationService.getConfiguration( name );

    PGPoolingDataSource ds = new PGPoolingDataSource();
    ds.setApplicationName( "OpenData" );
    ds.setDataSourceName( map.getString( "name", () -> map.getString( "database" ) ) );
    ds.setMaxConnections( map.getInt( "connections.max", 10 ) );
    ds.setInitialConnections( map.getInt( "connections.initial", 0 ) );

    ds.setUser( Objects.requireNonNull( map.getString( "username" ), "username required" ) );
    ds.setPassword( Objects.requireNonNull( map.getString( "password" ), "password required" ) );
    ds.setServerName( Objects.requireNonNull( map.getString( "hostname" ), "hostname required" ) );
    ds.setDatabaseName( map.getString( "database", () -> map.getString( "name" ) ) );
    ds.setPortNumber( map.getInt( "port", 0 ) );

    return ds;
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
public PGPoolingDataSource build(Environment environment) {
    final PGPoolingDataSource pg_ds = new PGPoolingDataSource();
    pg_ds.setDataSourceName("pg_ds");
    pg_ds.setServerName(this.getHost());
    pg_ds.setDatabaseName(this.getDb());
    pg_ds.setUser(this.getUser());
    pg_ds.setPassword(this.getPassword());
    pg_ds.setPortNumber(this.getPort());
    pg_ds.setMaxConnections(this.getMaxConnections());
    environment.lifecycle().manage(new Managed() {
        @Override
        public void start() {
        }

        @Override
        public void stop() {
            pg_ds.close();
        }
    });
    return pg_ds;
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
@Override
public void run(RecommenderConfiguration configuration,
                Environment environment) {
    
    PGPoolingDataSource pgPoolingDataSource = configuration.getDataSourceFactory().build(environment);
    ReloadFromJDBCDataModel dataModel = null;
    try {
        dataModel = configuration.getDataModelFactory().build(pgPoolingDataSource);
    } catch (TasteException e) {
        System.err.println(e);
        System.exit(-1);
    }
    
    Recommender userBasedRecommender = configuration.getRecommenderFactory().buildUserBasedRecommender(dataModel);
    ItemBasedRecommender itemBasedRecommender = configuration.getRecommenderFactory().buildItemBasedRecommender(dataModel);
    
    final RecommendationResource userRecommendationResource = new RecommendationResource(userBasedRecommender, itemBasedRecommender);
    final DataModelResource dataModelResource = new DataModelResource(dataModel);
    environment.jersey().register(userRecommendationResource);
    environment.jersey().register(dataModelResource);
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
/**
 * Closes all active connections to the database and cleans up any resources. Depending on your context, you may
 * wish to revoke connect permissions before invoking this.
 */
public void close()
{
  if (this.dataSource instanceof PGPoolingDataSource)
  {
    ((PGPoolingDataSource)this.dataSource).close();
  }
  else
  {
    // Terminate all connections manually.
    LinkedList<String> statements = new LinkedList<String>();
    String dbName = DatabaseProperties.getDatabaseName();
    
    statements.add(
        "SELECT \n" + 
        "    pg_terminate_backend(pid) \n" + 
        "FROM \n" + 
        "    pg_stat_activity \n" + 
        "WHERE \n" + 
        "    pid <> pg_backend_pid()\n" + 
        "    AND datname = '" + dbName + "'\n" + 
        "    ;");
    
    executeAsRoot(statements, true);
  }
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
@Test
public void createConnectionPool() throws SQLException {
    PGPoolingDataSource connectionPool = new PGPoolingDataSource();
    connectionPool.setApplicationName(CONFIG.DB_SERVER_NAME);
    connectionPool.setServerName(CONFIG.DB_SERVER_NAME);
    connectionPool.setPortNumber(CONFIG.DB_PORT_NUMBER);
    connectionPool.setDatabaseName(CONFIG.DB_NAME);
    connectionPool.setUser(CONFIG.DB_USER);
    connectionPool.setPassword(CONFIG.DB_PASSWORD);
    connectionPool.setMaxConnections(CONFIG.DB_MAX_CONNECTIONS);

    Connection c = connectionPool.getConnection();

    // request id for user dola with mode 1
    CallableStatement s = c.prepareCall("{ ? = call request_id( ? , ? ) }");
    s.registerOutParameter(1, Types.INTEGER);
    s.setString(2, "blubbedi");
    s.setInt(3, 1);
    s.execute();

    Integer client_id = s.getInt(1);
    s.close();
    assertNotNull("returned client id is null", client_id);
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
public PostgresqlConnectionProvider(@NonNls @NotNull final String serverDnsHostName, @NonNls @NotNull final String databaseName, @NonNls @NotNull final String applicationName, @NonNls @NotNull final String userName, @NonNls @NotNull final String password)
{
	dataSource = new PGPoolingDataSource();
	dataSource.setDataSourceName(randomUUID().toString());
	dataSource.setInitialConnections(2);
	dataSource.setMaxConnections(10);

	dataSource.setServerName(serverDnsHostName);
	dataSource.setPortNumber(DefaultPostgresPort);
	dataSource.setTcpKeepAlive(true);
	dataSource.setSocketTimeout(ThirtySeconds);

	dataSource.setSsl(false);
	dataSource.setProtocolVersion(0);
	dataSource.setSendBufferSize(FourKilobytes);
	dataSource.setReceiveBufferSize(FourKilobytes);
	dataSource.setBinaryTransfer(true);

	dataSource.setDatabaseName(databaseName);
	dataSource.setApplicationName(applicationName);
	dataSource.setUser(userName);
	dataSource.setPassword(password);
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
@Test(timeout = 4000)
public void test18() throws Throwable {
    Product product0 = new Product();
    PGPoolingDataSource pGPoolingDataSource0 = PGPoolingDataSource.getDataSource("");
    SQLDialect sQLDialect0 = SQLDialect.MARIADB;
    Settings settings0 = new Settings();
    DefaultDSLContext defaultDSLContext0 = new DefaultDSLContext(pGPoolingDataSource0,
                                                                 sQLDialect0,
                                                                 settings0);
    try {
        new WorkspaceSnapshot(product0, defaultDSLContext0);
        fail("Expecting exception: NullPointerException");

    } catch (NullPointerException e) {
        //
        // no message in exception (getMessage() returned null)
        //
        assertThrownBy("org.jooq.impl.DataSourceConnectionProvider", e);
    }
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
public static Connection getDbConnection(){
    PGPoolingDataSource source = new PGPoolingDataSource();
    source.setServerName("localhost");
    source.setDatabaseName("cookbook");
    source.setLoginTimeout(10);
    try {
        return source.getConnection();
    }
    catch(Exception ex) {
        ex.printStackTrace();
        return null;
    }
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
private static Connection getDbConnection(){
    PGPoolingDataSource source = new PGPoolingDataSource();
    source.setServerName("localhost");
    source.setDatabaseName("cookbook");
    source.setInitialConnections(3);
    source.setMaxConnections(10);
    source.setLoginTimeout(10);
    try {
        return source.getConnection();
    }
    catch(Exception ex) {
        ex.printStackTrace();
        return null;
    }
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
private static Connection getDbConnection(){
    PGPoolingDataSource source = new PGPoolingDataSource();
    source.setServerName("localhost");
    source.setDatabaseName("cookbook");
    try {
        return source.getConnection();
    }
    catch(Exception ex) {
        ex.printStackTrace();
        return null;
    }
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
public PostgresStore(PostgresConfiguration config, String schema) {
    this.pool = new PGPoolingDataSource();
    this.pool.setUrl(config.getJdbcUrl());
    this.pool.setUser(config.getUsername());
    this.pool.setPassword(config.getPassword());
    this.pool.setCurrentSchema(schema);
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
@Bean
public DataSource datasource(Environment env) {
    PGPoolingDataSource source = new PGPoolingDataSource();
    source.setServerName(env.getProperty(POSTGRES_HOST_KEY));
    source.setDatabaseName(env.getProperty(POSTGRES_DB));
    source.setUser(env.getProperty(POSTGRES_USER));
    source.setPassword(env.getProperty(POSTGRES_PASSWORD));
    return source;
}
 

import org.postgresql.ds.PGPoolingDataSource; //导入依赖的package包/类
private static DataSource getDataSource(SCEIApplicationConfig config) {
    final PGPoolingDataSource source = new PGPoolingDataSource();
    source.setDataSourceName("PostgresDB");
    source.setServerName(config.getDatabaseServerName());
    source.setDatabaseName(config.getDatabaseName());
    source.setPortNumber(config.getDatabasePort());
    source.setUser(config.getDatabaseUser());
    source.setPassword(config.getDatabasePassword());
    source.setMaxConnections(10);
    return source;
}