JavaEE开发技术点5：Tomcat jdbc数据库连接池

发表于   |   分类于   |     |   阅读 次

前言
数据库连接是一种昂贵的资源，当有多个用户访问网页的时候，对程序的性能与稳定性都有要求。数据库连接池就是为了解决这个问题的，数据库连接池负责创建、管理并释放连接。连接池中的连接可以被多个程序使用，这样就降低了创建数据库连接的开销。数据库连接池的原理也很简单，就是首先在内存存放一定数量的数据库连接，当请求的时候就从连接池中获取一个连接，该请求用完数据库连接后就会释放，于是这个连接就可以被其他程序请求。可以通过设置连接池的参数来控制连接池中的初始连接数、连接的上下限数以及每个连接的最大使用次数、最大空闲时间等等。

自己实现一个数据库连接池
目前主流的数据库连接池有dbcp、c3p0和proxool。其实现原理与上面都差不多，为了更好理解数据库连接池，我们手写一个连接池：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package cp;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
public class ConnectoinPool {
    //存放Connection对象的集合
    private List<Connection> cons = null;
    private String driver = null;
    private String url = null;
    private String user = null;
    private String password = null;
    //连接池中连接的索引
    private int index = 0;
    //数据库连接池中默认大小
    private int size = 5;
    
    public ConnectoinPool(){
        try {
            init();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public ConnectoinPool(int size) {
        this.size = size;
        try {
            init();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //初始化
    private void init() throws SQLException, ClassNotFoundException, IOException{
        this.cons = new ArrayList<Connection>();
        parseProperties();
        Class.forName(driver);
        for(int i=0;i<size;i++){
            Connection con = DriverManager.getConnection(url,user,password);
            cons.add(con);
        }
    }
    //读取properties文件的信息
    private void parseProperties() throws IOException {
        Properties p = new Properties();
        InputStream in = getClass().getResourceAsStream("/db.properties");
        p.load(in);
        if(p.containsKey("driver")){
            driver = p.getProperty("driver");
        }
        if(p.containsKey("url")){
            url = p.getProperty("url");
        }
        if(p.containsKey("user")){
            user = p.getProperty("user");
        }
        if(p.containsKey("password")){
            password = p.getProperty("password");
        }
    }
    
    //获取连接
    public Connection getConnection(){
        Connection con = cons.remove(size-1-index++);
        return con;
    }
    
    //释放连接
    public void release(Connection con) throws SQLException{
        cons.add(con);
        index--;
        con.close();
    }
    
}

创建db.properties配置文件

1
2
3
4
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost/test?useUnicode=true&charset=utf8
user=root
password=1234

然后编写主程序测试各功能是否正常：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package cp;
import java.sql.Connection;
import java.sql.SQLException;
public class TestCp {
    public static void main(String[] args) throws SQLException {
        // 创建一个数据库连接池
        ConnectoinPool cp = new ConnectoinPool();
        // 获取一个连接
        Connection con1 = cp.getConnection();
        System.out.println(con1);
        //释放这个连接
        cp.release(con1);
        // 获取一个连接
        Connection con2 = cp.getConnection();
        System.out.println(con2);
        // 获取一个连接
        Connection con3 = cp.getConnection();
        System.out.println(con3);
        // 获取一个连接
        Connection con4 = cp.getConnection();
        System.out.println(con4);
        // 获取一个连接
        Connection con5 = cp.getConnection();
        System.out.println(con5);
        // 获取一个连接
        Connection con6 = cp.getConnection();
        System.out.println(con6);
    }
}

可以发现，默认连接池有5个连接对象，在释放第一个连接后，连接池仍然有5个连接，所以在程序中创建第6个连接的时候没有报错。

当然这个程序问题很多，比如不能高访问量的情况，而且是单线程的。实际情况应该是，当用户请求一个连接的时候应该创建一个线程处理，这个线程决定该连接何时释放给连接池。通过上面的简单程序，知道了连接池管理数据库连接的原理。下面我们再看看第三方的数据库连接池的使用。

Tomcat7 jdbc pool
要知道在Tomcat7以前的版本中，使用的都是dbcp连接池，但是这个连接池bug太多，Hibernate官方宣布已经不再支持dbcp连接池dbcp连接池的主要问题：

  1. dbcp 是单线程的，为了保证线程安全会锁整个连接池
  2. jdk1.6编译有问题
  3. 结构太复杂

而jdbc pool在克服以上缺点的情况下，还增加了许多优良特性，详情请看这里

其中涉及的异步方式获取连接暂时还不懂，先来学习一下如何在独立的应用中获取连接。首先需要导入Tomcat7官方给的两个jar包：
tomcat-juli.jar（Tomcat的日志模块，在bin目录下）
tomcat-jdbc.jar（jdbc pool连接池，在lib目录下）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
package cp;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import org.apache.tomcat.jdbc.pool.DataSource;
import org.apache.tomcat.jdbc.pool.PoolProperties;
public class TomcatJdbcPool {
    private String driver = null;
    private String url = null;
    private String user = null;
    private String password = null;
    private DataSource datasource = null;
    public TomcatJdbcPool() {
        this.datasource = new DataSource();
        try {
            parseProperties();
            initPoolProperties();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 读取properties文件的信息
    private void parseProperties() throws IOException {
        Properties p = new Properties();
        InputStream in = getClass().getResourceAsStream("/db.properties");
        p.load(in);
        if (p.containsKey("driver")) {
            driver = p.getProperty("driver");
        }
        if (p.containsKey("url")) {
            url = p.getProperty("url");
        }
        if (p.containsKey("user")) {
            user = p.getProperty("user");
        }
        if (p.containsKey("password")) {
            password = p.getProperty("password");
        }
    }
    private void initPoolProperties() {
        PoolProperties p = new PoolProperties();
        p.setUrl(url); // url
        p.setDriverClassName(driver); // 驱动
        p.setUsername(user); // 用户名
        p.setPassword(password); // 密码
        p.setJmxEnabled(true); // 通过JMX注册连接池
        p.setTestWhileIdle(false); // 被空闲对象使用的时候连接是否有效
        p.setTestOnBorrow(true); // 在被对象拿走之前连接是否有效
        p.setValidationQuery("SELECT 1"); // 测试是否为有效连接
        p.setTestOnReturn(false); // 连接返回连接池之前是否有效
        p.setTimeBetweenEvictionRunsMillis(30000); // 验证线程与清除线程之间的毫秒数
        p.setMaxActive(100); // 最大的活动的连接数
        p.setInitialSize(10); // 初始化连接池大小
        p.setMaxWait(10000); // 连接池等待连接返回的最长时间
        p.setRemoveAbandonedTimeout(60); // 设置废弃连接被移除之前的毫秒数
        p.setMinIdle(10); // 最小空闲连接数
        p.setLogAbandoned(true); // 标记废弃连接的堆栈跟踪
        p.setRemoveAbandoned(true); // 超时后是否可以移除连接
        p.setJdbcInterceptors("org.apache.tomcat.jdbc.pool.interceptor.ConnectionState;"
                + "org.apache.tomcat.jdbc.pool.interceptor.StatementFinalizer");
        // jdbc拦截器
        datasource.setPoolProperties(p); // 设置p到数据源中
    }
    public Connection getTomcatJdbcPoolConnection() {
        Connection con = null;
        try {
            con = datasource.getConnection(); // 通过数据源获取连接
            Statement st = con.createStatement();
            ResultSet rs = st.executeQuery("select * from user");
            int cnt = 1;
            while (rs.next()) {
                System.out.println((cnt++) + ". Host:" + rs.getString("Host")
                        + " User:" + rs.getString("User") + " Password:"
                        + rs.getString("Password"));
            }
            rs.close();
            st.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if (con != null)
                try {
                    con.close();
                } catch (Exception ignore) {
                }
        }
        return con;
    }
}

运行结果如下：

jdbc pool 小结

使用这个数据库连接池主要就是设置相关属性，再通过数据源就可以获取连接对象了。由于进行了封装处理，所以不需要自己释放连接。这里通过properties资源文件设置数据库相关的连接属性，这样做的目的不需要修改源代码，提高程序的健壮性。

坚持原创技术分享，您的支持将鼓励我继续创作！