Java的JDBC数据库连接池实现方法

Java程序员都很羡慕Windows ADO ，只需要new Connection 就可以直接从数据库连接池中返回Connection。并且 ADO Connection 是线程安全的，多个线程可以共用一个Connection，所以ASP程序一般都把getConnection 放在 Global.asa 文件中，在 IIS 启动时建立数据库连接。ADO 的Connection 和Result 都有很好的缓冲，并且很容易使用。

睢宁县网站建设公司创新互联,睢宁县网站设计制作，有大型网站制作公司丰富经验。已为睢宁县1000+提供企业网站建设服务。企业网站搭建\外贸营销网站建设要多少钱，请找那个售后服务好的睢宁县做网站的公司定做！

其实我们可以自己写一个JDBC数据库连接池。

写JDBC connection pool 的注意事项有：

1. 有一个简单的函数从连接池中得到一个 Connection。

2. close 函数必须将connection 放回 数据库连接池。

3. 当数据库连接池中没有空闲的connection，数据库连接池必须能够自动增加connection 个数。

4. 当数据库连接池中的connection 个数在某一个特别的时间变得很大，但是以后很长时间只用其中一小部分，应该可以自动将多余的connection 关闭掉。

5. 如果可能，应该提供debug 信息报告没有关闭的new Connection 。

如果要new Connection 就可以直接从数据库连接池中返回Connection， 可以这样写( Mediator pattern ) (以下代码中使用了中文全角空格)：

 
 
 
    
  
  
  
  1. public class EasyConnection implements java.sql.Connection{  
    2.   
  
  
  2. 　　private Connection m_delegate = null;  
    3.   
  
  
  3. 　　public EasyConnection(){  
    4.   
  
  
  4. 　　　　m_delegate = getConnectionFromPool();  
    5.   
  
  
  5. 　　}  
    6.   
  
  
  6. 　public void close(){  
    7.   
  
  
  7. 　　　　putConnectionBackToPool(m_delegate);  
    8.   
  
  
  8. 　　}  
    9.   
  
  
  9. 　　public PreparedStatement prepareStatement(String sql) throws SQLException{  
    10.   
  
  
  10. 　　　　m_delegate.prepareStatement(sql);  
    11.   
  
  
  11. 　　}  
    12.   
  
  
  12. 　　//...... other method  
    13.   
  
  
  13. } 
    14.

看来并不难。不过不建议这种写法，因为应该尽量避免使用Java Interface, 关于Java Interface 的缺点我另外再写文章讨论。大家关注的是Connection Pool 的实现方法。下面给出一种实现方法。

 
 
 
    
  
  
  
  1. import java.sql.*;  
    2.   
  
  
  2. import java.lang.reflect.*;  
    3.   
  
  
  3. import java.util.*;  
    4.   
  
  
  4. import java.io.*;  
    5.   
  
  
  5.  
    6.   
  
  
  6. public class SimpleConnetionPool {  
    7.   
  
  
  7. 　　private static LinkedList m_notUsedConnection = new LinkedList();  
    8.   
  
  
  8. 　　private static HashSet m_usedUsedConnection = new HashSet();  
    9.   
  
  
  9. 　　private static String m_url = "";  
    10.   
  
  
  10. 　　private static String m_user = "";  
    11.   
  
  
  11. 　　private static String m_password = "";  
    12.   
  
  
  12. 　　static final boolean DEBUG = true;  
    13.   
  
  
  13. 　　static private long m_lastClearClosedConnection = System.currentTimeMillis();  
    14.   
  
  
  14. 　　public static long CHECK_CLOSED_CONNECTION_TIME = 4 * 60 * 60 * 1000; //4 hours  
    15.   
  
  
  15.  
    16.   
  
  
  16. 　　static {  
    17.   
  
  
  17. 　　　　initDriver();  
    18.   
  
  
  18. 　　}  
    19.   
  
  
  19.  
    20.   
  
  
  20. 　　private SimpleConnetionPool() {  
    21.   
  
  
  21. 　　}  
    22.   
  
  
  22.  
    23.   
  
  
  23. 　　private static void initDriver() {  
    24.   
  
  
  24. 　　　　Driver driver = null;  
    25.   
  
  
  25. 　　　　//load mysql driver  
    26.   
  
  
  26. 　　　　try {  
    27.   
  
  
  27. 　　　　　　driver = (Driver) Class.forName("com.mysql.jdbc.Driver").newInstance();  
    28.   
  
  
  28. 　　　　　　installDriver(driver);  
    29.   
  
  
  29. 　　　　} catch (Exception e) {  
    30.   
  
  
  30. 　　　　}  
    31.   
  
  
  31.  
    32.   
  
  
  32. 　　　　//load postgresql driver  
    33.   
  
  
  33. 　　　　try {  
    34.   
  
  
  34. 　　　　　　driver = (Driver) Class.forName("org.postgresql.Driver").newInstance();  
    35.   
  
  
  35. 　　　　　　installDriver(driver);  
    36.   
  
  
  36. 　　　　} catch (Exception e) {  
    37.   
  
  
  37. 　　　　}  
    38.   
  
  
  38. 　　}  
    39.   
  
  
  39.  
    40.   
  
  
  40. 　　public static void installDriver(Driver driver) {  
    41.   
  
  
  41. 　　　　try {  
    42.   
  
  
  42. 　　　　　　DriverManager.registerDriver(driver);  
    43.   
  
  
  43. 　　　　} catch (Exception e) {  
    44.   
  
  
  44. 　　　　　　e.printStackTrace();  
    45.   
  
  
  45. 　　　　}  
    46.   
  
  
  46. 　　}  
    47.   
  
  
  47.  
    48.   
  
  
  48.  
    49.   
  
  
  49. 　　public static synchronized Connection getConnection() {  
    50.   
  
  
  50. 　　　　clearClosedConnection();  
    51.   
  
  
  51. 　　　　while (m_notUsedConnection.size() > 0) {  
    52.   
  
  
  52. 　　　　　　try {  
    53.   
  
  
  53. 　　　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) m_notUsedConnection.removeFirst();  
    54.   
  
  
  54. 　　　　　　　　if (wrapper.connection.isClosed()) {  
    55.   
  
  
  55. 　　　　　　　　　　continue;  
    56.   
  
  
  56. 　　　　　　　　}  
    57.   
  
  
  57. 　　　　　　　　m_usedUsedConnection.add(wrapper);  
    58.   
  
  
  58. 　　　　　　　　if (DEBUG) {  
    59.   
  
  
  59. 　　　　　　　　　　wrapper.debugInfo = new Throwable("Connection initial statement");  
    60.   
  
  
  60. 　　　　　　　　}  
    61.   
  
  
  61. 　　　　　　　　return wrapper.connection;  
    62.   
  
  
  62. 　　　　　　} catch (Exception e) {  
    63.   
  
  
  63. 　　　　　　}  
    64.   
  
  
  64. 　　　　}  
    65.   
  
  
  65. 　　　　int newCount = getIncreasingConnectionCount();  
    66.   
  
  
  66. 　　　　LinkedList list = new LinkedList();  
    67.   
  
  
  67. 　　　　ConnectionWrapper wrapper = null;  
    68.   
  
  
  68. 　　　　for (int i = 0; i < newCount; i++) {  
    69.   
  
  
  69. 　　　　　　wrapper = getNewConnection();  
    70.   
  
  
  70. 　　　　　　if (wrapper != null) {  
    71.   
  
  
  71. 　　　　　　　　list.add(wrapper);  
    72.   
  
  
  72. 　　　　　　}  
    73.   
  
  
  73. 　　　　}  
    74.   
  
  
  74. 　　　　if (list.size() == 0) {  
    75.   
  
  
  75. 　　　　　　return null;  
    76.   
  
  
  76. 　　　　}  
    77.   
  
  
  77. 　　　　wrapper = (ConnectionWrapper) list.removeFirst();  
    78.   
  
  
  78. 　　　　m_usedUsedConnection.add(wrapper);  
    79.   
  
  
  79.  
    80.   
  
  
  80. 　　　　m_notUsedConnection.addAll(list);  
    81.   
  
  
  81. 　　　　list.clear();  
    82.   
  
  
  82.  
    83.   
  
  
  83. 　　　　return wrapper.connection;  
    84.   
  
  
  84. 　　}  
    85.   
  
  
  85.  
    86.   
  
  
  86. 　　private static ConnectionWrapper getNewConnection() {  
    87.   
  
  
  87. 　　　　try {  
    88.   
  
  
  88. 　　　　　　Connection con = DriverManager.getConnection(m_url, m_user, m_password);  
    89.   
  
  
  89. 　　　　　　ConnectionWrapper wrapper = new ConnectionWrapper(con);  
    90.   
  
  
  90. 　　　　　　return wrapper;  
    91.   
  
  
  91. 　　　　} catch (Exception e) {  
    92.   
  
  
  92. 　　　　　　e.printStackTrace();  
    93.   
  
  
  93. 　　　　}  
    94.   
  
  
  94. 　　　　return null;  
    95.   
  
  
  95. 　　}  
    96.   
  
  
  96.  
    97.   
  
  
  97. 　　static synchronized void pushConnectionBackToPool(ConnectionWrapper con) {  
    98.   
  
  
  98. 　　　　boolean exist = m_usedUsedConnection.remove(con);  
    99.   
  
  
  99. 　　　　if (exist) {  
    100.   
  
  
  100. 　　　　　　m_notUsedConnection.addLast(con);  
    101.   
  
  
  101. 　　　　}  
    102.   
  
  
  102. 　　}  
    103.   
  
  
  103.  
    104.   
  
  
  104. 　　public static int close() {  
    105.   
  
  
  105. 　　　　int count = 0;  
    106.   
  
  
  106.  
    107.   
  
  
  107. 　　　　Iterator iterator = m_notUsedConnection.iterator();  
    108.   
  
  
  108. 　　　　while (iterator.hasNext()) {  
    109.   
  
  
  109. 　　　　　　try {  
    110.   
  
  
  110. 　　　　　　　　( (ConnectionWrapper) iterator.next()).close();  
    111.   
  
  
  111. 　　　　　　　　count++;  
    112.   
  
  
  112. 　　　　　　} catch (Exception e) {  
    113.   
  
  
  113. 　　　　　　}  
    114.   
  
  
  114. 　　　　}  
    115.   
  
  
  115. 　　　　m_notUsedConnection.clear();  
    116.   
  
  
  116.  
    117.   
  
  
  117. 　　　　iterator = m_usedUsedConnection.iterator();  
    118.   
  
  
  118. 　　　　while (iterator.hasNext()) {  
    119.   
  
  
  119. 　　　　　　try {  
    120.   
  
  
  120. 　　　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();  
    121.   
  
  
  121. 　　　　　　　　wrapper.close();  
    122.   
  
  
  122. 　　　　　　　　if (DEBUG) {  
    123.   
  
  
  123. 　　　　　　　　　　wrapper.debugInfo.printStackTrace();  
    124.   
  
  
  124. 　　　　　　　　}  
    125.   
  
  
  125. 　　　　　　　　count++;  
    126.   
  
  
  126. 　　　　　　} catch (Exception e) {  
    127.   
  
  
  127. 　　　　　　}  
    128.   
  
  
  128. 　　　　}  
    129.   
  
  
  129. 　　　　m_usedUsedConnection.clear();  
    130.   
  
  
  130.  
    131.   
  
  
  131. 　　　　return count;  
    132.   
  
  
  132. 　　}  
    133.   
  
  
  133.  
    134.   
  
  
  134. 　　private static void clearClosedConnection() {  
    135.   
  
  
  135. 　　　　long time = System.currentTimeMillis();  
    136.   
  
  
  136. 　　　　//sometimes user change system time,just return  
    137.   
  
  
  137. 　　　　if (time < m_lastClearClosedConnection) {  
    138.   
  
  
  138. 　　　　　　time = m_lastClearClosedConnection;  
    139.   
  
  
  139. 　　　　　　return;  
    140.   
  
  
  140. 　　　　}  
    141.   
  
  
  141. 　　　　//no need check very often  
    142.   
  
  
  142. 　　　　if (time - m_lastClearClosedConnection < CHECK_CLOSED_CONNECTION_TIME) {  
    143.   
  
  
  143. 　　　　　　return;  
    144.   
  
  
  144. 　　　　}  
    145.   
  
  
  145. 　　　　m_lastClearClosedConnection = time;  
    146.   
  
  
  146.  
    147.   
  
  
  147. 　　　　//begin check  
    148.   
  
  
  148. 　　　　Iterator iterator = m_notUsedConnection.iterator();  
    149.   
  
  
  149. 　　　　while (iterator.hasNext()) {  
    150.   
  
  
  150. 　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();  
    151.   
  
  
  151. 　　　　　　try {  
    152.   
  
  
  152. 　　　　　　　　if (wrapper.connection.isClosed()) {  
    153.   
  
  
  153. 　　　　　　　　　　iterator.remove();  
    154.   
  
  
  154. 　　　　　　　　}  
    155.   
  
  
  155. 　　　　　　} catch (Exception e) {  
    156.   
  
  
  156. 　　　　　　　　iterator.remove();  
    157.   
  
  
  157. 　　　　　　　　if (DEBUG) {  
    158.   
  
  
  158. 　　　　　　　　　　System.out.println("connection is closed, this connection initial StackTrace");  
    159.   
  
  
  159. 　　　　　　　　　　wrapper.debugInfo.printStackTrace();  
    160.   
  
  
  160. 　　　　　　　　}  
    161.   
  
  
  161. 　　　　　　}  
    162.   
  
  
  162. 　　　　}  
    163.   
  
  
  163.  
    164.   
  
  
  164. 　　　　//make connection pool size smaller if too big  
    165.   
  
  
  165. 　　　　int decrease = getDecreasingConnectionCount();  
    166.   
  
  
  166. 　　　　if (m_notUsedConnection.size() < decrease) {  
    167.   
  
  
  167. 　　　　　　return;  
    168.   
  
  
  168. 　　　　}  
    169.   
  
  
  169.  
    170.   
  
  
  170. 　　　　while (decrease-- > 0) {  
    171.   
  
  
  171. 　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) m_notUsedConnection.removeFirst();  
    172.   
  
  
  172. 　　　　　　try {  
    173.   
  
  
  173. 　　　　　　　　wrapper.connection.close();  
    174.   
  
  
  174. 　　　　　　} catch (Exception e) {  
    175.   
  
  
  175. 　　　　　　}  
    176.   
  
  
  176. 　　　　}  
    177.   
  
  
  177. 　　}  
    178.   
  
  
  178.  
    179.   
  
  
  179. 　　/**  
    180.   
  
  
  180. 　　 * get increasing connection count, not just add 1 connection  
    181.   
  
  
  181. 　　 * @return count  
    182.   
  
  
  182. 　　 */ 
    183.   
  
  
  183. 　　public static int getIncreasingConnectionCount() {  
    184.   
  
  
  184. 　　　　int count = 1;  
    185.   
  
  
  185. 　　　　int current = getConnectionCount();  
    186.   
  
  
  186. 　　　　count = current / 4;  
    187.   
  
  
  187. 　　　　if (count < 1) {  
    188.   
  
  
  188. 　　　　　　count = 1;  
    189.   
  
  
  189. 　　　　}  
    190.   
  
  
  190. 　　　　return count;  
    191.   
  
  
  191. 　　}  
    192.   
  
  
  192.  
    193.   
  
  
  193. 　　/**  
    194.   
  
  
  194. 　　 * get decreasing connection count, not just remove 1 connection  
    195.   
  
  
  195. 　　 * @return count  
    196.   
  
  
  196. 　　 */ 
    197.   
  
  
  197. 　　public static int getDecreasingConnectionCount() {  
    198.   
  
  
  198. 　　　　int count = 0;  
    199.   
  
  
  199. 　　　　int current = getConnectionCount();  
    200.   
  
  
  200. 　　　　if (current < 10) {  
    201.   
  
  
  201. 　　　　　　return 0;  
    202.   
  
  
  202. 　　　　}  
    203.   
  
  
  203. 　　　　return current / 3;  
    204.   
  
  
  204. 　　}  
    205.   
  
  
  205.  
    206.   
  
  
  206. 　　public synchronized static void printDebugMsg() {  
    207.   
  
  
  207. 　　　　printDebugMsg(System.out);  
    208.   
  
  
  208. 　　}  
    209.   
  
  
  209.  
    210.   
  
  
  210. 　　public synchronized static void printDebugMsg(PrintStream out) {  
    211.   
  
  
  211. 　　　　if (DEBUG == false) {  
    212.   
  
  
  212. 　　　　　　return;  
    213.   
  
  
  213. 　　　　}  
    214.   
  
  
  214. 　　　　StringBuffer msg = new StringBuffer();  
    215.   
  
  
  215. 　　　　msg.append("debug message in " + SimpleConnetionPool.class.getName());  
    216.   
  
  
  216. 　　　　msg.append("\r\n");  
    217.   
  
  
  217. 　　　　msg.append("total count is connection pool: " + getConnectionCount());  
    218.   
  
  
  218. 　　　　msg.append("\r\n");  
    219.   
  
  
  219. 　　　　msg.append("not used connection count: " + getNotUsedConnectionCount());  
    220.   
  
  
  220. 　　　　msg.append("\r\n");  
    221.   
  
  
  221. 　　　　msg.append("used connection, count: " + getUsedConnectionCount());  
    222.   
  
  
  222. 　　　　out.println(msg);  
    223.   
  
  
  223. 　　　　Iterator iterator = m_usedUsedConnection.iterator();  
    224.   
  
  
  224. 　　　　while (iterator.hasNext()) {  
    225.   
  
  
  225. 　　　　　　ConnectionWrapper wrapper = (ConnectionWrapper) iterator.next();  
    226.   
  
  
  226. 　　　　　　wrapper.debugInfo.printStackTrace(out);  
    227.   
  
  
  227. 　　　　}  
    228.   
  
  
  228. 　　　　out.println();  
    229.   
  
  
  229. 　　}  
    230.   
  
  
  230.  
    231.   
  
  
  231. 　　public static synchronized int getNotUsedConnectionCount() {  
    232.   
  
  
  232. 　　　　return m_notUsedConnection.size();  
    233.   
  
  
  233. 　　}  
    234.   
  
  
  234.  
    235.   
  
  
  235. 　　public static synchronized int getUsedConnectionCount() {  
    236.   
  
  
  236. 　　　　return m_usedUsedConnection.size();  
    237.   
  
  
  237. 　　}  
    238.   
  
  
  238.  
    239.   
  
  
  239. 　　public static synchronized int getConnectionCount() {  
    240.   
  
  
  240. 　　　　return m_notUsedConnection.size() + m_usedUsedConnection.size();  
    241.   
  
  
  241. 　　}  
    242.   
  
  
  242.  
    243.   
  
  
  243. 　　public static String getUrl() {  
    244.   
  
  
  244. 　　　　return m_url;  
    245.   
  
  
  245. 　　}  
    246.   
  
  
  246.  
    247.   
  
  
  247. 　　public static void setUrl(String url) {  
    248.   
  
  
  248. 　　　　if (url == null) {  
    249.   
  
  
  249. 　　　　　　return;  
    250.   
  
  
  250. 　　　　}  
    251.   
  
  
  251. 　　　　m_url = url.trim();  
    252.   
  
  
  252. 　　}  
    253.   
  
  
  253.  
    254.   
  
  
  254. 　　public static String getUser() {  
    255.   
  
  
  255. 　　　　return m_user;  
    256.   
  
  
  256. 　　}  
    257.   
  
  
  257.  
    258.   
  
  
  258. 　　public static void setUser(String user) {  
    259.   
  
  
  259. 　　　　if (user == null) {  
    260.   
  
  
  260. 　　　　　　return;  
    261.   
  
  
  261. 　　　　}  
    262.   
  
  
  262. 　　　　m_user = user.trim();  
    263.   
  
  
  263. 　　}  
    264.   
  
  
  264.  
    265.   
  
  
  265. 　　public static String getPassword() {  
    266.   
  
  
  266. 　　　　return m_password;  
    267.   
  
  
  267. 　　}  
    268.   
  
  
  268.  
    269.   
  
  
  269. 　　public static void setPassword(String password) {  
    270.   
  
  
  270. 　　　　if (password == null) {  
    271.   
  
  
  271. 　　　　　　return;  
    272.   
  
  
  272. 　　　　}  
    273.   
  
  
  273. 　　　　m_password = password.trim();  
    274.   
  
  
  274. 　　}  
    275.   
  
  
  275.  
    276.   
  
  
  276. }  
    277.   
  
  
  277.  
    278.   
  
  
  278. class ConnectionWrapper implements InvocationHandler {  
    279.   
  
  
  279. 　　private final static String CLOSE_METHOD_NAME = "close";  
    280.   
  
  
  280. 　　public Connection connection = null;  
    281.   
  
  
  281. 　　private Connection m_originConnection = null;  
    282.   
  
  
  282. 　　public long lastAccessTime = System.currentTimeMillis();  
    283.   
  
  
  283. 　　Throwable debugInfo = new Throwable("Connection initial statement");  
    284.   
  
  
  284.  
    285.   
  
  
  285. 　　ConnectionWrapper(Connection con) {  
    286.   
  
  
  286. 　　　　this.connection = (Connection) Proxy.newProxyInstance(  
    287.   
  
  
  287. 　　　　　　con.getClass().getClassLoader(),  
    288.   
  
  
  288. 　　　　　　con.getClass().getInterfaces(), this);  
    289.   
  
  
  289. 　　　　m_originConnection = con;  
    290.   
  
  
  290. 　　}  
    291.   
  
  
  291.  
    292.   
  
  
  292. 　　void close() throws SQLException {  
    293.   
  
  
  293. 　　　　m_originConnection.close();  
    294.   
  
  
  294. 　　}  
    295.   
  
  
  295.  
    296.   
  
  
  296. 　　public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {  
    297.   
  
  
  297. 　　　　Object obj = null;  
    298.   
  
  
  298. 　　　　if (CLOSE_METHOD_NAME.equals(m.getName())) {  
    299.   
  
  
  299. 　　　　　　SimpleConnetionPool.pushConnectionBackToPool(this);  
    300.   
  
  
  300. 　　　　}  
    301.   
  
  
  301. 　　　　else {  
    302.   
  
  
  302. 　　　　　　obj = m.invoke(m_originConnection, args);  
    303.   
  
  
  303. 　　　　}  
    304.   
  
  
  304. 　　　　lastAccessTime = System.currentTimeMillis();  
    305.   
  
  
  305. 　　　　return obj;  
    306.   
  
  
  306. 　　}  
    307.   
  
  
  307. } 
    308.

使用方法

 
 
 
    
  
  
  
  1. public class TestConnectionPool{  
    2.   
  
  
  2. 　　public static void main(String[] args) {  
    3.   
  
  
  3. 　　　　SimpleConnetionPool.setUrl(DBTools.getDatabaseUrl());  
    4.   
  
  
  4. 　　　　SimpleConnetionPool.setUser(DBTools.getDatabaseUserName());  
    5.   
  
  
  5. 　　　　SimpleConnetionPool.setPassword(DBTools.getDatabasePassword());  
    6.   
  
  
  6.  
    7.   
  
  
  7. 　　　　Connection con = SimpleConnetionPool.getConnection();  
    8.   
  
  
  8. 　　　　Connection con1 = SimpleConnetionPool.getConnection();  
    9.   
  
  
  9. 　　　　Connection con2 = SimpleConnetionPool.getConnection();  
    10.   
  
  
  10.  
    11.   
  
  
  11. 　　　　//do something with con ...  
    12.   
  
  
  12.  
    13.   
  
  
  13. 　　　　try {  
    14.   
  
  
  14. 　　　　　　con.close();  
    15.   
  
  
  15. 　　　　} catch (Exception e) {}  
    16.   
  
  
  16.  
    17.   
  
  
  17. 　　　　try {  
    18.   
  
  
  18. 　　　　　　con1.close();  
    19.   
  
  
  19. 　　　　} catch (Exception e) {}  
    20.   
  
  
  20.  
    21.   
  
  
  21. 　　　　try {  
    22.   
  
  
  22. 　　　　　　con2.close();  
    23.   
  
  
  23. 　　　　} catch (Exception e) {}  
    24.   
  
  
  24.  
    25.   
  
  
  25. 　　　　con = SimpleConnetionPool.getConnection();  
    26.   
  
  
  26. 　　　　con1 = SimpleConnetionPool.getConnection();  
    27.   
  
  
  27. 　　　　try {  
    28.   
  
  
  28. 　　　　　　con1.close();  
    29.   
  
  
  29. 　　　　} catch (Exception e) {}  
    30.   
  
  
  30.  
    31.   
  
  
  31. 　　　　con2 = SimpleConnetionPool.getConnection();  
    32.   
  
  
  32. 　　　　SimpleConnetionPool.printDebugMsg();  
    33.   
  
  
  33.  
    34.   
  
  
  34. 　　}  
    35.   
  
  
  35. } 
    36.

运行测试程序后打印JDBC数据库连接池中Connection状态，以及正在使用的没有关闭Connection信息。

网站题目：Java的JDBC数据库连接池实现方法
本文路径：http://www.csdahua.cn/qtweb/news43/32543.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站内链知识

分类信息网

广汉锦华橡塑　　 　珉田数据中心　　 　盐亭做网站　　 　网站制作　　 　zaowang.cn　　 　域名申请　　 　乐至网站建设　　 　边坡防护网厂家　　 　四川电信机房托管　　 　公路打桩机　　 　重庆主机托管　　 　联通机房服务器托管　　 　成都发电机租用　　 　网站制作公司　　 　抖音代运营　　 　青羊雕琢时光　　 　四川珉田机房　　 　研帮主　　 　崇州威斯达宇　　 　发光字制作