JDBC 数据库连接池小结

当对数据库的访问不是很频繁时，可以在每次访问数据库时建立一个连接，用完之后关闭。但是，对于一个复杂的数据库应用，频繁的建立、关闭连接，会极大的减低系统性能，造成瓶颈。所以可以使用数据库连接池来达到连接资源的共享，使得对于数据库的连接可以使高效、安全的复用。

1.通过一个小测试来了解数据库连接池的原理

（1）创建一个属性文件 dbpool.properties

1 driverClassName=com.mysql.jdbc.Driver
2 username=root
3 password=iloveyou
4 url=jdbc:mysql://localhost:3306/student
5 poolSize=5

（2）创建实现数据库连接池的类文件 ConnectionPool.java

  1 package dbpool;
  2 
  3 import java.io.FileInputStream;
  4 import java.io.FileNotFoundException;
  5 import java.io.IOException;
  6 import java.sql.Connection;
  7 import java.sql.SQLException;
  8 import java.util.Properties;
  9 import java.util.Vector;
 10 
 11 public class ConnectionPool {
 12     private Vector<Connection> pool;
 13     private String url;
 14     private String username;
 15     private String password;
 16     private String driverClassName;
 17     private int poolSize = 1;
 18     private static ConnectionPool instance = null;
 19     
 20     //私有构造方法，禁止外部创建本类的对象，要想获得本类的对象，通过<code>getInstance</code>方法
 21     private ConnectionPool(){
 22         System.out.println("构造函数");
 23         init();
 24     }
 25     
 26     //连接池初始化方法，读取属性文件的内容，建立连接池中的初始连接
 27     private void init(){
 28         readConfig();
 29         pool = new Vector<Connection>(poolSize);
 30         addConnection();
 31     }
 32     
 33     //返回连接到连接池中
 34     public synchronized void release(Connection coon){
 35         pool.add(coon);
 36     }
 37     
 38     //关闭连接池中的所有数据库连接
 39     public synchronized void closePool(){
 40         for (int i = 0; i < pool.size(); i++) {
 41             try {
 42                 ((Connection)pool.get(i)).close();
 43             } catch (SQLException e) {
 44                 // TODO Auto-generated catch block
 45                 e.printStackTrace();
 46             }
 47             pool.remove(i);
 48         }
 49     }
 50     
 51     //返回当前连接池的一个对象
 52     public static ConnectionPool getInstance(){
 53         if (instance == null) {
 54             instance = new ConnectionPool();
 55         }
 56         return instance;
 57     }
 58     
 59     //返回连接池中的一个数据库连接
 60     public synchronized Connection getConnection(){
 61         if (pool.size() > 0) {
 62             Connection conn = pool.get(0);
 63             pool.remove(conn);
 64             return conn;
 65         }else {
 66             return null;
 67         }
 68     }
 69     
 70     //在连接池中创建初始设置的数据库连接
 71     private void addConnection(){
 72         Connection coon = null;
 73         for (int i = 0; i < poolSize; i++) {
 74             try {
 75                 Class.forName(driverClassName);
 76                 coon = java.sql.DriverManager.getConnection(url, username, password);
 77                 pool.add(coon);
 78             } catch (ClassNotFoundException e) {
 79                 // TODO Auto-generated catch block
 80                 e.printStackTrace();
 81             } catch (SQLException e) {
 82                 // TODO Auto-generated catch block
 83                 e.printStackTrace();
 84             }
 85         }
 86     }
 87     
 88     //读取设置连接池的属性文件
 89     private void readConfig(){
 90         try {
 91             String path = System.getProperty("user.dir") + "\dbpool.properties";
 92             FileInputStream is = new FileInputStream(path);
 93             Properties props = new Properties();
 94             props.load(is);
 95             this.driverClassName = props.getProperty("driverClassName");
 96             this.username = props.getProperty("username");
 97             this.password = props.getProperty("password");
 98             this.url = props.getProperty("url");
 99             this.poolSize = Integer.parseInt(props.getProperty("poolSize"));
100         } catch (FileNotFoundException e) {
101             // TODO Auto-generated catch block
102             e.printStackTrace();
103             System.err.println("属性文件找不到");
104         } catch (IOException e) {
105             // TODO Auto-generated catch block
106             e.printStackTrace();
107             System.err.println("读取属性文件出错");
108         }
109     }
110     
111 }

（3）创建一个使用连接池访问数据库的类文件 ConnectionPoolTest.java

 1 package dbpool;
 2 
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 
 8 public class ConnectionPoolTest {
 9     public static void main(String[] args) throws SQLException{
10         String sql = "select * from user";
11         ConnectionPool pool = null;
12         
13         for (int i = 0; i < 2; i++) {
14             pool = ConnectionPool.getInstance();
15             Connection conn = pool.getConnection();
16             PreparedStatement stmt = conn.prepareStatement(sql);
17             ResultSet rs = stmt.executeQuery(sql);
18             while (rs.next()) {
19                 System.out.println(rs.getString(1) + "		" + rs.getString(2) + "		" + rs.getString(3));
20             }
21             rs.close();
22             stmt.close();
23             pool.release(conn);
24         }
25         pool.closePool();
26     }
27 }

2.在开发具体项目时没有必要自己编写数据库连接池，现在已经有很多现成的组件。许多服务器已经内置了数据库连接池，如Tomcat服务器、Jboss服务器和WebLogic服务器等。我自己根据书上的例子，配置了一下Tomcat服务器。配置步骤如下：

（1）配置Tomcat根目录下的 conf 中的文件 context.xml 如下：

1 <!--Resource 设置数据库连接池的核心-->
2     <!--属性 name 数据源的名字       属性 auth 表示验证方式     type 资源的类型       -->
3     <Resource name="jdbc/DBWater" auth="Container" Type="javax.sql.DataSource"
4               maxActive="100" maxIdle="30" maxWait="10000"
5               username="root" password="*******"
6               driverClassName="com.mysql.jdbc.Driver"
7               url="jdbc:mysql://localhost:3306/student"/>

将这段代码添加到<context></context>之间

（2）修改项目工程目录下 WebRoot/WEB-INF/web.xml 文件：

 1 <resource-ref>
 2   <!-- 描述信息 -->
 3   <description>Connection Pool</description>
 4   <!-- 数据源名字 和上面配置中数据源的名字一致-->
 5   <res-ref-name>jdbc/DBWater</res-ref-name>
 6   <!-- 数据源类型 -->
 7   <res-type>javax.sql.DataSource</res-type>
 8   <res-auth>Container</res-auth>
 9   <res-sharing-scope>Shareable</res-sharing-scope>
10 </resource-ref>

下面就可以进行连接池使用了。比如，这里，创建一个DBWater.java文件：

 1 package com.lihui.dbwater;
 2 
 3 import java.sql.Connection;
 4 import java.sql.ResultSet;
 5 import java.sql.Statement;
 6 
 7 import javax.naming.Context;
 8 import javax.naming.InitialContext;
 9 import javax.naming.NamingException;
10 import javax.sql.DataSource;
11 
12 public class DBWater {
13     String userId;
14     String name;
15     String password;
16     
17     public String getUserId(){
18         return userId;
19     }
20     
21     public String getName(){
22         return name;
23     }
24     
25     public String getpassword(){
26         return password;
27     }
28     
29     public void init(){
30         try {
31             InitialContext initC = new InitialContext();//创建InitialContext对象
32             if (initC == null) {
33                 throw new Exception("No Context");
34             }
35             Context context = (Context)initC.lookup("java:comp/env");//不变
36             DataSource ds = (DataSource)context.lookup("jdbc/DBWater");//tomcat服务器配置文件中数据源名称
37             if (ds != null) {
38                 Connection conn = ds.getConnection();
39                 if (conn != null) {
40                     Statement statement = conn.createStatement();
41                     ResultSet resultSet = statement.executeQuery("select * from user");
42                     while (resultSet.next()) {
43                         userId = resultSet.getString(1);
44                         name = resultSet.getString(2);
45                         password = resultSet.getString(3);
46                     }
47                     conn.close();
48                 }
49             }
50         } catch (NamingException e) {
51             // TODO Auto-generated catch block
52             e.printStackTrace();
53         } catch (Exception e) {
54             // TODO Auto-generated catch block
55             e.printStackTrace();
56         }
57     }
58 }

那么在jsp文件中调用该类：

 1 <%@ page language="java" import="java.util.*" pageEncoding="gb2312"%>
 2 <%@page import="com.lihui.dbwater.DBWater"%>
 3 
 4 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 5 <html>
 6   <head>
 7     <title>连接池测试</title>
 8   </head>
 9   
10   <body>
11   <%
12       DBWater rs = new DBWater();
13       rs.init();
14 %>
15   id:<%=rs.getUserId() %>
16   name:<%=rs.getName() %>
17   psd:<%=rs.getpassword() %>
18   </body>
19 </html>