Java中幾種常用數據庫連接池的使用
用戶每次請求都需要向數據庫獲得鏈接，而數據庫創建連接通常需要消耗相對較大的資源，創建時間也較長。假設網站一天10萬訪問量，數據庫服務器就需要創建10萬次連接，極大的浪費數據庫的資源，并且極易造成數據庫服務器內存溢出、拓機。如下圖所示：
數據庫連接是一種關鍵的有限的昂貴的資源,這一點在多用戶的網頁應用程序中體現的尤為突出.對數據庫連接的管理能顯著影響到整個應用程序的伸縮性和健壯性,影響到程序的性能指標.數據庫連接池正式針對這個問題提出來的.數據庫連接池負責分配,管理和釋放數據庫連接,它允許應用程序重復使用一個現有的數據庫連接,而不是重新建立一個。如下圖所示：
數據庫連接池在初始化時將創建一定數量的數據庫連接放到連接池中, 這些數據庫連接的數量是由最小數據庫連接數來設定的.無論這些數據庫連接是否被使用,連接池都將一直保證至少擁有這么多的連接數量.連接池的最大數據庫連接數量限定了這個連接池能占有的最大連接數,當應用程序向連接池請求的連接數超過最大連接數量時,這些請求將被加入到等待隊列中.
數據庫連接池的最小連接數和最大連接數的設置要考慮到以下幾個因素:
最小連接數:是連接池一直保持的數據庫連接,所以如果應用程序對數據庫連接的使用量不大,將會有大量的數據庫連接資源被浪費. 最大連接數:是連接池能申請的最大連接數,如果數據庫連接請求超過次數,后面的數據庫連接請求將被加入到等待隊列中,這會影響以后的數據庫操作 如果最小連接數與最大連接數相差很大:那么最先連接請求將會獲利,之后超過最小連接數量的連接請求等價于建立一個新的數據庫連接.不過,這些大于最小連接數的數據庫連接在使用完不會馬上被釋放,他將被放到連接池中等待重復使用或是空間超時后被釋放.2.2、編寫數據庫連接池編寫連接池需實現java.sql.DataSource接口。DataSource接口中定義了兩個重載的getConnection方法：
Connection getConnection() Connection getConnection(String username, String password)實現DataSource接口，并實現連接池功能的步驟：
在DataSource構造函數中批量創建與數據庫的連接，并把創建的連接加入LinkedList對象中。 實現getConnection方法，讓getConnection方法每次調用時，從LinkedList中取一個Connection返回給用戶。 當用戶使用完Connection，調用Connection.close()方法時，Collection對象應保證將自己返回到LinkedList中,而不要把conn還給數據庫。Collection保證將自己返回到LinkedList中是此處編程的難點。數據庫連接池核心代碼
使用動態代理技術構建連接池中的connection
JdbcPool.java:
大致思路：1、讀取配置文件，將屬性值取出
2、注冊jdbc驅動
3、通過數據庫連接數和驅動管理器獲得相應連接（.getConnection()）,因為DataSource是接口，所以這個方法需要 我們手動實現
4、重點：實現getConnection()方法
思考：當外部有連接需求時，直接從connectList拿出一個connect，就實現了這個方法，但是我們再想想，它用完了怎么回收呢，確實，有close()方法，但是這個方法作用是將這個連接還給數據庫，而不是數據庫連接池，這樣會導致數據庫連接池中 的連接越來越少，這樣可不行，但是我們也不能影響它的正常使用吧，在這種情況下，我們想要監測這個連接對象的動態，在它調用close()方法時，我們將其再添加進connectList,這樣連接池中的連接不就沒少了嗎，在java中對于監聽一個對象的動態，最常用也最實用的便是動態代理，對于動態代理，其實我們可以把它想象成就是一個大盒子，里面裝著一個真實對象小盒子，這就在大盒子和小盒子間形成了一個橫切空隙，而真實做事的還是這個對象，代理只是個接活的，接到活就給內部的小盒子干，自然這個空隙可以用來監測真實對象的事務，也就是監聽對象的方法。具體可以看看這個，動態代理：https://www.jb51.net/article/213416.htm
package jdbcPoolTest; import java.io.IOException;import java.io.InputStream;import java.io.PrintWriter;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.sql.SQLFeatureNotSupportedException;import java.util.LinkedList;import java.util.Properties;import java.util.logging.Logger; import javax.sql.DataSource; import org.omg.PortableServer.POA; public class JdbcPool implements DataSource{private static LinkedList<Connection> listConnections = new LinkedList<>();static {//靜態代碼塊中加載db.properties配置文件InputStream in = JdbcPool.class.getClassLoader().getResourceAsStream('db.properties');Properties prop = new Properties();try {//讀取文件內容prop.load(in);String driver = prop.getProperty('driver');String url = prop.getProperty('url');String username = prop.getProperty('username');String password = prop.getProperty('password');//數據庫連接池的初始化連接大小int jdbcPoolInitSize = Integer.parseInt(prop.getProperty('jdbcPoolInitSize'));//加載數據庫驅動Class.forName(driver);for(int i=0; i<jdbcPoolInitSize; i++) {//獲取連接Connection conn = DriverManager.getConnection(url, username, password);System.out.println('獲取連接：'+conn);//將conn連接加入listConnections集合中，此時的listConnections就是一個連接池listConnections.add(conn);}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}catch (ClassNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}} @Overridepublic Connection getConnection() throws SQLException {// TODO Auto-generated method stub//如果數據庫連接池的連接數大于0System.out.println('進來了');if (listConnections.size()>0) {//從listConnections中獲取一個連接final Connection conn = listConnections.removeFirst();System.out.println('數據庫連接池的大小為：'+listConnections.size());//返回Connection的代理，利用代理可以處理一些橫切事件System.out.println('取出的連接為：'+conn);return (Connection) Proxy.newProxyInstance(JdbcPool.class.getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// TODO Auto-generated method stub//如果不是執行關閉操作，則通過反射執行相應方法if (!method.getName().equals('close')) {return method.invoke(conn, args);}else {//否則，將conn歸還給連接池listConnections.add(conn);System.out.println('歸還連接：'+conn);System.out.println('連接池大小為：'+listConnections.size());return null;}}});}else {throw new RuntimeException('對不起，數據庫正忙');}}@Overridepublic PrintWriter getLogWriter() throws SQLException {// TODO Auto-generated method stubreturn null;} @Overridepublic int getLoginTimeout() throws SQLException {// TODO Auto-generated method stubreturn 0;} @Overridepublic Logger getParentLogger() throws SQLFeatureNotSupportedException {// TODO Auto-generated method stubreturn null;} @Overridepublic void setLogWriter(PrintWriter arg0) throws SQLException {// TODO Auto-generated method stub} @Overridepublic void setLoginTimeout(int arg0) throws SQLException {// TODO Auto-generated method stub} @Overridepublic boolean isWrapperFor(Class<?> arg0) throws SQLException {// TODO Auto-generated method stubreturn false;} @Overridepublic <T> T unwrap(Class<T> arg0) throws SQLException {// TODO Auto-generated method stubreturn null;} @Overridepublic Connection getConnection(String username, String password) throws SQLException {// TODO Auto-generated method stubreturn null;} }
寫一個JdbcUtil測試數據庫連接池
package jdbcPoolTest; import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement; public class JdbcUtil { private static JdbcPool jdbcPool = new JdbcPool();public static Connection getConnection() throws SQLException {return jdbcPool.getConnection();}//釋放的資源包括Connection數據庫連接對象，負責執行SQL命令的Statement對象，存儲查詢結果的ResultSet對象public static void release(Connection conn,Statement st ,ResultSet rs) {if (conn!=null) {try {conn.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if (st!=null) {try {st.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if (rs!=null) {try {rs.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}rs = null;}}}
db.properties配置文件如下：
driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/student username=root password=123456 jdbcPoolInitSize=10三、開源數據庫連接池
現在很多WEB服務器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的實現，即連接池的實現。通常我們把DataSource的實現，按其英文含義稱之為數據源，數據源中都包含了數據庫連接池的實現。也有一些開源組織提供了數據源的獨立實現：
DBCP 數據庫連接池 C3P0 數據庫連接池在使用了數據庫連接池之后，在項目的實際開發中就不需要編寫連接數據庫的代碼了，直接從數據源獲得數據庫的連接。
3.1、DBCP數據源DBCP 是 Apache 軟件基金組織下的開源連接池實現，要使用DBCP數據源，需要應用程序應在系統中增加如下兩個 jar 文件：
Commons-dbcp.jar：連接池的實現 Commons-pool.jar：連接池實現的依賴庫Tomcat 的連接池正是采用該連接池來實現的。該數據庫連接池既可以與應用服務器整合使用，也可由應用程序獨立使用。
3.2、在應用程序中加入dbcp連接池1.導入相關jar包 commons-dbcp-1.2.2.jar、commons-pool.jar、common-logging.jar三個包2、在類目錄下加入dbcp的配置文件：dbcpconfig.properties
用了官方的連接池，自然配置文件內容也就多了
dbcpconfig.properties的配置信息如下：
注意這段：
#driver default 指定由連接池所創建的連接的只讀（read-only）狀態。 #如果沒有設置該值，則“setReadOnly”方法將不被調用。（某些驅動并不支持只讀模式，如：Informix） defaultReadOnly=
如果設置為ture,那就只能進行查詢操作
#連接設置 報錯com.mysql.jdbc.Connection.isValid(I)Z,更新mysql包driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/student username=root password=123456 #初始化連接池大小 jdbcPoolInitSize=10 #最大連接數量 maxActive=50 #<!-- 最大空閑連接 --> maxIdle=20 #<!-- 最小空閑連接 --> minIdle=5 #<!-- 超時等待時間以毫秒為單位 6000毫秒/1000等于60秒 --> maxWait=60000 #JDBC驅動建立連接時附帶的連接屬性的格式必須為這樣：[屬性名=property;] #注意：'user' 與 'password' 兩個屬性會被明確地傳遞，因此這里不需要包含他們。 connectionProperties=useUnicode=true;characterEncoding=UTF8 #指定由連接池所創建的連接的自動提交（auto-commit）狀態。 defaultAutoCommit=true #driver default 指定由連接池所創建的連接的只讀（read-only）狀態。 #如果沒有設置該值，則“setReadOnly”方法將不被調用。（某些驅動并不支持只讀模式，如：Informix） defaultReadOnly= #driver default 指定由連接池所創建的連接的事務級別（TransactionIsolation）。 #可用值為下列之一：（詳情可見javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE defaultTransactionIsolation=READ_UNCOMMITTED
包結構：
jdbcUtils_DBCP：
大致思路：
1、從配置文件中獲取輸入流，進行加載
2、有了BasicDataSoureFactory,那我們也不需要將配置文件中的屬性值一個一個讀取出來了，它有個方法createDataSource（）能自動獲取到數據源
3、接下來只需要拿著這個數據源對象ds去獲取連接了，具體如何連接，就不需要我們關心，大致思路與我們自行編寫連接池類似，只不過多了些其他屬性的出來方法。從而簡化了我們的開發
package zdb.jdbc.util; import java.io.IOException;import java.io.InputStream;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import java.util.Properties; import javax.sql.DataSource; import org.apache.commons.dbcp2.BasicDataSourceFactory; public class jdbcUtils_DBCP { /** * 在java中，編寫數據庫連接池需實現java.sql.DataSource接口，每一種數據庫連接池都是DataSource接口的實現 * DBCP連接池就是java.sql.DataSource接口的一個具體實現 */private static DataSource ds = null;static {InputStream in = jdbcUtils_DBCP.class.getClassLoader().getResourceAsStream('dbcpconfig.properties');Properties prop = new Properties();try {prop.load(in);//創建數據源ds = BasicDataSourceFactory.createDataSource(prop); } catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}public static Connection getConnection() throws SQLException{return ds.getConnection();}//釋放的資源包括Connection數據庫連接對象，負責執行SQL命令的Statement對象，存儲查詢結果的ResultSet對象public static void release(Connection conn,PreparedStatement ps ,ResultSet rs) {if (conn!=null) {try {conn.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if (ps!=null) {try {ps.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if (rs!=null) {try {rs.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}rs = null;}}}
接下來我們通過在表中插入屬性值來測試--DataSourceTest：
注意這段：
//由于包版本問題：必須加上PreparedStatement.RETURN_GENERATED_KEYS，不然將會報主鍵錯誤 ps = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);
package zdb.jdbc.util; import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException; import javafx.css.PseudoClass; public class DataSourceTest { public static void jdbcDataSource() {PreparedStatement ps = null;ResultSet rs = null;Connection conn = null;try {//conn = jdbcUtils_DBCP.getConnection();conn = jdbcUtils_DBCP.getConnection();String sql = 'insert into user(uname) values(?)';//由于版本兼容問題：必須加上PreparedStatement.RETURN_GENERATED_KEYSps = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);ps.setString(1, 'lonewolf');ps.executeUpdate();//獲得主鍵rs = ps.getGeneratedKeys();if (rs.next()) {System.out.println(rs.getInt(1));}} catch (SQLException e) {// TODO Auto-generated catch blockrse.printStackTrace();}finally {jdbcUtils_DBCP.release(conn, ps, rs);//jdbcUtils_C3P0.release(conn, ps, rs);}} public static void main(String[] args) {new DataSourceTest().jdbcDataSource();}}3.3、C3P0數據源（重點）
C3P0是一個開源的JDBC連接池，它實現了數據源和JNDI綁定，支持JDBC3規范和JDBC2的標準擴展。目前使用它的開源項目有Hibernate，Spring等。C3P0數據源在項目開發中使用得比較多。
c3p0與dbcp區別
dbcp默認不自動回收空閑連接，需要手動開啟c3p0默認自動回收空閑連接功能3.4、在應用程序中加入C3P0連接池
1.導入相關jar包 c3p0-0.9.5.2.jar、mchange-commons-java-0.2.12jar，如果操作的是Oracle數據庫，那么還需要導入c3p0-oracle-thin-extras-0.9.2-pre1.jar
注意：導入包時，兩個包的版本也是需要匹配的
不然會報錯：Exception in thread 'main' java.lang.NoClassDefFoundError: com/mchange/v2/ser/Indirector
但是這兩個包版本是匹配的，下載鏈接c3p0_jar_jb51.rar
2、包結構：
3、在類目錄下加入C3P0的配置文件：c3p0-config.xml，即在項目根目錄下讀取文件
c3p0-config.xml的配置信息如下：
注意：配置文件中有兩種內容相似的配置，一種缺省配置，意思是在沒有指定配置文件名時，調用該配置，一種命名配置，也就是在使用配置文件時，加上配置名即可引用，如接下來會說的：new ComboPooledDataSource('MySQL');
<c3p0-config> <!-- C3P0的缺省(默認)配置， 如果在代碼中“ComboPooledDataSource ds = new ComboPooledDataSource();”這樣寫就表示使用的是C3P0的缺省(默認)配置信息來創建數據源 --> <default-config> <property name='driverClass'>com.mysql.jdbc.Driver</property> <property name='jdbcUrl'>jdbc:mysql://localhost:3306/student</property> <property name='user'>root</property> <property name='password'>123456</property> <property name='acquireIncrement'>5</property> <property name='initialPoolSize'>10</property> <property name='minPoolSize'>5</property> <property name='maxPoolSize'>20</property> </default-config> <!-- C3P0的命名配置， 如果在代碼中“ComboPooledDataSource ds = new ComboPooledDataSource('MySQL');”這樣寫就表示使用的是name是MySQL的配置信息來創建數據源 --> <named-config name='MySQL'> <property name='driverClass'>com.mysql.jdbc.Driver</property> <property name='jdbcUrl'>jdbc:mysql://localhost:3306/student</property> <property name='user'>root</property> <property name='password'>123456</property> <property name='acquireIncrement'>5</property> <property name='initialPoolSize'>10</property> <property name='minPoolSize'>5</property> <property name='maxPoolSize'>20</property> </named-config> </c3p0-config>
jdbcUtils_C3P0：
大致思路：
我們可以通過代碼看到，c3p0將我們的代碼量又縮減了許多
ComboPooledDataSource ds = new ComboPooledDataSource('MySQL');我們直接new一個ComboPooledDataSource(）對象就可以獲得數據源，所以這就是為什么之前需要將xml配置文件放在根目錄下，“MySQL”就是我們的配置的名字
package zdb.jdbc.util; import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException; import com.mchange.v2.c3p0.ComboPooledDataSource; public class jdbcUtils_C3P0 {private static ComboPooledDataSource ds = null;static {ds = new ComboPooledDataSource('MySQL');}public static Connection getConnection() throws SQLException{ //從數據源中獲取數據庫連接 return ds.getConnection();}//釋放的資源包括Connection數據庫連接對象，負責執行SQL命令的Statement對象，存儲查詢結果的ResultSet對象public static void release(Connection conn,PreparedStatement ps ,ResultSet rs) {if (conn!=null) {try {conn.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if (ps!=null) {try {ps.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if (rs!=null) {try {rs.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}rs = null;}} }
測試C3P0數據源-DataSourceTest
package zdb.jdbc.util; import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException; import javafx.css.PseudoClass; public class DataSourceTest { public static void jdbcDataSource() {PreparedStatement ps = null;ResultSet rs = null;Connection conn = null;try {//conn = jdbcUtils_DBCP.getConnection();conn = jdbcUtils_C3P0.getConnection();String sql = 'insert into user(uname) values(?)';//由于版本兼容問題：必須加上PreparedStatement.RETURN_GENERATED_KEYSps = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS);ps.setString(1, 'lonewolf');ps.executeUpdate();//獲得主鍵rs = ps.getGeneratedKeys();if (rs.next()) {System.out.println(rs.getInt(1));}} catch (SQLException e) {// TODO Auto-generated catch blockrse.printStackTrace();}finally {jdbcUtils_DBCP.release(conn, ps, rs);//jdbcUtils_C3P0.release(conn, ps, rs);}} public static void main(String[] args) {new DataSourceTest().jdbcDataSource();}}
這些便是數據庫連接池的大致內容。
接下來說說
四、Tomcat中配置數據庫源在實際開發中，我們有時候還會使用服務器提供給我們的數據庫連接池，比如我們希望Tomcat服務器在啟動的時候可以幫我們創建一個數據庫連接池，那么我們在應用程序中就不需要手動去創建數據庫連接池，直接使用Tomcat服務器創建好的數據庫連接池即可。要想讓Tomcat服務器在啟動的時候幫我們創建一個數據庫連接池，那么需要簡單配置一下Tomcat服務器。
4.1、JNDI技術簡介JNDI(Java Naming and Directory Interface)，Java命名和目錄接口，它對應于J2SE中的javax.naming包，這 套API的主要作用在于：它可以把Java對象放在一個容器中（JNDI容器），并為容器中的java對象取一個名稱，以后程序想獲得Java對象，只需 通過名稱檢索即可。其核心API為Context，它代表JNDI容器，其lookup方法為檢索容器中對應名稱的對象。
Tomcat服務器創建的數據源是以JNDI資源的形式發布的，所以說在Tomat服務器中配置一個數據源實際上就是在配置一個JNDI資源
服務器創建好數據源之后，我們的應用程序又該怎么樣得到這個數據源呢，Tomcat服務器創建好數據源之后是以JNDI的形式綁定到一個JNDI容器中的，我們可以把JNDI想象成一個大大的容器，我們可以往這個容器中存放一些對象，一些資源，JNDI容器中存放的對象和資源都會有一個獨一無二的名稱，應用程序想從JNDI容器中獲取資源時，只需要告訴JNDI容器要獲取的資源的名稱，JNDI根據名稱去找到對應的資源后返回給應用程序。我們平時做javaEE開發時，服務器會為我們的應用程序創建很多資源，比如request對象，response對象，服務器創建的這些資源有兩種方式提供給我們的應用程序使用：第一種是通過方法參數的形式傳遞進來，比如我們在Servlet中寫的doPost和doGet方法中使用到的request對象和response對象就是服務器以參數的形式傳遞給我們的。第二種就是JNDI的方式，服務器把創建好的資源綁定到JNDI容器中去，應用程序想要使用資源時，就直接從JNDI容器中獲取相應的資源即可。
對于上面的name='jdbc/datasource'數據源資源，在應用程序中可以用如下的代碼去獲取
Context initCtx = new InitialContext();Context envCtx = (Context) initCtx.lookup('java:comp/env');dataSource = (DataSource)envCtx.lookup('jdbc/datasource');
此種配置下，數據庫的驅動jar文件需放置在tomcat的lib下
4.2、配置Tomcat數據源 包結構：
如果報錯com.mysql.jdbc.Connection.isValid(I)Z,說明包太舊了，更新mysql包即可解決
配置數據源JNDI的方式有很多，詳細請看：https://www.jb51.net/article/213425.htm
注意了：有個問題坑了我一天先看我的這篇文章---解決Tomcat中修改server.xml和content.xml后自動還原問題：https://www.jb51.net/article/213429.htm
之前我是直接在外部的tomcat文件下的conf文件夾下去修改這兩個文件，所以落坑
看完這篇文章應該知道了server.xml、context.xml的大概配置，接下來，我們來具體配置
我使用---配置全局JNDI數據源,應用到所有Tomcat下部署的應用
第一步、找到Tomcat的server.xml中GlobalNamingResources節點,在節點下加一個全局數據源
注意：name='jdbc/mysql'中“jdbc/mysql”為數據源名，在文件中多處引用
<Resource name='jdbc/mysql' scope='Shareable' type='javax.sql.DataSource' factory='org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory' url='jdbc:mysql://localhost:3306/test' driverClassName ='com.mysql.jdbc.Driver' username='root' password='root' />
第二步,找到Tomcat的context.xml,在Context節點下加一個ResourceLink節點對第一步配置的數據源進行引用
這個XML配置文件的根節點就是<Context>
插入代碼：
<ResourceLink global='jdbc/mysql' name='jdbc/mysql' type='javax.sql.DataSource'/>
第三步，配置web.xml文件，添加資源映射（此步驟可要可不要）
<resource-ref> <description>DB Connection</description> <res-ref-name>jdbc/mysql</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth> </resource-ref>
這種配置方式
優點:重用性,一次性到位
缺點:沒有可控性（tomcat原始文件遭到修改）
配置文件配置好了，現在就來寫代碼
JdbcUtils_JNDI：
package zdb.util.JNDI_tomcat; import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException; import javax.naming.Context;import javax.naming.InitialContext;import javax.naming.NamingException;import javax.sql.DataSource; public class JdbcUtils_JNDI {private static DataSource ds = null;static {try {//初始化JNDIContext initCtx = new InitialContext();//得到JNDI容器Context envCtx = (Context) initCtx.lookup('java:comp/env');//從JNDI容器中檢索name為jdbc/datasource的數據源ds = (DataSource) envCtx.lookup('jdbc/mysql');} catch (NamingException e) {// TODO Auto-generated catch blocke.printStackTrace();}}public static Connection getConnection() throws SQLException{ //從數據源中獲取數據庫連接 return ds.getConnection(); }//釋放的資源包括Connection數據庫連接對象，負責執行SQL命令的Statement對象，存儲查詢結果的ResultSet對象public static void release(Connection conn,PreparedStatement ps ,ResultSet rs) {if (conn!=null) {try {conn.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if (ps!=null) {try {ps.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if (rs!=null) {try {rs.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}rs = null;} }}
測試下
JNDI_test：
package zdb.util.JNDI_tomcat; import java.io.IOException;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet; import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;@WebServlet('/JNDI_test')public class JNDI_test extends HttpServlet{public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { Connection conn = null; PreparedStatement st = null; ResultSet rs = null; try{ //獲取數據庫連接 conn = JdbcUtils_JNDI.getConnection(); System.out.println('mysql Connection pool connected !!'); String sql = 'insert into user(uname) values(?)'; st = conn.prepareStatement(sql,PreparedStatement.RETURN_GENERATED_KEYS); st.setString(1, 'gacl'); st.executeUpdate(); //獲取數據庫自動生成的主鍵 rs = st.getGeneratedKeys(); if(rs.next()){ System.out.println(rs.getInt(1)); } }catch (Exception e) { e.printStackTrace(); }finally{ //釋放資源 JdbcUtils_JNDI.release(conn, st, rs); } } public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } }
我再通過寫一個jsp頁面來映射到該servlet測試下
test.jsp:
<%@ page language='java' contentType='text/html; charset=UTF-8' pageEncoding='UTF-8'%><!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN' 'http://www.w3.org/TR/html4/loose.dtd'><html><head><meta http-equiv='Content-Type' content='text/html; charset=UTF-8'><title>Insert title here</title><style>body{text-align:center;}</style></head><body><a href='http://www.gepszalag.com/bcjs/${pageContext.servletContext.contextPath }/JNDI_test' rel='external nofollow' >測試</a></body>
測試結果成功：
拓展：由于此種配置模式的缺點，我們還可以通過增加一個新的xml文件來增加節點，而不用動原始文件
具體請看：tomcat虛擬路徑的配置幾篇文章推薦給大家看下：
tomcat下面web應用發布路徑配置( 即虛擬目錄配置 )：http://www.voidcn.com/article/p-zctzsjte-rs.html
Tomcat服務器原理詳解：https://www.cnblogs.com/crazylqy/p/4706223.html
Tomcat中主目錄配置與虛擬目錄配置問題自我總結：http://blog.51cto.com/longx/1357666
文章借鑒參照：-孤傲蒼狼-原文：https://www.cnblogs.com/xdp-gacl/p/4002804.html
到此這篇關于Java中幾種常用數據庫連接池的使用的文章就介紹到這了,更多相關Java 數據庫連接池內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！
相關文章：
網公網安備