GNU Classpath (0.20) | |
Frames | No Frames |
1: /* DriverManager.java -- Manage JDBC drivers 2: Copyright (C) 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: package java.sql; 39: 40: import java.io.PrintStream; 41: import java.io.PrintWriter; 42: import java.util.Enumeration; 43: import java.util.Properties; 44: import java.util.StringTokenizer; 45: import java.util.Vector; 46: 47: /** 48: * This class manages the JDBC drivers in the system. It maintains a 49: * registry of drivers and locates the appropriate driver to handle a 50: * JDBC database URL. 51: * <p> 52: * On startup, <code>DriverManager</code> loads all the managers specified 53: * by the system property <code>jdbc.drivers</code>. The value of this 54: * property should be a colon separated list of fully qualified driver 55: * class names. Additional drivers can be loaded at any time by 56: * simply loading the driver class with <code>class.forName(String)</code>. 57: * The driver should automatically register itself in a static 58: * initializer. 59: * <p> 60: * The methods in this class are all <code>static</code>. This class 61: * cannot be instantiated. 62: * 63: * @author Aaron M. Renn (arenn@urbanophile.com) 64: */ 65: public class DriverManager 66: { 67: /** 68: * This is the log stream for JDBC drivers. 69: */ 70: private static PrintStream log_stream; 71: 72: /** 73: * This is the log writer for JDBC drivers. 74: */ 75: private static PrintWriter log_writer; 76: 77: /** 78: * This is the login timeout used by JDBC drivers. 79: */ 80: private static int login_timeout; 81: 82: /** 83: * This is the list of JDBC drivers that are loaded. 84: */ 85: private static Vector drivers; 86: // Hmm, seems like we might want to do a Hashtable and lookup by something, 87: // but what would it be? 88: 89: // Load all drivers on startup 90: static 91: { 92: drivers = new Vector(); 93: 94: String driver_string = System.getProperty("jdbc.drivers"); 95: if (driver_string != null) 96: { 97: StringTokenizer st = new StringTokenizer(driver_string); 98: while (st.hasMoreTokens()) 99: { 100: String driver_classname = st.nextToken(); 101: 102: try 103: { 104: Class.forName(driver_classname); // The driver registers itself 105: } 106: catch (Exception e) 107: { 108: // Ignore not founds 109: } 110: } 111: } 112: 113: } 114: 115: /** Can't be instantiated. */ 116: private DriverManager() 117: { 118: } 119: 120: /** 121: * This method returns the log writer being used by all JDBC drivers. 122: * This method should be used in place of the deprecated 123: * <code>getLogStream</code> method. 124: * 125: * @return The log writer in use by JDBC drivers. 126: */ 127: public static PrintWriter getLogWriter() 128: { 129: return log_writer; 130: } 131: 132: /** 133: * This method sets the log writer being used by JDBC drivers. This is a 134: * system-wide parameter that affects all drivers. Note that since there 135: * is no way to retrieve a <code>PrintStream</code> from a 136: * <code>PrintWriter</code>, this method cannot set the log stream in 137: * use by JDBC. Thus any older drivers may not see this setting. 138: * 139: * @param out The new log writer for JDBC. 140: */ 141: public static void setLogWriter(PrintWriter out) 142: { 143: DriverManager.log_writer = out; 144: } 145: 146: /** 147: * This method attempts to return a connection to the specified 148: * JDBC URL string using the specified connection properties. 149: * 150: * @param url The JDBC URL string to connect to. 151: * @param properties The connection properties. 152: * 153: * @return A <code>Connection</code> to that URL. 154: * 155: * @exception SQLException If an error occurs. 156: */ 157: public static Connection getConnection(String url, Properties properties) 158: throws SQLException 159: { 160: Driver d = getDriver(url); 161: if (d == null) 162: throw new SQLException("Driver not found for URL: " + url); 163: 164: return d.connect(url, properties); 165: } 166: 167: 168: /** 169: * This method attempts to return a connection to the specified 170: * JDBC URL string using the specified username and password. 171: * 172: * @param url The JDBC URL string to connect to. 173: * @param user The username to connect with. 174: * @param password The password to connect with. 175: * @return A <code>Connection</code> to that URL. 176: * @exception SQLException If an error occurs. 177: */ 178: public static Connection getConnection(String url, String user, 179: String password) throws SQLException 180: { 181: Properties p = new Properties(); 182: 183: if (user != null) 184: p.setProperty("user", user); 185: if (password != null) 186: p.setProperty("password", password); 187: 188: return getConnection(url, p); 189: } 190: 191: /** 192: * This method attempts to return a connection to the specified 193: * JDBC URL string. 194: * 195: * @param url The JDBC URL string to connect to. 196: * 197: * @return A <code>Connection</code> to that URL. 198: * 199: * @exception SQLException If an error occurs. 200: */ 201: public static Connection getConnection(String url) throws SQLException 202: { 203: return getConnection(url, new Properties()); 204: } 205: 206: /** 207: * This method returns a driver that can connect to the specified 208: * JDBC URL string. This will be selected from among drivers loaded 209: * at initialization time and those drivers manually loaded by the 210: * same class loader as the caller. 211: * 212: * @param url The JDBC URL string to find a driver for. 213: * 214: * @return A <code>Driver</code> that can connect to the specified 215: * URL. 216: * 217: * @exception SQLException If an error occurs, or no suitable driver can be found. 218: */ 219: public static Driver getDriver(String url) throws SQLException 220: { 221: // FIXME: Limit driver search to the appropriate subset of loaded drivers. 222: Enumeration e = drivers.elements(); 223: while(e.hasMoreElements()) 224: { 225: Driver d = (Driver)e.nextElement(); 226: if (d.acceptsURL(url)) 227: return d; 228: } 229: 230: throw new SQLException("No driver found for " + url); 231: } 232: 233: /** 234: * This method registers a new driver with the manager. This is normally 235: * called by the driver itself in a static initializer. 236: * 237: * @param driver The new <code>Driver</code> to add. 238: * 239: * @exception SQLException If an error occurs. 240: */ 241: public static void registerDriver(Driver driver) throws SQLException 242: { 243: if (! drivers.contains(driver)) 244: drivers.addElement(driver); 245: } 246: 247: /** 248: * This method de-registers a driver from the manager. 249: * 250: * @param driver The <code>Driver</code> to unregister. 251: * 252: * @exception SQLException If an error occurs. 253: */ 254: public static void deregisterDriver(Driver driver) throws SQLException 255: { 256: if (drivers.contains(driver)) 257: drivers.removeElement(driver); 258: } 259: 260: /** 261: * This method returns a list of all the currently registered JDBC drivers 262: * that were loaded by the current <code>ClassLoader</code>. 263: * 264: * @return An <code>Enumeration</code> of all currently loaded JDBC drivers. 265: */ 266: public static Enumeration getDrivers() 267: { 268: Vector v = new Vector(); 269: Enumeration e = drivers.elements(); 270: 271: // Is this right? 272: ClassLoader cl = Thread.currentThread().getContextClassLoader(); 273: 274: while(e.hasMoreElements()) 275: { 276: Object obj = e.nextElement(); 277: 278: ClassLoader loader = obj.getClass().getClassLoader(); 279: 280: if (loader == null) 281: loader = ClassLoader.getSystemClassLoader(); 282: if (! loader.equals(cl)) 283: continue; 284: 285: v.addElement(obj); 286: } 287: 288: return v.elements(); 289: } 290: 291: /** 292: * This method set the login timeout used by JDBC drivers. This is a 293: * system-wide parameter that applies to all drivers. 294: * 295: * @param login_timeout The new login timeout value. 296: */ 297: public static void setLoginTimeout(int seconds) 298: { 299: DriverManager.login_timeout = login_timeout; 300: } 301: 302: /** 303: * This method returns the login timeout in use by JDBC drivers systemwide. 304: * 305: * @return The login timeout. 306: */ 307: public static int getLoginTimeout() 308: { 309: return login_timeout; 310: } 311: 312: /** 313: * This method sets the log stream in use by JDBC. 314: * 315: * @param log_stream The log stream in use by JDBC. 316: * 317: * @deprecated Use <code>setLogWriter</code> instead. 318: */ 319: public static void setLogStream(PrintStream out) 320: { 321: DriverManager.log_stream = log_stream; 322: } 323: 324: /** 325: * This method returns the log stream in use by JDBC. 326: * 327: * @return The log stream in use by JDBC. 328: * 329: * @deprecated Use <code>getLogWriter()</code> instead. 330: */ 331: public static PrintStream getLogStream() 332: { 333: return log_stream; 334: } 335: 336: /** 337: * This method prints the specified line to the log stream. 338: * 339: * @param str The string to write to the log stream. 340: */ 341: public static void println(String message) 342: { 343: if (log_stream != null) // Watch for user not using logging 344: log_stream.println(message); 345: } 346: }
GNU Classpath (0.20) |