dbmanager.java

数据刷新程序,用于不同数据库之间德数据传递

package com.main.apps.dbmanage;

import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;

import com.main.apps.common.FileUtil;
 
public class DBManager
{
    static private DBManager instance; // The single instance

    static private int clients;

    private String logFile;

    private Vector drivers = new Vector();

    private Hashtable pools = new Hashtable();

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

    public int getAccessNum()
    {
        return clients;
    }

    public String getLogFile()
    {
        return logFile;
    }

    public int getUsedConNum(String poolName)
    {
        DBConnectionPool pool = (DBConnectionPool) pools.get(poolName);
        int size = 0;
        if (pool != null)
        {
            size = pool.getUsedConNum();
        }
        pool = null;
        return size;
    }

    public int getFreeConNum(String poolName)
    {
        DBConnectionPool pool = (DBConnectionPool) pools.get(poolName);
        int size = 0;
        if (pool != null)
        {
            size = pool.getFreeConNum();
        }
        pool = null;
        return size;
    }

    public String[] getPoolName()
    {
        Enumeration names = pools.keys();
        String[] nameList = new String[pools.size()];
        int i = 0;
        while (names.hasMoreElements())
        {
            nameList[i++] = (String) names.nextElement();
        }
        return nameList;
    }

    /**
     * A private constructor since this is a Singleton
     */
    private DBManager()
    {
        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);
        }
        pool = 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.
     * @param name The pool name as defined in the properties file
     * @return Connection The connection or null
     */
    public java.sql.Connection getConnection(String name)
    {
        DBConnectionPool pool = (DBConnectionPool) pools.get(name);
        if (pool != null)
        {
            return pool.getConnection();
        }
        pool = null;
        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 java.sql.Connection getConnection(String name, long time)
    {

        DBConnectionPool pool = (DBConnectionPool) pools.get(name);
        if (pool != null)
        {
            return pool.getConnection(time);
        }
        pool = null;
        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;
        }
        Enumeration allPools = pools.elements();
        while (allPools.hasMoreElements())
        {
            DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
            pool.release();
        }
        Enumeration allDrivers = drivers.elements();
        while (allDrivers.hasMoreElements())
        {
            Driver driver = (Driver) allDrivers.nextElement();
            try
            {
                DriverManager.deregisterDriver(driver);
                FileUtil.printEvent("Deregistered JDBC driver "
                        + driver.getClass().getName(), logFile);
            }
            catch (SQLException e)
            {
                FileUtil.printEvent("Can't deregister JDBC driver: "
                        + driver.getClass().getName() + " Exception:"
                        + e.getMessage(), logFile);
            }
        }
    }

    /**
     * Creates instances of DBConnectionPool based on the properties. A
     * DBConnectionPool can be defined with the following properties:
     * 
     * <PRE>
     * 
     * &lt;poolname&gt;.url The JDBC URL for the database &lt;poolname&gt;.user
     * A database user (optional) &lt;poolname&gt;.passwordA database user
     * password (if user specified) &lt;poolname&gt;.maxconn The maximal number
     * of connections (optional)
     * 
     * </PRE>
     * 
     * @param props The connection pool properties
     */
    private void createPools(Properties props)
    {
        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)
                {
                    FileUtil.printEvent("No URL specified for " + poolName, logFile);
                    continue;
                }
                String user = props.getProperty(poolName + ".user");
                String password = props.getProperty(poolName + ".password");
                String maxconn = props.getProperty(poolName + ".maxconn", "3");
                String minconn = props.getProperty(poolName + ".minconn", "1");
                String defconn = props.getProperty(poolName + ".defconn", "2");
                int max, min, def;
                try
                {
                    max = Integer.valueOf(maxconn.trim()).intValue();
                    min = Integer.valueOf(minconn.trim()).intValue();
                    def = Integer.valueOf(defconn.trim()).intValue();
                }
                catch (Exception e)
                {
                    FileUtil.printEvent("Invalid maxconn value " + maxconn + " for "
                            + poolName, logFile);
                    FileUtil.printEvent("Invalid minconn value " + minconn + " for "
                            + poolName, logFile);
                    FileUtil.printEvent("Invalid minconn value " + defconn + " for "
                            + poolName, logFile);
                    max = 3;
                    min = 1;
                    def = 2;
                }
                DBConnectionPool pool = new DBConnectionPool(poolName, url
                        .trim(), user, password, max, min, def);
                pools.put(poolName, pool);
                FileUtil.printEvent("Initialized pool " + poolName, logFile);
            }
        }
    }

    /**
     * Loads properties and initializes the instance with its values.
     */
    private void init()
    {
        FileInputStream is = null;
        try
        {
            if (System.getProperty("file.separator").equals("/"))
                is = new FileInputStream("./parameter/db.properties");
            else
                is = new FileInputStream(".\\parameter\\db.properties");
        }
        catch (FileNotFoundException e)
        {
            System.out.println("File db.properties not found");
        }
        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;
        }
        logFile = dbProps.getProperty("logFile", "DBConnectionManager.log");
        loadDrivers(dbProps);
        createPools(dbProps);
    }

    /**
     * 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(Properties props)
    {
        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)