一个Oracle数据库链接的JavaBean实例

　　public class OracleConnectionManager {

　　private DBConnectionManager connMgr;
　　private final String poolName="Oracle";
　　private Connection conn;

　　public OracleConnectionManager() {

　　String userID = "system";
　　String password = "manager";
　　String JDBCDriver = "oracle.jdbc.driver.OracleDriver";
　　String JDBCDriverType = "jdbc:oracle:thin";
　　String DBHost = "127.0.0.1";
　　String Port = "1521";
　　String SID="sid";
　　String url = JDBCDriverType+":@"+DBHost + ":" + Port + ":" +SID;

　　connMgr = DBConnectionManager.getInstance();
　　if (DBConnectionManager.clients == 1){
　　connMgr.init(poolName, JDBCDriver, url, userID, password);
　　connMgr.init("egongOracle", JDBCDriver, JDBCDriverType+":@110.7.6.22:1521:egong", "abcusername", "abcpasswd");

　　}
　　}

　　public Connection getConnection() {
　　return (conn=connMgr.getConnection(poolName));
　　}

　　public Connection getConnection(String newOracle) {
　　return (conn=connMgr.getConnection(newOracle));
　　}

　　public void freeConnection() {
　　connMgr.freeConnection(poolName,conn);
　　}

　　public void freeConnection(String newOracle) {
　　connMgr.freeConnection(newOracle,conn);
　　}

　　}

　　public class DBConnectionManager {
　　static private DBConnectionManager instance=null; // The single instance
　　static public int clients=0;

　　private Vector drivers = new Vector();
　　private PrintWriter log;
　　private Hashtable pools = new Hashtable();
　　private final int MAX_CONN = 1000;

　　/**
　　* Returns the single instance, creating one if it´s the
　　* first time this method is called.
　　*
　　* @return DBConnectionManager The single instance.
　　*/
　　static synchronized public DBConnectionManager getInstance() {
　　if (instance == null) {
　　instance = new DBConnectionManager();
　　}
　　clients++;
　　return instance;
　　}

　　/**
　　* A private constructor since this is a Singleton
　　*/
　　private DBConnectionManager() {
　　// init();
　　}

　　/**
　　* Returns a connection to the named pool.
　　*
　　* @param name The pool name as defined in the properties file
　　* @param con The Connection
　　*/
　　public void freeConnection(String name, Connection con) {
　　DBConnectionPool pool = (DBConnectionPool) pools.get(name);
　　if (pool != null) {
　　pool.freeConnection(con);
　　}
　　}

　　/**
　　* Returns an open connection. If no one is available, and the max
　　* number of connections has not been reached, a new connection is
　　* created.
　　*
　　* @param name The pool name as defined in the properties file
　　* @return Connection The connection or null
　　*/
　　public Connection getConnection(String name) {
　　DBConnectionPool pool = (DBConnectionPool) pools.get(name);
　　if (pool != null) {
　　return pool.getConnection();
　　}
　　return null;
　　}

　　/**
　　* Returns an open connection. If no one is available, and the max
　　* number of connections has not been reached, a new connection is
　　* created. If the max number has been reached, waits until one
　　* is available or the specified time has elapsed.
　　*
　　* @param name The pool name as defined in the properties file
　　* @param time The number of milliseconds to wait
　　* @return Connection The connection or null
　　*/
　　public Connection getConnection(String name, long time) {
　　DBConnectionPool pool = (DBConnectionPool) pools.get(name);
　　if (pool != null) {
　　return pool.getConnection(time);
　　}
　　return null;
　　}

　　/**
　　* Closes all open connections and dereGISters all drivers.
　　*/
　　public synchronized void release() {
　　// Wait until called by the last client
　　if (--clients != 0) {
　　return;
　　}

　　/**
　　* Creates instances of DBConnectionPool based on the properties.
　　* A DBConnectionPool can be defined with the following properties:
　　* <PRE>
　　* <poolname>.url The JDBC URL for the database
　　* <poolname>.user A database user (optional)
　　* <poolname>.password A database user password (if user specified)
　　* <poolname>.maxconn The maximal number of connections (optional)
　　* </PRE>
　　*
　　* @param props The connection pool properties
　　*/
　　private void createPools(String poolName, String url, String user, String password, int max) {
　　/*
　　Enumeration propNames = props.propertyNames();
　　while (propNames.hasMoreElements()) {
　　String name = (String) propNames.nextElement();
　　if (name.endsWith(".url")) {
　　String poolName = name.substring(0, name.lastIndexOf("."));
　　String url = props.getProperty(poolName + ".url");
　　if (url == null) {
　　log("No URL specified for " + poolName);
　　continue;
　　}
　　String user = props.getProperty(poolName + ".user");
　　String password = props.getProperty(poolName + ".password");
　　String maxconn = props.getProperty(poolName + ".maxconn", "0");
　　int max;
　　try {
　　max = Integer.valueOf(maxconn).intValue();
　　}
　　catch (NumberFormatException e) {
　　log("Invalid maxconn value " + maxconn + " for " + poolName);
　　max = 0;
　　}
　　DBConnectionPool pool =
　　new DBConnectionPool(poolName, url, user, password, max);
　　pools.put(poolName, pool);
　　log("Initialized pool " + poolName);
　　}
　　}
　　*/
　　DBConnectionPool pool =
　　new DBConnectionPool(poolName, url, user, password, max);
　　pools.put(poolName, pool);
　　log("Initialized pool " + poolName);
　　}

　　public void init(String poolName, String driver, String url, String user, String passwd) {
　　init(poolName, driver, url, user, passwd, MAX_CONN);
　　}

　　/**
　　* Loads properties and initializes the instance with its values.
　　*/
　　public void init(String poolName, String driver, String url, String user, String passwd, int maxconn) {
　　/*
　　InputStream is = getClass().getResourceAsStream("/db.properties");
　　Properties dbProps = new Properties();
　　try {
　　dbProps.load(is);
　　}
　　catch (Exception e) {
　　System.err.println("Can´t read the properties file. " +
　　"Make sure db.properties is in the CLASSPATH");
　　return;
　　}
　　String logFile = dbProps.getProperty("logfile", "DBConnectionManager.log");

　　String logFile = "." + File.separator + "logs" + File.separator + "dbpool";
　　try {
　　log = new PrintWriter(new FileWriter(logFile, true), true);
　　}
　　catch (IOException e) {
　　System.err.println("Can´t open the log file: " + logFile);
　　log = new PrintWriter(System.err);
　　}
　　*/
　　log = new PrintWriter(System.err);
　　loadDrivers(driver);
　　createPools(poolName, url, user, passwd, maxconn);
　　}

　　/**
　　* Loads and registers all JDBC drivers. This is done by the
　　* DBConnectionManager, as opposed to the DBConnectionPool,
　　* since many pools may share the same driver.
　　*
　　* @param props The connection pool properties
　　*/
　　private void loadDrivers(String driverClassName) {
　　/*
　　String driverClasses = props.getProperty("drivers");
　　StringTokenizer st = new StringTokenizer(driverClasses);
　　while (st.hasMoreElements()) {
　　String driverClassName = st.nextToken().trim();
　　try {
　　Driver driver = (Driver)
　　Class.forName(driverClassName).newInstance();
　　DriverManager.registerDriver(driver);
　　drivers.addElement(driver);
　　log("Registered JDBC driver " + driverClassName);
　　}
　　catch (Exception e) {
　　log("Can´t register JDBC driver: " +
　　driverClassName + ", Exception: " + e);
　　}
　　}
　　*/
　　try {
　　Driver driver = (Driver)
　　Class.forName(driverClassName).newInstance();
　　DriverManager.registerDriver(driver);
　　drivers.addElement(driver);
　　log("Registered JDBC driver " + driverClassName);
　　}
　　catch (Exception e) {
　　log("Can´t register JDBC driver: " +
　　driverClassName + ", Exception: " + e);
　　}
　　}

　　/**
　　* Writes a message to the log file.
　　*/
　　private void log(String msg) {
　　log.println(new Date() + ": " + msg);
　　}

　　/**
　　* Writes a message with an Exception to the log file.
　　*/
　　private void log(Throwable e, String msg) {
　　log.println(new Date() + ": " + msg);
　　e.printStackTrace(log);
　　}

　　/**
　　* Creates new connection pool.
　　*
　　* @param name The pool name
　　* @param URL The JDBC URL for the database
　　* @param user The database user, or null
　　* @param password The database user password, or null
　　* @param maxConn The maximal number of connections, or 0
　　* for no limit
　　*/
　　public DBConnectionPool(String name, String URL, String user, String password,
　　int maxConn) {
　　this.name = name;
　　this.URL = URL;
　　this.user = user;
　　this.password = password;
　　this.maxConn = maxConn;
　　}

　　/**
　　* Checks in a connection to the pool. Notify other Threads that
　　* may be waiting for a connection.
　　*
　　* @param con The connection to check in
　　*/
　　public synchronized void freeConnection(Connection con) {
　　// Put the connection at the end of the Vector
　　freeConnections.addElement(con);
　　checkedOut--;
　　notifyAll();
　　}

　　/**
　　* Checks out a connection from the pool. If no free connection
　　* is available, a new connection is created unless the max
　　* number of connections has been reached. If a free connection
　　* has been closed by the database, it´s removed from the pool
　　* and this method is called again recursively.
　　*/
　　public synchronized Connection getConnection() {
　　Connection con = null;
　　if (freeConnections.size() > 0) {
　　// Pick the first Connection in the Vector
　　// to get round-robin usage
　　con = (Connection) freeConnections.firstElement();
　　freeConnections.removeElementAt(0);
　　try {
　　if (con.isClosed()) {
　　log("Removed bad connection from " + name);
　　// Try again recursively
　　con = getConnection();
　　}
　　}
　　catch (SQLException e) {
　　log("Removed bad connection from " + name);
　　// Try again recursively
　　con = getConnection();
　　}
　　}
　　else if (maxConn == 0 || checkedOut < maxConn) {
　　con = newConnection();
　　}
　　if (con != null) {
　　checkedOut++;
　　}
　　return con;
　　}

　　/**
　　* Checks out a connection from the pool. If no free connection
　　* is available, a new connection is created unless the max
　　* number of connections has been reached. If a free connection
　　* has been closed by the database, it´s removed from the pool
　　* and this method is called again recursively.
　　* <P>
　　* If no connection is available and the max number has been
　　* reached, this method waits the specified time for one to be
　　* checked in.
　　*
　　* @param timeout The timeout value in milliseconds
　　*/
　　public synchronized Connection getConnection(long timeout) {
　　long startTime = new Date().getTime();
　　Connection con;
　　while ((con = getConnection()) == null) {
　　try {
　　wait(timeout);
　　}
　　catch (InterruptedException e) {}
　　if ((new Date().getTime() - startTime) >= timeout) {
　　// Timeout has expired
　　return null;
　　}
　　}
　　return con;
　　}

　　/**
　　* Closes all available connections.
　　*/
　　public synchronized void release() {
　　Enumeration allConnections = freeConnections.elements();
　　while (allConnections.hasMoreElements()) {
　　Connection con = (Connection) allConnections.nextElement();
　　try {
　　con.close();
　　log("Closed connection for pool " + name);
　　}
　　catch (SQLException e) {
　　log(e, "Can´t close connection for pool " + name);
　　}
　　}
　　freeConnections.removeAllElements();
　　}

　　/**
　　* Creates a new connection, using a userid and password
　　* if specified.
　　*/
　　private Connection newConnection() {
　　Connection con = null;
　　try {
　　if (user == null) {
　　con = DriverManager.getConnection(URL);
　　}
　　else {
　　con = DriverManager.getConnection(URL, user, password);
　　}
　　log("Created a new connection in pool " + name);
　　}
　　catch (SQLException e) {
　　log(e, "Can´t create a new connection for " + URL);
　　return null;
　　}
　　return con;
　　}
　　}
　　}