dbmanager.java

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

                        .newInstance();
                DriverManager.registerDriver(driver);
                drivers.addElement(driver);
                FileUtil.printEvent("Registered JDBC driver " + driverClassName,
                        logFile);
            }
            catch (Exception e)
            {
                FileUtil.printEvent("Can't register JDBC driver: " + driverClassName
                        + ", Exception: " + e, logFile);
            }
        }
    }

    /**
     * This inner class represents a connection pool. It creates new connections
     * on demand, up to a max number if specified. It also makes sure a
     * connection is still open before it is returned to a client.
     */
    class DBConnectionPool
    {
        private int checkedOut; //已用连接数

        private Vector freeConnections = new Vector(); //可用连接数

        private int maxConn; //最大连接数

        private int minConn; //最小连接数

        private int defaultConn; //默认连接数

        private String name; //数据库名称

        private String password; //登陆密码

        private String URL; //数据库路径

        private String user; //用户名称

        public int getUsedConNum()
        {
            return checkedOut;
        }

        public int getFreeConNum()
        {
            return freeConnections.size();
        }

        /**
         * 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, int minConn, int defaultConn)
        {
            this.name = name;
            this.URL = URL;
            this.user = user;
            this.password = password;
            this.maxConn = maxConn;
            this.minConn = minConn;
            this.defaultConn = defaultConn;
            initConnections();
        }

        /**
         * 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
            int free = freeConnections.size();
            if (con == null
                    || ((checkedOut + free > maxConn) && (free >= minConn)))
            {
                try
                {
                    if (con != null)
                    {
                        con.close();
                        FileUtil.printEvent("Closed connection for pool " + name,
                                logFile);
                    }
                    else
                        FileUtil.printEvent("Thread Name :"
                                + Thread.currentThread().getName()
                                + " Closed Connecion is null " + name, logFile);
                }
                catch (SQLException e)
                {
                    FileUtil.printEvent("Can't close connection for pool " + name
                            + " Exception :" + e, logFile);
                }
            }
            else
            {
                Statement stmt = null;
                try
                {
                    if (!con.getAutoCommit())
                        con.setAutoCommit(true);
                    stmt = con.createStatement();
                    stmt.close();
                    freeConnections.addElement(con);
                }
                catch (Exception e)
                {
                    if (stmt != null)
                    {
                        try
                        {
                            stmt.close();
                            con.close();
                        }
                        catch (SQLException ex)
                        {
                        }
                    }
                }
            }
            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 java.sql.Connection getConnection()
        {
            java.sql.Connection con = null;
            if (freeConnections.size() > 0)
            {
                con = (java.sql.Connection) freeConnections.firstElement();
                freeConnections.removeElementAt(0);
                Statement stmt = null;
                try
                {

                    if (con == null || con.isClosed())
                    {
                        FileUtil.printEvent("Removed bad connection from 1 in:"
                                + Thread.currentThread().getName(), logFile);

                        con = getConnection();
                    }
                    else
                    {
                        stmt = con.createStatement();
                        stmt.close();
                    }
                }
                catch (SQLException e)
                {
                    FileUtil.printEvent("Removed bad connection from 2 in:"
                            + Thread.currentThread().getName(), logFile);
                    if (stmt != null)
                    {
                        try
                        {
                            stmt.close();
                            con.close();
                        }
                        catch (SQLException ex)
                        {
                        }
                    }
                    con = getConnection();
                }
            }
            else if (maxConn == 0 || checkedOut < maxConn)
            { //如果maxCon为零则可无限增大

                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 java.sql.Connection getConnection(long timeout)
        {
            long startTime = new Date().getTime();
            java.sql.Connection con;
            while ((con = getConnection()) == null)
            {
                try
                {
                    wait(timeout); //有notifyAll()唤醒或时间到自动唤醒
                }
                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())
            {
                java.sql.Connection con = (java.sql.Connection) allConnections
                        .nextElement();
                try
                {
                    con.close();
                    FileUtil.printEvent("Closed connection for pool " + name,
                            logFile);
                }
                catch (SQLException e)
                {
                    FileUtil.printEvent("Can't close connection for pool " + name
                            + " Exception :" + e, logFile);
                }
            }
            freeConnections.removeAllElements();
        }

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

        private void initConnections()
        {
            java.sql.Connection con = null;
            for (int i = 0; i < defaultConn; i++)
            {
                con = newConnection();
                freeConnections.addElement(con);
            }
        }
    }
}