* On startup, DriverManager loads all the managers specified
* by the system property jdbc.drivers. The value of this
* property should be a colon separated list of fully qualified driver
* class names. Additional drivers can be loaded at any time by
* simply loading the driver class with class.forName(String).
* The driver should automatically register itself in a static
* initializer.
*
* The methods in this class are all static. This class
* cannot be instantiated.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
*/
public class DriverManager
{
/**
* This is the log stream for JDBC drivers.
*/
private static PrintStream log_stream;
/**
* This is the log writer for JDBC drivers.
*/
private static PrintWriter log_writer;
/**
* This is the login timeout used by JDBC drivers.
*/
private static int login_timeout;
/**
* This is the list of JDBC drivers that are loaded.
*/
private static Vector drivers;
// Hmm, seems like we might want to do a Hashtable and lookup by something,
// but what would it be?
// Load all drivers on startup
static
{
drivers = new Vector();
String driver_string = System.getProperty("jdbc.drivers");
if (driver_string != null)
{
StringTokenizer st = new StringTokenizer(driver_string);
while (st.hasMoreTokens())
{
String driver_classname = st.nextToken();
try
{
Class.forName(driver_classname); // The driver registers itself
}
catch (Exception e) { ; } // Ignore not founds
}
}
}
/** Can't be instantiated. */
private DriverManager()
{
}
/**
* This method returns the log writer being used by all JDBC drivers.
* This method should be used in place of the deprecated
* getLogStream method.
*
* @return The log writer in use by JDBC drivers.
*/
public static PrintWriter getLogWriter()
{
return log_writer;
}
/**
* This method sets the log writer being used by JDBC drivers. This is a
* system-wide parameter that affects all drivers. Note that since there
* is no way to retrieve a PrintStream from a
* PrintWriter, this method cannot set the log stream in
* use by JDBC. Thus any older drivers may not see this setting.
*
* @param out The new log writer for JDBC.
*/
public static void setLogWriter(PrintWriter out)
{
DriverManager.log_writer = out;
}
/**
* This method attempts to return a connection to the specified
* JDBC URL string using the specified connection properties.
*
* @param url The JDBC URL string to connect to.
* @param properties The connection properties.
*
* @return A Connection to that URL.
*
* @exception SQLException If an error occurs.
*/
public static Connection getConnection(String url, Properties properties)
throws SQLException
{
Driver d = getDriver(url);
if (d == null)
throw new SQLException("Driver not found for URL: " + url);
return d.connect(url, properties);
}
/**
* This method attempts to return a connection to the specified
* JDBC URL string using the specified username and password.
*
* @param url The JDBC URL string to connect to.
* @param user The username to connect with.
* @param password The password to connect with.
* @return A Connection to that URL.
* @exception SQLException If an error occurs.
*/
public static Connection getConnection(String url, String user,
String password) throws SQLException
{
Properties p = new Properties();
if (user != null)
p.setProperty("user", user);
if (password != null)
p.setProperty("password", password);
return getConnection(url, p);
}
/**
* This method attempts to return a connection to the specified
* JDBC URL string.
*
* @param url The JDBC URL string to connect to.
*
* @return A Connection to that URL.
*
* @exception SQLException If an error occurs.
*/
public static Connection getConnection(String url) throws SQLException
{
return getConnection(url, new Properties());
}
/**
* This method returns a driver that can connect to the specified
* JDBC URL string. This will be selected from among drivers loaded
* at initialization time and those drivers manually loaded by the
* same class loader as the caller.
*
* @param url The JDBC URL string to find a driver for.
*
* @return A Driver that can connect to the specified
* URL, or null if a suitable driver cannot be found.
*
* @exception SQLException If an error occurs.
*/
public static Driver getDriver(String url) throws SQLException
{
// FIXME: Limit driver search to the appropriate subset of loaded drivers.
Enumeration e = drivers.elements();
while(e.hasMoreElements())
{
Driver d = (Driver)e.nextElement();
if (d.acceptsURL(url))
return d;
}
return null;
}
/**
* This method registers a new driver with the manager. This is normally
* called by the driver itself in a static initializer.
*
* @param driver The new Driver to add.
*
* @exception SQLException If an error occurs.
*/
public static void registerDriver(Driver driver) throws SQLException
{
if (! drivers.contains(driver))
drivers.addElement(driver);
}
/**
* This method de-registers a driver from the manager.
*
* @param driver The Driver to unregister.
*
* @exception SQLException If an error occurs.
*/
public static void deregisterDriver(Driver driver) throws SQLException
{
if (drivers.contains(driver))
drivers.removeElement(driver);
}
/**
* This method returns a list of all the currently registered JDBC drivers
* that were loaded by the current ClassLoader.
*
* @return An Enumeration of all currently loaded JDBC drivers.
*/
public static Enumeration getDrivers()
{
Vector v = new Vector();
Enumeration e = drivers.elements();
// Is this right?
ClassLoader cl = Thread.currentThread().getContextClassLoader();
while(e.hasMoreElements())
{
Object obj = e.nextElement();
ClassLoader loader = obj.getClass().getClassLoader();
if (loader == null)
loader = ClassLoader.getSystemClassLoader();
if (! loader.equals(cl))
continue;
v.addElement(obj);
}
return v.elements();
}
/**
* This method set the login timeout used by JDBC drivers. This is a
* system-wide parameter that applies to all drivers.
*
* @param login_timeout The new login timeout value.
*/
public static void setLoginTimeout(int seconds)
{
DriverManager.login_timeout = login_timeout;
}
/**
* This method returns the login timeout in use by JDBC drivers systemwide.
*
* @return The login timeout.
*/
public static int getLoginTimeout()
{
return login_timeout;
}
/**
* This method sets the log stream in use by JDBC.
*
* @param log_stream The log stream in use by JDBC.
*
* @deprecated Use setLogWriter instead.
*/
public static void setLogStream(PrintStream out)
{
DriverManager.log_stream = log_stream;
}
/**
* This method returns the log stream in use by JDBC.
*
* @return The log stream in use by JDBC.
*
* @deprecated Use getLogWriter() instead.
*/
public static PrintStream getLogStream()
{
return log_stream;
}
/**
* This method prints the specified line to the log stream.
*
* @param str The string to write to the log stream.
*/
public static void println(String message)
{
if (log_stream != null) // Watch for user not using logging
log_stream.println(message);
}
}