释放双眼，带上耳机，听听看~！
什么是数据库连接池：
数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正式针对这个问题提出来的.数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。如下图所示：
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中, 这些数据库连接的数量是由最小数据库连接数来设定的.无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中。
数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:
最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费.
最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作
如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.
如何使用Druid连接池：
第一步：首先下载Druid的jar包，导入环境；
第二步：编写配置文件：
Druid.properties配置文件
2
3
4
5
6
7
8
9
10
11
12
13
14
2driver=com.mysql.cj.jdbc.Driver
3url=jdbc:mysql:///student?serverTimezone=GMT&useSSL=false
4username=root
5password=yanzhiguo140710
6#初始化连接数量#
7initialSize = 5
8#最大连接数量
9maxACtive = 10
10#等待时间 3秒
11maxWait = 3000
12
13
14
第三步：导入配置文件，使用Druid连接池
具体实现方法如下：
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
2
3import com.alibaba.druid.pool.DruidDataSource;
4import com.alibaba.druid.pool.DruidDataSourceFactory;
5
6import javax.sql.DataSource;
7import java.io.IOException;
8import java.io.InputStream;
9import java.sql.Connection;
10import java.sql.PreparedStatement;
11import java.sql.ResultSet;
12import java.sql.SQLException;
13import java.util.Properties;
14
15public class DruidDemo {
16 public static void main(String[] args) {
17 //1.导入jar包
18 //2.定义配置文件
19 //3.加载配置文件
20 Properties pro = new Properties();
21 InputStream resourceAsStream = DruidDemo.class.getClassLoader().getResourceAsStream("Druid.properties");
22 Connection connection = null;
23 PreparedStatement preparedStatement = null;
24 ResultSet resultSet = null;
25 try {
26 pro.load(resourceAsStream);
27 DataSource ds = DruidDataSourceFactory.createDataSource(pro);
28 connection = ds.getConnection();
29 String sql = "Select * from goods";
30 preparedStatement = connection.prepareStatement(sql);
31 resultSet = preparedStatement.executeQuery();
32 while (resultSet.next()){
33 Integer id = resultSet.getInt("id");
34 String name = resultSet.getString("name");
35 String value = resultSet.getString("value");
36 System.out.println(id+" "+name+" "+value);
37 }
38 } catch (IOException e) {
39 e.printStackTrace();
40 } catch (SQLException e) {
41 e.printStackTrace();
42 } catch (Exception e) {
43 e.printStackTrace();
44 } finally {
45 if (connection!=null){
46 try {
47 connection.close();
48 } catch (SQLException e) {
49 e.printStackTrace();
50 }
51 }
52 if (resultSet!=null){
53 try {
54 resultSet.close();
55 } catch (SQLException e) {
56 e.printStackTrace();
57 }
58 }
59 if (preparedStatement!=null){
60 try {
61 preparedStatement.close();
62 } catch (SQLException e) {
63 e.printStackTrace();
64 }
65 }
66
67 }
68
69 }
70
71}
72
73结果是：
这样就完成了一个小小的案例。但是总不能每一次使用都这样使用吧，这就需要写一个DruidUtil的工具类，这样才能能方便快捷的写代码。
DruidUtil类：
DruidUtil需要实现获取数据库连接池、数据库的连接、数据库连接资源的关闭。
具体的实现代码：
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
102
103
104
105
106
2
3import com.alibaba.druid.pool.DruidDataSourceFactory;
4
5import javax.sql.DataSource;
6import java.io.IOException;
7import java.io.InputStream;
8import java.sql.Connection;
9import java.sql.PreparedStatement;
10import java.sql.ResultSet;
11import java.sql.SQLException;
12import java.util.Properties;
13
14public class DruidUtil {
15
16 private static DataSource ds;
17
18 static {
19 //加载配置文件和建立连接池
20 try {
21 Properties pro = new Properties();
22 InputStream resourceAsStream = DruidUtil.class.getClassLoader().getResourceAsStream("Druid.properties");
23 pro.load(resourceAsStream);
24 ds = DruidDataSourceFactory.createDataSource(pro);
25 } catch (IOException e) {
26 e.printStackTrace();
27 } catch (Exception e) {
28 e.printStackTrace();
29 }
30 }
31
32 /**
33 * 获取数据库连接池
34 * @return
35 */
36 public static DataSource getDataSource(){
37 return ds;
38 }
39
40
41 /**
42 * 获取连接池中的一个连接
43 * @return
44 * @throws SQLException
45 */
46 public Connection getconnection() throws SQLException {
47 return ds.getConnection();
48
49 }
50
51
52 /**
53 * 关闭数据库的资源 三个对象都存在时
54 * @param conn
55 * @param res
56 * @param pstmt
57 */
58 public static void close(Connection conn, ResultSet res, PreparedStatement pstmt){
59 if (conn!=null){
60 try {
61 conn.close();
62 } catch (SQLException e) {
63 e.printStackTrace();
64 }
65 }
66 if (res!=null){
67 try {
68 res.close();
69 } catch (SQLException e) {
70 e.printStackTrace();
71 }
72 }
73 if (pstmt!=null){
74 try {
75 pstmt.close();
76 } catch (SQLException e) {
77 e.printStackTrace();
78 }
79 }
80 }
81
82 /**
83 * 关闭数据库的连接（只存在Connection和PreparedStatement对象时）
84 * @param conn
85 * @param pstmt
86 */
87 public void close(Connection conn,PreparedStatement pstmt){
88 if (conn!=null){
89 try {
90 conn.close();
91 } catch (SQLException e) {
92 e.printStackTrace();
93 }
94 }
95 if (pstmt!=null){
96 try {
97 pstmt.close();
98 } catch (SQLException e) {
99 e.printStackTrace();
100 }
101 }
102 }
103
104}
105
106上述的配置文件还是最上面的那一个，并没有改变。
我们来测试一下这个工具类写的正确与否：
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
2
3import Util.DruidUtil;
4
5import javax.sql.DataSource;
6import java.sql.Connection;
7import java.sql.PreparedStatement;
8import java.sql.ResultSet;
9import java.sql.SQLException;
10
11public class DruidDemo2 {
12 public static void main(String[] args) throws SQLException {
13 DataSource ds = DruidUtil.getDataSource();
14 Connection connection = ds.getConnection();
15 String sql = "select * from goods";
16 PreparedStatement preparedStatement = connection.prepareStatement(sql);
17 ResultSet resultSet = preparedStatement.executeQuery();
18 while (resultSet.next()){
19 Integer id = resultSet.getInt("id");
20 String name = resultSet.getString("name");
21 String value = resultSet.getString("value");
22 System.out.println(id+" "+name+" "+value);
23 }
24 DruidUtil.close(connection,resultSet,preparedStatement);
25 }
26}
27
28结果是：
这样就验证了编写的工具类是正确的！
数据库的连接池就说完了，下一篇博客复习一下JDBCTemplate的使用方法！
