Associação de Conexão JDBC

FAÇA O DOWNLOAD COMO PDF

Introdução
Este documento fornece informações destinadas a ajudar os
desenvolvedores a fornecer uma estratégia de pool de conexão para
aplicativos que devem lidar com o agrupamento de
conexões. Primeiro, este documento fornece uma visão geral do pool
de conexão JDBC conforme especificado pela especificação JDBC
3.0. Em seguida, fornece exemplos de como usar o DataDirect
Connection Pool Manager (que é fornecido com DataDirect
Connect® para JDBC e DataDirect SequeLink® para JDBC) para seus
aplicativos. Finalmente, este documento fornece um exemplo que
mostra benchmarks de desempenho que demonstram o benefício de
desempenho que você pode conseguir usando o pool de conexão.

De volta ao topo

Pool de conexão
O estabelecimento de conexões JDBC é caro em termos de recursos,
especialmente quando a API JDBC é usada em um ambiente de
servidor de camada intermediária, como quando o DataDirect
Connect para JDBC ou DataDirect SequeLink para JDBC está sendo
executado em um servidor web habilitado para Java. Neste tipo de
ambiente, o desempenho pode ser melhorado significativamente
quando o pool de conexão é usado. O agrupamento de
conexões significa que as conexões são reutilizadas em vez de serem
criadas sempre que uma conexão é solicitada. Para facilitar a
reutilização da conexão, um módulo de agrupamento de conexão
mantém um cache de memória de conexões de banco de dados,
chamado pool de conexão , como uma camada em cima de qualquer
produto de driver JDBC padrão.

O agrupamento de conexões é executado em segundo plano e não

afeta a forma como um aplicativo é codificado; no entanto, o aplicativo
deve usar um objeto DataSource (um objeto que implementa a
interface DataSource) para obter uma conexão em vez de usar a
classe DriverManager. Uma classe que implementa a interface
DataSource pode ou não fornecer pool de conexão. Um objeto
DataSource é registrado com um serviço de nomeação JNDI. Uma vez
 que um objeto DataSource está registrado, o aplicativo o recupera do
serviço de nomeação JNDI da maneira padrão.

Por exemplo:
Context ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("jdbc/SequeLink");

Se o objeto DataSource fornecer pool de conexão, a pesquisa

retornará uma conexão do pool se houver um disponível. Se o objeto
DataSource não fornecer pool de conexão ou se não houver conexões
disponíveis no pool, a pesquisa cria uma nova conexão. O aplicativo
se beneficia da reutilização da conexão sem exigir alterações de
código. As conexões reutilizadas do pool se comportam da mesma
forma que as conexões físicas recém-criadas. O aplicativo faz uma
conexão com o banco de dados e o acesso a dados funciona da
maneira usual. Quando a aplicação terminou seu trabalho com a
conexão, o aplicativo fecha a conexão de forma explícita.

Por exemplo:
Connection con = ds.getConnection("scott", "tiger");
// Do some database activities using the connection...
con.close();

O evento de encerramento em uma conexão combinada sinaliza o

módulo de pool para colocar a conexão no pool de conexão para
reutilização futura.

De volta ao topo

JDBC 3.0 API Framework

A API JDBC 3.0 fornece uma estrutura geral com "ganchos" para
suportar o agrupamento de conexões em vez de especificar uma
implementação particular de pool de conexão. Desta forma,
fornecedores ou usuários de terceiros podem implementar os
algoritmos específicos de armazenamento em cache ou de
agrupamento que melhor atendam às suas necessidades. A API JDBC
3.0 especifica uma classe ConnectionEvent e as seguintes interfaces
como ganchos para qualquer implementação de pool de conexão:

 ConnectionPoolDataSource
 PooledConnection
 ConnectionEventListener
A Figura 1 mostra esse quadro geral.
 Figura 1. Arquitetura de agrupamento de conexão do JDBC 3.0

 JDBCDriverVendorDataSource
Um fornecedor de driver JDBC deve fornecer uma classe que
implemente a interface padrão do ConnectionPoolDataSource. Esta
interface fornece ganchos que fornecedores terceirizados podem usar
para implementar o agrupamento como uma camada em cima de seus
drivers JDBC. A interface ConnectionPoolDataSource atua como uma
"fábrica" que cria objetos PooledConnection.

 JDBCDriverVendorPooledConnection
Um fornecedor de driver JDBC deve fornecer uma classe que
implemente a interface padrão PooledConnection. Essa interface
permite que fornecedores terceirizados implementem o agrupamento
em cima de seus drivers JDBC. Um objeto PooledConnection atua
como uma "fábrica" que cria objetos Connection. Um objeto
PooledConnection mantém a conexão física com o banco de dados; O
objeto Conexão criado pelo objeto PooledConnection é simplesmente
um identificador para a conexão física.

 PoolingVendorDataSource
Um fornecedor de terceiros deve fornecer uma classe que implemente
a interface DataSource. Esta interface é o ponto de entrada que
permite a interação com seu módulo de pool. A classe do fornecedor
 de agrupamento usa o objeto PooledConnectionDataSource do driver
JDBC para criar as Conexões Pooled que o pool gerencia.

 PoolingVendorConnectionCache
A API JDBC 3.0 não especifica as interfaces a serem usadas entre o
objeto DataSource e o cache de conexão. O fornecedor de
agrupamento determina como esses componentes irão
interagir. Normalmente, um módulo de cache de conexão contém uma
ou várias classes. Na Figura 1, a classe
PoolingVendorConnectionCache é usada como uma maneira simples
de transmitir esse conceito. O módulo de cache de conexão deve ter
uma classe que implemente a interface padrão
ConnectionEventListener. A interface ConnectionEventListener recebe
objetos ConnectionEvent de objetos PooledConnection quando uma
conexão se fecha ou ocorre um erro de conexão. Quando uma
conexão, criada por um PooledConnection, fecha, o módulo de cache
de conexão retorna o objeto PooledConnection para o cache.
Quando um aplicativo faz uma conexão chamando
DataSource.getConnection () em um objeto
PoolingVendorDataSource, o objeto PoolingVendorDataSource
executa uma pesquisa no cache de conexão para determinar se um
objeto PooledConnection está disponível. Se estiver disponível, ele é
usado. Se um objeto PooledConnection não estiver disponível,
ConnectionPoolDataSource do fornecedor do driver JDBC cria um
novo objeto PooledConnection. Em ambos os casos, um objeto
PooledConnection está disponível.

O objeto PoolingVendorDataSource invoca o método

PooledConnection.getConnection () para obter um objeto de conexão,
que ele retorna ao aplicativo para usar como uma conexão
normal. Como o fornecedor do driver JDBC implementa a interface
PooledConnection, o driver JDBC cria o objeto Connection; No
entanto, esse objeto de conexão não é uma conexão física como no
caso de não pool. O objeto Conexão é um identificador para a
conexão física mantida pelo objeto PooledConnection.

Quando o aplicativo fecha a conexão chamando o método

Connection.close (), um ConnectionEvent é gerado e é passado para
o módulo de cache. O módulo de cache retorna o objeto
PooledConnection para o cache para ser reutilizado. O aplicativo não
possui acesso ao método PooledConnection.close (). Somente o
módulo de pool de conexão, como parte de sua atividade de limpeza,
emite o método PooledConnection.close () para realmente fechar a
conexão física.
 De volta ao topo

Criando uma fonte de dados

Esta seção fornece exemplos sobre como criar objetos DataSource
agrupados e não agrupados para DataDirect Connect para JDBC e
DataDirect SequeLink para JDBC e registre-os em um serviço de
nomeação JNDI.

Criando um objeto DataDirect Data Source

DATADIRECT CONNECT PARA JDBC
Este exemplo mostra como criar um objeto DataDirect
Connect para JDBC DataSource e registrá-lo em um serviço de
nomeação JNDI. A classe DataSource fornecida
pelos drivers DataDirect Connect para JDBC é dependente do banco
de dados. No exemplo a seguir, usamos o Oracle, então a classe
DataSource é com.ddtek.jdbcx.oracle.OracleDataSource.

Se você deseja que o aplicativo cliente use:

 Uma fonte de dados não agrupada , o aplicativo pode especificar o

nome JNDI desse objeto fonte de dados como registrado no seguinte
exemplo de código ("jdbc / ConnectSparkyOracle").
 Uma fonte de dados agrupada , o aplicativo deve especificar o nome
JNDI ("jdbc / SparkyOracle") como registrado no exemplo de código
na seção "Criando uma Fonte de Dados Usando o DataDirect
Connection Pool Manager " .
//********************************************************************
//
// This code creates a DataDirect Connect for JDBC data source and
// registers it to a JNDI naming service. This DataDirect Connect for
// JDBC data source uses the DataSource implementation provided by
// DataDirect Connect for JDBC Drivers.
//
// This data source registers its JNDI name as
<jdbc/ConnectSparkyOracle>.
// Client applications using non-pooled connections must perform a
lookup
// for this name.
//
//********************************************************************
// From DataDirect Connect for JDBC:
import com.ddtek.jdbcx.oracle.OracleDataSource;
import javax.sql.*;
import java.sql.*;
import javax.naming.*;
import javax.naming.directory.*;
 import java.util.Hashtable;
public class OracleDataSourceRegisterJNDI
{
public static void main(String argv[])
{
try {
// Set up data source reference data for naming context:
// -----------------------------------------------------
// Create a class instance that implements the interface
// ConnectionPoolDataSource
OracleDataSource ds = new OracleDataSource();
ds.setDescription(
"Oracle on Sparky - Oracle Data Source");
ds.setServerName("sparky");
ds.setPortNumber(1521);
ds.setUser("scott");
ds.setPassword("test");
// Set up environment for creating initial context
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
env.put(Context.PROVIDER_URL, "file:c:\\JDBCDataSource");
Context ctx = new InitialContext(env);
// Register the data source to JNDI naming service
ctx.bind("jdbc/ConnectSparkyOracle", ds);
} catch (Exception e) {
System.out.println(e);
return;
}
} // Main
} // class OracleDataSourceRegisterJNDI

DataDirect SequeLink
O exemplo a seguir mostra como criar um objeto
SequeLink para JDBC DataSource e registrá-lo em um serviço de
nomeação JNDI. A classe DataSource fornecida pelo driver DataDirect
SequeLink para JDBC é independente do banco de dados; portanto,
para todos os bancos de dados, a classe DataSource é
SequeLinkDataSource.

Se você deseja que o aplicativo cliente use:

 Uma conexão não agrupada (" Criando um objeto DataDirect Data

Source "), você deve modificar este exemplo para que a entrada JNDI
seja registrada usando o nome jdbc / SparkyOracle.
 Uma conexão combinada , a entrada JNDI deve se mapear para a
DataSource do DataDirect Connection Pool Manager. Portanto, você
deve registrar duas fontes de dados:
o Fonte de dados do Gerenciador de conexões usando o exemplo em
" Criando uma fonte de dados usando o Gerenciador de pool de
conexão DataDirect ". Esse processo registra a fonte de dados usando
a entrada JNDI jdbc / SparkyOracle. O Connection Pool Manager cria
conexões físicas usando a entrada JNDI jdbc /
SequeLinkSparkyOracle.
o Uma fonte de dados SequeLink, usando o exemplo a seguir para
registrar o DataSource usando a entrada JNDI jdbc /
SequeLinkSparkyOracle.
//********************************************************************
//
// This code creates a SequeLink for JDBC data source and registers it
to a
// JNDI naming service. This SequeLink for JDBC data source uses the
// DataSource implementation provided by the SequeLink for JDBC
Driver.
//
// If you want users to use non-pooled connections, you must modify
this
// example so that it registers the SequeLink Data Source using the
JNDI
// entry <jdbc/SparkyOracle>.
//
// If you want users to use pooled connections, use this example as is
// to register the SequeLink Data Source using the JNDI entry
// <jdbc/SequeLinkSparkyOracle>. Also, use the example in the next
// section to register the Connection Pool Manager's Data Source using
the
// JNDI entry <jdbc/SparkyOracle>
//
//********************************************************************
// From SequeLink for JDBC:
import com.ddtek.jdbcx.sequelink.SequeLinkDataSource;
import javax.sql.*;
import java.sql.*;
import javax.naming.*;
import javax.naming.directory.*;
import java.util.Hashtable;
public class SequeLinkDataSourceRegisterJNDI
{
public static void main(String argv[])
{
try {
// Set up data source reference data for naming context:
// ----------------------------------------------------
// Create a class instance that implements the interface
// ConnectionPoolDataSource
OracleDataSource ds = new SequeLinkDataSource();
ds.setDescription(
"Oracle on Sparky - SequeLink Data Source");
ds.setServerName("sparky");
ds.setPortNumber(19996);
ds.setUser("scott");
ds.setPassword("test");
// Set up environment for creating initial context
 Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
env.put(Context.PROVIDER_URL, "file:c:\\JDBCDataSource");
Context ctx = new InitialContext(env);
// Register the data source to JNDI naming service
ctx.bind("jdbc/SequeLinkSparkyOracle", ds);
} catch (Exception e) {
System.out.println(e);
return;
}
} // Main
} // class SequeLinkDataSourceRegisterJNDI

Criando uma Fonte de Dados Usando o

Gerenciador de Pool de Conexão
DataDirect
DATADIRECT CONNECT PARA JDBC
O exemplo de código Java a seguir cria uma fonte de dados para o
DataDirect Connect para JDBC e o registra em um serviço de
nomeação JNDI. A classe PooledConnectionDataSource é fornecida
pelo pacote DataDirect com.ddtek.pool. No exemplo de código que se
segue, o objecto PooledConnectionDatasource referencia um
DataDirect Ligação reunidas por objecto fonte de dados
JDBC. Portanto, o exemplo executa uma pesquisa configurando o
atributo DataSourceName para o nome JNDI de uma fonte de dados
agrupada registrada (neste exemplo, jdbc / ConnectSparkyOracle, que
é o objeto DataDirect Connect para JDBC DataSource criado na seção
" Criando um DataDirect Data Source Object " .

Os aplicativos de cliente que usam essa fonte de dados devem

realizar uma pesquisa usando o nome JNDI registrado (jdbc /
SparkyOracle neste exemplo).
//********************************************************************
//
// This code creates a data source and registers it to a JNDI naming
// service. This data source uses the PooledConnectionDataSource
// implementation provided by the DataDirect com.ddtek.pool package.
//
// This data source refers to a previously registered pooled data
source.
//
// This data source registers its name as <jdbc/SparkyOracle>
// Client applications using pooling must perform a lookup for this
name.
//
//********************************************************************
// From the DataDirect connection pooling package:
import com.ddtek.pool.PooledConnectionDataSource;
import javax.sql.*;
import java.sql.*;
import javax.naming.*;
import javax.naming.directory.*;
import java.util.Hashtable;
public class PoolMgrDataSourceRegisterJNDI
{
public static void main(String argv[])
{
try {
// Set up data source reference data for naming context:
// ----------------------------------------------------
// Create a pooling manager's class instance that implements
// the interface DataSource
PooledConnectionDataSource ds = new PooledConnectionDataSource();
ds.setDescription("Sparky Oracle - Oracle Data Source");
// Refer to a previously registered pooled data source to access
// a ConnectionPoolDataSource object
ds.setDataSourceName("jdbc/ConnectSparkyOracle");
// The pool manager will be initiated with 5 physical connections
ds.setInitialPoolSize(5);
// The pool maintenance thread will make sure that there are 5
// physical connections available
ds.setMinPoolSize(5);
// The pool maintenance thread will check that there are no more
// than 10 physical connections available
ds.setMaxPoolSize(10);
// The pool maintenance thread will wake up and check the pool
// every 20 seconds
ds.setPropertyCycle(20);
// The pool maintenance thread will remove physical connections
// that are inactive for more than 300 seconds
ds.setMaxIdleTime(300);
// Set tracing off since we choose not to see output listing
// of activities on a connection
ds.setTracing(false);
// Set up environment for creating initial context
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
env.put(Context.PROVIDER_URL, "file:c:\\JDBCDataSource");
Context ctx = new InitialContext(env);
// Register the data source to JNDI naming service
// for application to use
ctx.bind("jdbc/SparkyOracle", ds);
} catch (Exception e) {
System.out.println(e);
return;
}
} // Main
} // class PoolMgrDataSourceRegisterJNDI
DataDirect SequeLink
O exemplo de código Java a seguir cria uma fonte de dados para o
JDBC e o registra em um serviço de nomeação JNDI. A classe
PooledConnectionDataSource é fornecida pelo pacote DataDirect
com.ddtek.pool. No exemplo de código a seguir, o objeto
PooledConnectionDataSource faz referência a um objeto de fonte de
dados JDBC. O exemplo executa uma pesquisa configurando o
atributo DataSourceName para o nome JNDI de uma fonte de dados
agrupada registrada (neste exemplo, jdbc / SequeLinkSparkyOracle,
que é o objeto JDBC DataSource criado na seção " Criando um objeto
DataDirect Data Source ").

Os aplicativos de cliente que usam essa fonte de dados devem

realizar uma pesquisa usando o nome JNDI registrado (jdbc /
SparkyOracle neste exemplo).
//********************************************************************
//
// This code creates a data source and registers it to a JNDI naming
// service. This data source uses the PooledConnectionDataSource
// implementation provided by the DataDirect com.ddtek.pool package.
//
// This data source refers to a previously registered pooled data
source.
//
// This data source registers its name as <jdbc/SparkyOracle>
// Client applications using pooling must perform a lookup for this
name.
//
//********************************************************************
// From the DataDirect connection pooling package:
import com.ddtek.pool.PooledConnectionDataSource;
import javax.sql.*;
import java.sql.*;
import javax.naming.*;
import javax.naming.directory.*;
import java.util.Hashtable;
public class PoolMgrDataSourceRegisterJNDI
{
public static void main(String argv[])
{
try {
// Set up data source reference data for naming context:
// ----------------------------------------------------
// Create a pooling manager's class instance that implements
// the interface DataSource
PooledConnectionDataSource ds = new PooledConnectionDataSource();
ds.setDescription("Sparky Oracle - Oracle Data Source");
// Refer to a previously registered pooled data source to access
// a ConnectionPoolDataSource object
ds.setDataSourceName("jdbc/SequeLinkSparkyOracle");
// The pool manager will be initiated with 5 physical connections
 ds.setInitialPoolSize(5);
// The pool maintenance thread will make sure that there are
// at least 5 physical connections available
ds.setMinPoolSize(5);
// The pool maintenance thread will check that there are no more
// than 10 physical connections available
ds.setMaxPoolSize(10);
// The pool maintenance thread will wake up and check the pool
// every 20 seconds
ds.setPropertyCycle(20);
// The pool maintenance thread will remove physical connections
// that are inactive for more than 300 seconds
ds.setMaxIdleTime(300);
// Set tracing off since we choose not to see output listing
// of activities on a connection
ds.setTracing(false);
// Set up environment for creating initial context
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
env.put(Context.PROVIDER_URL, "file:c:\\JDBCDataSource");
Context ctx = new InitialContext(env);
// Register the data source to JNDI naming service
// for application to use
ctx.bind("jdbc/SparkyOracle", ds);
} catch (Exception e) {
System.out.println(e);
return;
}
} // Main
} // class PoolMgrDataSourceRegisterJNDI

De volta ao topo

Conectando-se a uma fonte de

dados
Se o agrupamento de conexão é usado não afeta o código do
aplicativo. Não requer alterações de código no aplicativo porque o
aplicativo executa uma pesquisa em um nome JNDI de uma fonte de
dados previamente registrada. Se a fonte de dados especificar uma
implementação de pool de conexão durante o registro JNDI (conforme
descrito na seção " Criando uma Fonte de Dados Usando o
Gerenciador de Pool de Conexão DataDirect "), o aplicativo cliente se
beneficia de conexões mais rápidas através do pool de conexão.

DataDirect Connect para JDBC

O exemplo a seguir mostra o código que pode ser usado para
pesquisar e usar uma fonte de dados registrada no JNDI para
conexões. Você especifica o nome de pesquisa do JNDI para a fonte
de dados que você criou (conforme descrito em "Criando uma Fonte
de Dados Usando o Gerenciador de Pool de Conexão DataDirect " .
//********************************************************************
//
// Test program to look up and use a JNDI-registered data source.
//
// To run the program, specify the JNDI lookup name for the
// command-line argument, for example:
//
// java TestDataSourceApp JNDI_lookup_name
//
//********************************************************************
import javax.sql.*;
import java.sql.*;
import javax.naming.*;
import java.util.Hashtable;
public class TestDataSourceApp
{
public static void main(String argv[])
{
String strJNDILookupName = """;
// Get the JNDI lookup name for a data source
int nArgv = argv.length;
if (nArgv != 1) {
// User does not specify a JNDI lookup name for a data source,
System.out.println(
"Please specify a JNDI name for your data source");
System.exit(0);
} else {
strJNDILookupName = argv[0];
}
DataSource ds = null;
Connection con = null;
Context ctx = null;
Hashtable env = null;
long nStartTime, nStopTime, nElapsedTime;
// Set up environment for creating InitialContext object
env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
env.put(Context.PROVIDER_URL, "file:c:\\JDBCDataSource");
try {
// Retrieve the DataSource object that bound to the
// logical lookup JNDI name
ctx = new InitialContext(env);
ds = (DataSource) ctx.lookup(strJNDILookupName);
} catch (NamingException eName) {
System.out.println("Error looking up " +
strJNDILookupName + ": " +eName);
System.exit(0);
}
int numOfTest = 4;
 int [] nCount = {100, 100, 1000, 3000};
for (int i = 0; i < numOfTest; i ++) {
// Log the start time
nStartTime = System.currentTimeMillis();
for (int j = 1; j <= nCount[i]; j++) {
// Get Database Connection
try {
con = ds.getConnection("scott", "tiger");
// Do something with the connection
// ...
// Close Database Connection
if (con != null) con.close();
} catch (SQLException eCon) {
System.out.println("Error getting a connection: " + eCon);
System.exit(0);
} // try getConnection
} // for j loop
// Log the end time
nStopTime = System.currentTimeMillis();
// Compute elapsed time
nElapsedTime = nStopTime - nStartTime;
System.out.println("Test number " + i + ": looping " +
nCount[i] + " times");
System.out.println("Elapsed Time: " + nElapsedTime + "\n");
} // for i loop
// All done
System.exit(0);
} // Main
} // TestDataSourceApp

NOTA: A classe de objeto DataDirect Connect for JDBC DataSource

implementa a interface DataSource para não pooling, além de
ConnectionPoolDataSource para pool. Para usar uma fonte de dados
que não seja pool de pool, use o nome JNDI registrado no código de
exemplo na seção " Criando um objeto DataDirect Data Source " e
execute o TestDataSourceApp. Por exemplo:
java TestDataSourceApp jdbc/ConnectSparkyOracle

DataDirect SequeLink para JDBC

O exemplo a seguir mostra o código que pode ser usado para
pesquisar e usar uma fonte de dados registrada no JNDI para
conexões. Você especifica o nome da pesquisa JNDI para a fonte de
dados que você criou (conforme descrito em " Criando uma Fonte de
Dados Usando o Gerenciador de Pool de Conexão DataDirect ").
//********************************************************************
//
// Test program to look up and use a JNDI-registered data source.
//
// To run the program, specify the JNDI lookup name for the
// command-line argument, for example:
//
// java TestDataSourceApp JNDI_lookup_name
//
//********************************************************************
import javax.sql.*;
import java.sql.*;
import javax.naming.*;
import java.util.Hashtable;
public class TestDataSourceApp
{
public static void main(String argv[])
{
String str JNDILookupName = "jdbc/SparkyOracle";
// Hard-code the JNDI entry, the application does not need to change
DataSource ds = null;
Connection con = null;
Context ctx = null;
Hashtable env = null;
long nStartTime, nStopTime, nElapsedTime;
// Set up environment for creating InitialContext object
env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.fscontext.RefFSContextFactory");
env.put(Context.PROVIDER_URL, "file:c:\\JDBCDataSource");
try {
// Retrieve the DataSource object that bound to the
// logical lookup JNDI name
ctx = new InitialContext(env);
ds = (DataSource) ctx.lookup(strJNDILookupName);
} catch (NamingException eName) {
System.out.println("Error looking up " +
strJNDILookupName + ": " +eName);
System.exit(0);
}
int numOfTest = 4;
int [] nCount = {100, 100, 1000, 3000};
for (int i = 0; i < numOfTest; i ++) {
// Log the start time
nStartTime = System.currentTimeMillis();
for (int j = 1; j <= nCount[i]; j++) {
// Get Database Connection
try {
con = ds.getConnection("scott", "tiger");
// Do something with the connection
// ...
// Close Database Connection
if (con != null) con.close();
} catch (SQLException eCon) {
System.out.println("Error getting a connection: " + eCon);
System.exit(0);
} // try getConnection
} // for j loop
// Log the end time
nStopTime = System.currentTimeMillis();
// Compute elapsed time
nElapsedTime = nStopTime - nStartTime;
 System.out.println("Test number " + i + ": looping " +
nCount[i] + " times");
System.out.println("Elapsed Time: " + nElapsedTime + "\n");
} // for i loop
// All done
System.exit(0);
} // Main
} // TestDataSourceApp

NOTA: A classe de objeto DataDirect SequeLink para JDBC

DataSource implementa a interface DataSource para não
agrupamento, além de ConnectionPoolDataSource para pool. Para
usar conexões não agrupadas, modifique o exemplo em " Criando um
objeto DataDirect Data Source " para que ele registre a SequeLink
Data Source usando a entrada JNDI
jdbc/SparkyOracle.

Você pode então executar o TestDataSourceApp sem qualquer

modificação:
java TestDataSourceApp

De volta ao topo

Fechar o pool de conexão

Para garantir que o pool de conexão seja fechado corretamente
quando um aplicativo pára de ser executado, o aplicativo deve notificar
o DataDirect Connection Pool Manager quando ele parar. Se um
aplicativo é executado no JRE 1.3 ou superior, a notificação ocorre
automaticamente quando o aplicativo pára de ser executado. Se um
aplicativo é executado no JRE 1.2, o aplicativo deve notificar
explicitamente o gerenciador do pool quando ele pára de usar o
método PooledConnectionDataSource.close como mostrado no
seguinte código:

if (ds instanceof com.ddtek.pool.PooledConnectionDataSource){

com.ddtek.pool.PooledConnectionDataSource pcds =
(com.ddtek.pool.PooledConnectionDataSource) ds;
pcds.close();
}

O método PooledConnectionDataSource.close também pode ser

usado para fechar explicitamente o pool de conexão enquanto o
aplicativo está sendo executado. Por exemplo, se as mudanças forem
feitas na configuração do pool usando uma ferramenta de
gerenciamento de pool, o método PooledConnectionDataSource.close
pode ser usado para forçar o pool de conexão a fechar e recriar o pool
usando os novos valores de configuração.
De volta ao topo

Benchmarks de desempenho
Utilizamos o aplicativo de exemplo fornecido na seção " Conexão a
uma fonte de dados " para abrir uma conexão com o Oracle9i usando
um driver Oracle DataDirect Connect para JDBC 3.2. Fechamos a
conexão em 100, 100, 1000 e 3000 iterações. Executamos este
aplicativo de exemplo em uma única máquina Pentium IV 2 GHz com
512 MB de RAM conectada a um servidor Oracle9i (máquina Pentium
IV 2 GHz com 512 MB de RAM). O tempo total decorrido para cada
execução foi medido quando o agrupamento de conexão foi usado e
foi medido novamente quando o pool de conexão não foi usado como
mostrado na tabela a seguir:

100 iterações 100 iterações 1000 iterações 3000 It

Agrupando 547 ms <10 ms 47 ms 31 ms

Não agrupando 4859 ms 4453 ms 43625 ms 134375

Quando o agrupamento de conexão foi usado, a primeira conexão

levou mais tempo porque uma nova conexão física teve que ser criada
e o gerenciador do grupo teve que ser inicializado. Uma vez que a
conexão existia, a conexão física foi colocada no pool e foi reutilizada
para criar um identificador para cada conexão subseqüente. Você
pode ver isso comparando a primeira conexão (as primeiras 100
iterações) com suas conexões subseqüentes.

NOTA: Em nosso exemplo de agrupamento de conexão, todas as

conexões subseqüentes foram reutilizadas porque elas foram usadas
para o mesmo usuário e a limpeza do pool não ocorreu.

Agora, compare os resultados da associação em cada ponto de

verificação da iteração com os resultados que não são de
pool. Claramente, o pool de conexão representa uma melhoria
significativa no desempenho.

Conclusão
O pool de conexões fornece uma melhoria significativa no
desempenho ao reutilizar conexões ao invés de criar uma nova
conexão para cada solicitação de conexão, sem exigir alterações no
seu código de aplicativo JDBC.

Observe que o tempo para a caixa combinada de iterao 3000 é mais

rápido que o caso combinado de iterao 1000. Isso ocorre porque o
compilador Just In Time (JIT) entrou em vigor neste momento. Se o
compilador JIT estiver desativado, o tempo para o caso combinado de
iterações 3000 aumenta para 94 ms, enquanto o tempo para os outros
casos agrupados permanece o mesmo.