This section provides examples on how to create pooled and non-pooled DataSource objects for DataDirect Connect for JDBC and DataDirect SequeLink for JDBC, and register them to a JNDI naming service.
Creating a DataDirect Data Source Object
DataDirect Connect for JDBC
This example shows how to create a DataDirect Connect for JDBC DataSource object and register it to a JNDI naming service. The DataSource class provided by the DataDirect Connect for JDBC drivers is database-dependent. In the following example we use Oracle, so the DataSource class is com.ddtek.jdbcx.oracle.OracleDataSource.
If you want the client application to use:
- A non-pooled data source, the application can specify the JNDI name of this data source object as registered in the following code example ("jdbc/ConnectSparkyOracle").
- A pooled data source, the application must specify the JNDI name ("jdbc/SparkyOracle") as registered in the code example in the section "Creating a Data Source Using the 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
The following example shows how to create a SequeLink for JDBC DataSource object and register it to a JNDI naming service. The DataSource class provided by the DataDirect SequeLink for JDBC driver is database-independent; therefore, for all databases, the DataSource class is SequeLinkDataSource.
If you want the client application to use:
- A non-pooled connection ("Creating a DataDirect Data Source Object"), you must modify this example so that the JNDI entry is registered using the name jdbc/SparkyOracle.
- A pooled connection, the JNDI entry must map to the DataSource of the DataDirect Connection Pool Manager. Therefore, you must register two data sources:
- The Connection Pool Manager's Data Source using the example in "Creating a Data Source Using the DataDirect Connection Pool Manager." This process registers the data source using the JNDI entry jdbc/SparkyOracle. The Connection Pool Manager creates physical connections using the JNDI entry jdbc/SequeLinkSparkyOracle.
- A SequeLink Data Source, using the following example to register the DataSource using the JNDI entry 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
Creating a Data Source Using the DataDirect Connection Pool Manager
DataDirect Connect for JDBC
The following Java code example creates a data source for DataDirect Connect for JDBC and registers it to a JNDI naming service. The PooledConnectionDataSource class is provided by the DataDirect com.ddtek.pool package. In the following code example, the PooledConnectionDataSource object references a pooled DataDirect Connect for JDBC data source object. Therefore, the example performs a lookup by setting the DataSourceName attribute to the JNDI name of a registered pooled data source (in this example, jdbc/ConnectSparkyOracle, which is the DataDirect Connect for JDBC DataSource object created in section "Creating a DataDirect Data Source Object."
Client applications that use this data source must perform a lookup using the registered JNDI name (jdbc/SparkyOracle in this example).
//********************************************************************
//
// 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
The following Java code example creates a data source for JDBC and registers it to a JNDI naming service. The PooledConnectionDataSource class is provided by the DataDirect com.ddtek.pool package. In the following code example, the PooledConnectionDataSource object references a JDBC data source object. The example performs a lookup by setting the DataSourceName attribute to the JNDI name of a registered pooled data source (in this example, jdbc/SequeLinkSparkyOracle, which is the JDBC DataSource object created in section "Creating a DataDirect Data Source Object").
Client applications that use this data source must perform a lookup using the registered JNDI name (jdbc/SparkyOracle in this example).
//********************************************************************
//
// 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
Whether connection pooling is used does not affect application code. It does not require any code changes to the application because the application performs a lookup on a JNDI name of a previously registered data source. If the data source specifies a connection pooling implementation during JNDI registration (as described in section "Creating a Data Source Using the DataDirect Connection Pool Manager"), the client application benefits from faster connections through connection pooling.
DataDirect Connect for JDBC
The following example shows code that can be used to look up and use a JNDI-registered data source for connections. You specify the JNDI lookup name for the data source you created (as described in "Creating a Data Source Using the DataDirect Connection Pool Manager."
//********************************************************************
//
// 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
NOTE: The DataDirect Connect for JDBC DataSource object class implements the DataSource interface for non-pooling in addition to ConnectionPoolDataSource for pooling. To use a non-pooling data source, use the JNDI name registered in the example code in section "Creating a DataDirect Data Source Object" and run the TestDataSourceApp. For example:
java TestDataSourceApp jdbc/ConnectSparkyOracle
DataDirect SequeLink for JDBC
The following example shows code that can be used to look up and use a JNDI-registered data source for connections. You specify the JNDI lookup name for the data source you created (as described in "Creating a Data Source Using the DataDirect Connection Pool Manager.")
//********************************************************************
//
// 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
NOTE: The DataDirect SequeLink for JDBC DataSource object class implements the DataSource interface for non-pooling in addition to ConnectionPoolDataSource for pooling. To use non-pooled connections, modify the example in "Creating a DataDirect Data Source Object" so that it registers the SequeLink Data Source using the JNDI entry
You can then run the TestDataSourceApp without any modification: