Java創建連接池連接不同數據庫

在一個應用里面，可能涉及到連接多個不同數據庫進行操作，而每次連接寫不同的實現會很麻煩。前面已經會了用JDBC連接數據庫，那么利用反射和工廠模式，可以實現連接不同的數據庫，這樣處理起來將會很方便。同時建造數據庫連接池，處理多個業務數據處理。

 

 

 

那么具體怎么實現呢，下面一起來看一下：

整體結構如下：

 

第一步，先處理連接不同數據庫

1、首先，將數據庫配置信息創建一個公用類：JdbcUrl.java

主數據庫可以用默認的構造方法，如果是連接其他庫，則通過傳遞參數的方式來處理。

數據庫參數有如下幾個：

 

/**
 * 數據庫連接配置信息類
 * @author Damon
 */
public class JdbcUrl
{

    /** 定義數據庫參數 */

    // 數據庫類型
    private String DBType;
    // 數據庫服務器IP
    private String IP;
    // 數據庫服務器端口
    private String Port;
    // 數據庫名稱
    private String DBName;
    // 用戶名
    private String UserName;
    // 密碼
    private String PassWord;


    /**
     * 默認構造方法，連接默認數據庫
     */
    public JdbcUrl()
    {
        // TODO Auto-generated constructor stub
        DBType = SysCon.DATABASE_TYPE_MYSQL;
        IP = "127.0.0.1";
        DBName = "mysql";
        Port = "3306";
        UserName = "damon";
        PassWord = "damon";
    }

    /**
     * 連接指定數據庫
     * @param urlType 傳入連接類型標識
     */
    public JdbcUrl(String urlType)
    {
        if ("mysql".equals(urlType))
        {
            DBType = SysCon.DATABASE_TYPE_MYSQL;
            IP = "127.0.0.1";
            DBName = "mysql";
            Port = "3306";
            UserName = "damon";
            PassWord = "damon";
        }
    }

    /**
     * 獲取連接句柄
     * @return String
     */
    public String getJdbcUrl()
    {
        String sUrl = "";

        if (DBType.trim().toUpperCase().equals("MYSQL"))
        {
            sUrl = "jdbc:mysql://" + IP + ":" + Port + "/" + DBName;
        }
        else if (DBType.trim().toUpperCase().equals("DB2"))
        {
            sUrl = "jdbc:db2://" + IP + ":" + Port + "/" + DBName;
        }

        else if (DBType.trim().toUpperCase().equals("ORACLE"))
        {
            sUrl = "jdbc:oracle:thin:@" + IP + ":" + Port + ":" + DBName;
        }

        else if (DBType.trim().toUpperCase().equals("SQLSERVER"))
        {
            sUrl = "jdbc:microsoft:sqlserver://" + IP + ":" + Port + ";databaseName=" + DBName + ";selectMethod=cursor";
        }
        else if (DBType.trim().toUpperCase().equals("WEBLOGICPOOL"))
        {
            sUrl = "jdbc:weblogic:pool:" + DBName;
        }
        else
        {
            System.out.println("暫無對應數據庫驅動");
        }
        return sUrl;
    }

    // getters and setters

    public String getDBType()
    {
        return DBType;
    }

    public void setDBType(String dBType)
    {
        DBType = dBType;
    }

    public String getIP()
    {
        return IP;
    }

    public void setIP(String iP)
    {
        IP = iP;
    }

    public String getPort()
    {
        return Port;
    }

    public void setPort(String port)
    {
        Port = port;
    }

    public String getDBName()
    {
        return DBName;
    }

    public void setDBName(String dBName)
    {
        DBName = dBName;
    }

    public String getUserName()
    {
        return UserName;
    }

    public void setUserName(String userName)
    {
        UserName = userName;
    }

    public String getPassWord()
    {
        return PassWord;
    }

    public void setPassWord(String passWord)
    {
        PassWord = passWord;
    }

}

 

2、重寫一個Connection類，實現Connection接口的方法，同時連接數據庫。

參數有已實現的JdbrUrl類，主要新增方法為：createConnection()

根據DBType來對不同數據庫進行處理：加載對應的數據庫，然后獲取數據庫連接。

**
 * 數據庫連接類，連接數據庫
 * @author Damon
 */
public class DBConn implements Connection
{

    // 獲取JdbcUrl信息
    private JdbcUrl JUrl;

    // 數據庫連接
    private Connection con = null;

    // 連接是否已使用
    private boolean bNotInUse;

    private CharArrayWriter m_buf = new CharArrayWriter();

    private PrintWriter m_pw = new PrintWriter(m_buf, true);

    // 默認連接
    public DBConn()
    {
        // TODO Auto-generated constructor stub
        this.JUrl = new JdbcUrl();
    }

    // 指定數據庫連接
    public DBConn(String urlType)
    {
        this.JUrl = new JdbcUrl(urlType);
    }

    // 創建連接
    public boolean createConnection()
    {

        // 根據數據庫類型加載驅動及連接
        try
        {
            // 連接MySQL數據庫
            if (SysCon.DATABASE_TYPE_MYSQL.equals(JUrl.getDBType()))
            {
                // 加載數據庫驅動
                Class.forName("com.mysql.jdbc.Driver");

                // 嘗試連接數據庫
                con = DriverManager.getConnection(JUrl.getJdbcUrl(), JUrl.getUserName(), JUrl.getPassWord());
            }
            // 其他數據庫類型判斷及處理
            // SQLSERVER
            else if (SysCon.DATABASE_TYPE_SQLSERVER.equals(JUrl.getDBType()))
            {
                Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
                con = DriverManager.getConnection(JUrl.getJdbcUrl(), JUrl.getUserName(), JUrl.getPassWord());
            }
            // DB2
            else if (SysCon.DATABASE_TYPE_DB2.equals(JUrl.getDBType()))
            {
                Class.forName("com.ibm.db2.jcc.DB2Driver");
                con = DriverManager.getConnection(JUrl.getJdbcUrl(), JUrl.getUserName(), JUrl.getPassWord());
            }
            // ORACLE
            else if (SysCon.DATABASE_TYPE_ORACLE.equals(JUrl.getDBType()))
            {
                Class.forName("oracle.jdbc.driver.OracleDriver");
                // 一個是緩存取到的記錄數，一個是設置默認的批量提交數
                Properties props = new Properties();
                props.setProperty("user", JUrl.getUserName());
                props.setProperty("password", JUrl.getPassWord());
                props.setProperty("defaultRowPrefetch", "50");
                props.setProperty("defaultExecuteBatch", "50");
                con = DriverManager.getConnection(JUrl.getJdbcUrl(), props);
            }
            else
            {
                System.out.println("未匹配到數據庫類型！");
                return false;
            }

        }
        catch (ClassNotFoundException e)
        {
            // TODO Auto-generated catch block
            System.out.println("加載驅動失敗！");
            e.printStackTrace();
            return false;
        }
        catch (SQLException e)
        {
            // TODO Auto-generated catch block
            System.out.println("創建連接失敗..." + e.getMessage());
            e.printStackTrace();
            return false;
        }
        return true;
    }

    protected void setInUse()
    {
        /**
         * Record stack information when each connection is get We reassian
         * System.err, so Thread.currentThread().dumpStack() can dump stack info
         * into our class FilterPrintStream.
         */
        new Throwable().printStackTrace(m_pw);

        bNotInUse = false;

        /**
         * record lastest access time
         */
    }

    /* 下面都是 實現Connection的方法，返回conn的實現 */
    public <T> T unwrap(Class<T> iface) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.unwrap(null);
    }

    public boolean isWrapperFor(Class<?> iface) throws SQLException
    {
        // TODO Auto-generated method stub
        return false;
    }

    public Statement createStatement() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createStatement();
    }

    public PreparedStatement prepareStatement(String sql) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.prepareStatement(sql);
    }

    public CallableStatement prepareCall(String sql) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.prepareCall(sql);
    }

    public String nativeSQL(String sql) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.nativeSQL(sql);
    }

    public void setAutoCommit(boolean autoCommit) throws SQLException
    {
        // TODO Auto-generated method stub
        con.setAutoCommit(autoCommit);
    }

    public boolean getAutoCommit() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getAutoCommit();
    }

    public void commit() throws SQLException
    {
        // TODO Auto-generated method stub
        con.commit();
    }

    public void rollback() throws SQLException
    {
        // TODO Auto-generated method stub
        con.rollback();
    }

    public void close() throws SQLException
    {
        // TODO Auto-generated method stub
        con.close();
    }

    public boolean isClosed() throws SQLException
    {
        // TODO Auto-generated method stub

        return con.isClosed();
    }

    public DatabaseMetaData getMetaData() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getMetaData();
    }

    public void setReadOnly(boolean readOnly) throws SQLException
    {
        // TODO Auto-generated method stub
        con.setReadOnly(readOnly);
    }

    public boolean isReadOnly() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.isReadOnly();
    }

    public void setCatalog(String catalog) throws SQLException
    {
        // TODO Auto-generated method stub
        con.setCatalog(catalog);
    }

    public String getCatalog() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getCatalog();
    }

    public void setTransactionIsolation(int level) throws SQLException
    {
        // TODO Auto-generated method stub
        con.setTransactionIsolation(level);
    }

    public int getTransactionIsolation() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getTransactionIsolation();
    }

    public SQLWarning getWarnings() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getWarnings();
    }

    public void clearWarnings() throws SQLException
    {
        // TODO Auto-generated method stub
        con.clearWarnings();
    }

    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createStatement(resultSetType, resultSetConcurrency);
    }

    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
            throws SQLException
    {
        // TODO Auto-generated method stub
        return con.prepareStatement(sql, resultSetType, resultSetConcurrency);
    }

    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.prepareCall(sql, resultSetType, resultSetConcurrency);
    }

    public Map<String, Class<?>> getTypeMap() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getTypeMap();
    }

    public void setTypeMap(Map<String, Class<?>> map) throws SQLException
    {
        // TODO Auto-generated method stub
        con.setTypeMap(map);
    }

    public void setHoldability(int holdability) throws SQLException
    {
        // TODO Auto-generated method stub
        con.setHoldability(holdability);
    }

    public int getHoldability() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getHoldability();
    }

    public Savepoint setSavepoint() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.setSavepoint();
    }

    public Savepoint setSavepoint(String name) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.setSavepoint(name);
    }

    public void rollback(Savepoint savepoint) throws SQLException
    {
        // TODO Auto-generated method stub
        con.rollback(savepoint);
    }

    public void releaseSavepoint(Savepoint savepoint) throws SQLException
    {
        // TODO Auto-generated method stub
        con.releaseSavepoint(savepoint);
    }

    public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
            throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
    }

    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
            int resultSetHoldability) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
    }

    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
            int resultSetHoldability) throws SQLException
    {
        // TODO Auto-generated method stub
        return null;
    }

    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.prepareStatement(sql, autoGeneratedKeys);
    }

    public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.prepareStatement(sql, columnIndexes);
    }

    public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.prepareStatement(sql, columnNames);
    }

    public Clob createClob() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createClob();
    }

    public Blob createBlob() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createBlob();
    }

    public NClob createNClob() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createNClob();
    }

    public SQLXML createSQLXML() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createSQLXML();
    }

    public boolean isValid(int timeout) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.isValid(timeout);
    }

    public void setClientInfo(String name, String value) throws SQLClientInfoException
    {
        // TODO Auto-generated method stub
        con.setClientInfo(name, value);
    }

    public void setClientInfo(Properties properties) throws SQLClientInfoException
    {
        // TODO Auto-generated method stub
        con.setClientInfo(properties);
    }

    public String getClientInfo(String name) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getClientInfo(name);
    }

    public Properties getClientInfo() throws SQLException
    {
        // TODO Auto-generated method stub
        return con.getClientInfo();
    }

    public Array createArrayOf(String typeName, Object[] elements) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createArrayOf(typeName, elements);
    }

    public Struct createStruct(String typeName, Object[] attributes) throws SQLException
    {
        // TODO Auto-generated method stub
        return con.createStruct(typeName, attributes);
    }

}

 

3、公共的數據庫連接池

數據庫配置和數據庫連接已經搞定，那么可以建一個數據庫連接池來進行數據庫的連接及處理。

主要有2個方法，連接默認數據庫和連接指定的數據庫。

/**
     * 獲取默認數據庫連接
     * @param uri
     * @return
     */
    public static DBConn getConnection()
    {
        DBConn dbConn = new DBConn();
        if (!dbConn.createConnection())
        {
            // 如果創建連接失敗
            DBSemaphore.unLock();
            return null;
        }

        // 連接成功，設置該連接屬性
        try
        {
            // 特殊處理連接的AutoCommit是否已經被設置
            dbConn.setAutoCommit(true);
            dbConn.setInUse();
            DBSemaphore.unLock();
            return dbConn;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            DBSemaphore.unLock();
            return null;
        }

    }

    /**
     * 通過URI地址獲取指定數據庫連接
     * @param uri
     * @return
     */
    public static DBConn getConnection(String uri)
    {
        DBConn dbConn = new DBConn(uri);
        if (!dbConn.createConnection())
        {
            // 如果創建連接失敗
            // DBSemaphore.UnLock();
            return null;
        }
        try
        {
            // 特殊處理連接的AutoCommit是否已經被設置
            dbConn.setAutoCommit(true);
            // dbConn.setInUse();
            // DBSemaphore.UnLock();
            return dbConn;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            // DBSemaphore.UnLock();
            return null;
        }

    }

 

可以寫一個測試方式，這也數據庫連接就完成了，通過傳入不同的參數就可以獲取到不同數據庫的連接了。

 

    public static void main(String[] args)
    {
        // 測試連接池

        // 1、連接mysql 數據庫
        Connection conn = DBConnPool.getConnection();

        if (conn == null)
        {
            System.out.println("獲取連接失敗！");
        }
        else
        {
            System.out.println("獲取連接成功");
        }

    }

 

第二步，構建數據庫連接池

前面已經實現連接不同數據庫，那么怎么處理為連接池呢？

數據庫連接池負責分配、管理和釋放數據庫連接，它允許應用程序重復使用一個現有的數據庫連接，而不是再重新建立一個；釋放空閑時間超過最大空閑時間的數據庫連接來避免因為沒有釋放數據庫連接而引起的數據庫連接遺漏。這項技術能明顯提高對數據庫操作的性能。下面我們就來實現數據庫連接池的功能：

 

數據庫連接池的實現思想主要有如下幾個方面：

1、可定義最大和最小的連接數：如果請求小於最小連接數，則直接分配連接，達到最大連接數則新請求等待；

2、用戶在連接數據庫時，不用新建連接，而是直接從連接池中獲取連接，使用完畢后也不用關閉，而是釋放給連接池，供下一個用戶使用；

下面來進行實現：

其實就是實現了一個數據連接數的判斷，最大連接數進行限制，實際的數據庫連接池需結合對應的數據庫連接池組件（比如 WebSphere等中間件），在判斷是否有連接在使用的時候，會涉及到並發，這里需要用到volatile關鍵字。

 

其中，增加了DBsemaphor類，用以處理連接的使用和釋放。

在原有DBConn基礎上，加上是否已使用方法，在獲取連接成功時調用，具體代碼如下：

 

// 連接成功，設置該連接屬性
        try
        {
            // 特殊處理連接的AutoCommit是否已經被設置
            dbConn.setAutoCommit(true);
            dbConn.setInUse();
            DBSemaphore.unLock();
            return dbConn;
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            DBSemaphore.unLock();
            return null;
        }

新增DBSemaphore類屬性及方法如下：

/**
 * 數據庫同步對象
 * @author Damon
 */
public class DBSemaphore
{
    private static volatile boolean m_bInUse = false;

    public DBSemaphore()
    {}

    /**
     * 設置"使用標志"。 傳入true表示請求“使用標志”，傳入false表示釋放“使用標志”。
     * @param bNewValue boolean
     * @return boolean
     */
    protected static synchronized boolean setInUseFlag(boolean bNewValue)
    {
        if (bNewValue == true)
        {
            // 請求“使用標志”
            if (m_bInUse == true)
            {
                // “使用標志”已經被占用
                return false;
            }
            else
            {
                m_bInUse = true;
                return true;
            }
        }
        else
        {
            // 釋放“使用標志”
            m_bInUse = false;
            return true;
        }
    }

    protected static void lock() throws Exception
    {
        lock(0);
    }

    protected static void lock(int nSeconds) throws Exception
    {
        if (nSeconds <= 0)
        {
            while (!setInUseFlag(true))
            {
                Thread.sleep(100);
            }
        }
        else
        {
            while (!setInUseFlag(true) && nSeconds-- > 0)
            {
                Thread.sleep(100);
            }

            if (nSeconds == 0)
            {
                throw new Exception("Lock time out");
            }
        }
    }

    protected static void unLock()
    {
        setInUseFlag(false);
    }
}

 

到這里，整個配置處理結束了，更多的就需要在實際項目中發揮了~