JDBC和连接池0410.数据库连接池10.1传统连接弊端分析
- 传统获取Connection问题分析
- 传统的 JDBC 数据库连接使用DriverManager来获取，每次向数据库建立连接的时候都要将Connection加载到内存中，再验证IP地址，用户名和密码（约0.05s~1s时间）。需要数据库连接的时候，就向数据库要求一个，频繁地进行数据库连接操作将会占用很多的系统资源，容易造成服务器崩溃
- 每一次数据库连接，使用完后都得断开，如果程序出现异常而未能关闭，将导致数据库内存泄漏，最终将导致重启数据库
- 传统获取连接的方式，不能控制创建的连接数量，如连接过多，也可能导致内存泄漏，MySQL崩溃
- 解决传统开发中的数据库连接问题，可以采用数据库连接池技术（connection pool）
例子1
package li.jdbc.datasource;import li.jdbc.utils.JDBCUtils;import org.junit.Test;import java.sql.Connection;public class ConQuestion { @Test public void testCon(){ for (int i = 0; i < 5000; i++) { //使用传统的jdbc方式得到连接 Connection connection = JDBCUtils.getConnection(); //这里做一些工作.... //不关闭连接资源，使其一直占用 } }}出现的异常：
java.lang.RuntimeException: com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Data source rejected establishment of connection, message from server: "Too many connections"
例子2：
package li.jdbc.datasource;import li.jdbc.utils.JDBCUtils;import org.junit.Test;import java.sql.Connection;public class ConQuestion { @Test public void testCon(){ long start = System.currentTimeMillis(); System.out.println("开始连接..."); for (int i = 0; i < 5000; i++) { //使用传统的jdbc方式得到连接 Connection connection = JDBCUtils.getConnection(); //这里做一些工作.... JDBCUtils.close(null,null,connection);//每次连接完都正常关闭连接资源 } long end = System.currentTimeMillis(); System.out.println("传统方式连接5000次耗时："+(end-start));//20171ms }}每次连接完都正常关闭连接资源，可以看到5000次连接数据库需要耗时20171ms
10.2数据库连接池原理
- 数据库连接池基本介绍
- 预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再将连接放回连接池中。
- 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个
- 当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中
- 数据库连接池种类
- JDBC的数据库连接池使用javax.sql.DataSource来表示，DataSource只是一个接口，该接口通常由第三方提供实现 [提供相应的jar包]
- C3P0数据库连接池，速度相对较慢，稳定性不错（hibernate，spring）
- DBCP数据库连接池，速度相对C3P0较快，但不稳定
- Proxool数据库连接池，有监控连接池状态的功能，稳定性较C3P0差一点
- BoneCP数据库连接池，速度快
- Druid（德鲁伊）是阿里提供的数据库连接池，集DBCP、C3P0、Proxool优点于一身的数据库连接池
10.3C3P0方式10.3.1方式1-相关参数在程序中指定
使用代码实现c3p0数据库连接池
首先在网上下载c3p0jar包，并将其复制到项目的lib文件夹中，右键选择add as library
package li.jdbc.datasource;import com.mchange.v2.c3p0.ComboPooledDataSource;import org.junit.Test;import java.io.FileInputStream;import java.sql.Connection;import java.util.Properties;/** * 演示c3p0的使用 */public class C3P0_ { //方式1：相关参数在程序中指定，user，url，password等 @Test public void testC3P0_01() throws Exception { //1.创建一个数据源对象 ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource(); //2.通过配置文件mysql.properties获取相关的连接信息 Properties properties = new Properties(); properties.load(new FileInputStream("src\\mysql.properties")); //读取相关的属性值 String user = properties.getProperty("user"); String password = properties.getProperty("password"); String url = properties.getProperty("url"); String driver = properties.getProperty("driver"); //给数据源 comboPooledDataSource设置相关的参数 //注意：连接管理 是由comboPooledDataSource来管理 comboPooledDataSource.setDriverClass(driver); comboPooledDataSource.setJdbcUrl(url); comboPooledDataSource.setUser(user); comboPooledDataSource.setPassword(password); //设置初始化连接数 comboPooledDataSource.setInitialPoolSize(10); //最大连接数--连接请求超过最大连接数据将进入等待队列 comboPooledDataSource.setMaxPoolSize(50); //测试连接池的效率 long start = System.currentTimeMillis(); for (int i = 0; i < 5000; i++) { Connection connection = comboPooledDataSource.getConnection();//这个方法就是从DataSource 接口实现的 //System.out.println("连接成功"); connection.close(); } long end = System.currentTimeMillis(); System.out.println("c3p0 5000次连接mysql 耗时=" + (end - start)); }}c3p0方式一：5000次的连接耗时553ms
10.3.2方式2-使用配置文件模板来完成
首先如10.3.1一样将jar包加入到项目中
然后将c3p0提供的配置文件c3p0-config.xml复制到src目录下，该文件指定了连接数据库和连接池的相关参数
c3p0-config.xml：
com.mysql.jdbc.Driver jdbc:mysql://127.0.0.1:3306/hsp_db02 root 123456 5 10 5 50 5 2 测试程序：
package li.jdbc.datasource;import com.mchange.v2.c3p0.ComboPooledDataSource;import org.junit.Test;import java.sql.Connection;/** * 演示c3p0的使用 */public class C3P0_ { //方式2：使用配置文件模板来完成 //将c3p0提供的配置文件c3p0-config.xml复制到src目录下 // 该文件指定了连接数据库和连接池的相关参数 @Test public void testC3P0_02() throws Exception { ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("hello"); //测试5000次连接诶mysql long start = System.currentTimeMillis(); System.out.println("开始执行..."); for (int i = 0; i < 5000; i++) { Connection connection = comboPooledDataSource.getConnection(); //System.out.println("连接成功"); connection.close(); } long end = System.currentTimeMillis(); System.out.println("c3p0的第二种方式 5000次连接mysql 耗时=" + (end - start)); }}c3p0的第二种方式 5000次连接mysql 耗时=533ms
10.4德鲁伊连接池
首先将Druid的jar包复制到项目的lib文件夹中，点击右键，选择add as library
jar包在该网站可以下载 Central Repository: com/alibaba/druid (maven.org)
然后将提供的配置文件的druid.properties(文件名可以随意)复制到src目录下
druid.properties:
#key=valuedriverClassName=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/hsp_02?rewriteBatchedStatements=true#url=jdbc:mysql://localhost:3306/hsp_02username=rootpassword=123456#initial connection SizeinitialSize=10#min idle connecton sizeminIdle=5#max active connection sizemaxActive=50#max wait time (5000 mil seconds) 在等待队列中的最大等待时间maxWait=5000测试程序：
package li.jdbc.datasource;import com.alibaba.druid.pool.DruidDataSourceFactory;import org.junit.Test;import javax.sql.DataSource;import java.io.FileInputStream;import java.sql.Connection;import java.util.Properties;/** * 测试德鲁伊Druid的使用 */public class Druid_ { @Test public void testDruid() throws Exception { //1.加入Druid包 //2.加入配置文件 druid.properties,将该文件复制到项目的src目录下面 //3.创建Properties对象，读取配置文件 Properties properties = new Properties(); properties.load(new FileInputStream("src\\druid.properties")); //4.创建一个指定参数的数据库连接池,Druid连接池 DataSource dataSource = DruidDataSourceFactory.createDataSource(properties); long start = System.currentTimeMillis(); for (int i = 0; i < 5000; i++) { Connection connection = dataSource.getConnection(); //System.out.println("连接成功！"); connection.close(); } long end = System.currentTimeMillis(); System.out.println("Druid连接池 操作5000次耗时="+(end-start)); }}德鲁伊连接池操作5000次的总耗时为434ms
5000次连接池的时间和c3p0的时间差不多，但是当连接数量到50万、500万时差距就会很明显，因此在实际开发中推荐使用Druid连接池。
10.4.1德鲁伊工具类
将之前7.1的JDBCUtils工具类改为Druid（德鲁伊）实现
通过德鲁伊数据库连接池获取连接对象
工具类：JDBCUtilsByDruid
package li.jdbc.datasource;import com.alibaba.druid.pool.DruidDataSourceFactory;import javax.sql.DataSource;import java.io.FileInputStream;import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import java.util.Properties;/** * 基于Druid数据库连接池的工具类 */public class JDBCUtilsByDruid { private static DataSource ds; //在静态代码块完成ds的初始化 //静态代码块在加载类的时候只会执行一次，因此数据源也只会初始化一次 static { Properties properties = new Properties(); try { properties.load(new FileInputStream("src\\druid.properties")); ds = DruidDataSourceFactory.createDataSource(properties); } catch (Exception e) { e.printStackTrace(); } } //编写getConnection方法 public static Connection getConnection() throws SQLException { return ds.getConnection(); } //关闭连接（注意：在数据库连接池技术中，close不是真的关闭连接，而是将Connection对象放回连接池中） public static void close(ResultSet resultSet, Statement statemenat, Connection connection) { try { if (resultSet != null) { resultSet.close(); } if (statemenat != null) { statemenat.close(); } if (connection != null) { connection.close(); } } catch (SQLException e) { throw new RuntimeException(e); } }}测试程序：JDBCUtilsByDruid_Use
package li.jdbc.datasource;import org.junit.Test;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.util.Date;public class JDBCUtilsByDruid_Use { @Test public void testSelect() { System.out.println("使用druid方式完成"); //1.得到连接 Connection connection = null; //2.组织一个sql语句 String sql = "Select * from actor where id >=?"; //3.创建PreparedStatement对象 PreparedStatement preparedStatement = null; ResultSet set = null; try { connection = JDBCUtilsByDruid.getConnection(); /** * Connection是个接口，是由sun公司定义的规范，根据Connection的实现类不同，close方法也不同 * mysql的厂商的实现类是直接把连接关闭，Alibaba的实现是将引用的连接放回到连接池等待下一次引用 * 因此在Druid中的close方法并不是真正地关闭连接 */ System.out.println(connection.getClass());//运行类型 class com.alibaba.druid.pool.DruidPooledConnection preparedStatement = connection.prepareStatement(sql); preparedStatement.setInt(1, 1);//给?号赋值 //执行sql,得到结果集 set = preparedStatement.executeQuery(); //遍历该结果集 while (set.next()) { int id = set.getInt("id"); String name = set.getString("name"); String sex = set.getString("sex"); Date borndate = set.getDate("borndate"); String phone = set.getString("phone"); System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone); } } catch (SQLException e) { e.printStackTrace(); } finally { //关闭资源（不是真的关闭连接，而是将Connection对象放回连接池中） JDBCUtilsByDruid.close(set, preparedStatement, connection); } }}
注意：
Connection是个接口，是由sun公司定义的规范，根据Connection的实现类不同，close方法也不同
mysql的厂商的实现类是直接把连接关闭，Alibaba的实现是将引用的连接放回到连接池等待下一次引用
因此在Druid中的close方法并不是真正地关闭连接，而是将Connection对象放回连接池中
10.5Apache-DBUtils10.5.1resultSet问题
先分析一个问题
在之前的程序中，执行sql语句后返回的结果集存在如下问题：
关闭connection后，resultSet结果集无法使用
如果要使用结果集，就不能关闭连接，不能关闭连接，就会反过来影响别的程序去连接数据库，就会对多并发程序造成很大的影响
resultSet不利于数据的管理
如果其它的方法或者程序想要使用结果集，也需要一直保持连接，影响其他程序对数据库的连接
使用返回信息也不方便
解决方法：
定义一个类，该类的属性和表的字段是对应关系/映射关系，即用类的属性和表的字段(列)关联起来
我们把这种类叫做JavaBean，或者POJO，Domain。
一个Actor对象就对应一条actor表的记录，将Actor对象放入到ArrayList集合中（将结果集的记录封装到ArrayList中）
10.5.2土方法完成封装
Actor类（JavaBean）：
package li.jdbc.datasource;import java.util.Date;/** * Actor对象和actor表的记录对应 */public class Actor {//JavaBean/POJO/Domain private Integer id; private String name; private String sex; private Date borndate; private String phone; public Actor() {//一定要给一个无参构造器[反射需要] } public Actor(Integer id, String name, String sex, Date borndate, String phone) { this.id = id; this.name = name; this.sex = sex; this.borndate = borndate; this.phone = phone; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public Date getBorndate() { return borndate; } public void setBorndate(Date borndate) { this.borndate = borndate; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } @Override public String toString() { return "\nActor{" + "id=" + id + ", name='" + name + '\'' + ", sex='" + sex + '\'' + ", borndate=" + borndate + ", phone='" + phone + '\'' + '}'; }}测试程序：
package li.jdbc.datasource;import org.junit.Test;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.Date;public class JDBCUtilsByDruid_Use { //使用土方法尝试解决ResultSet问题==封装=>ArrayList @Test public void testSelectToArrayList() {//也可以设置返回值 System.out.println("使用druid方式完成"); //1.得到连接 Connection connection = null; //2.组织一个sql语句 String sql = "Select * from actor where id >=?"; //3.创建PreparedStatement对象 PreparedStatement preparedStatement = null; ResultSet set = null; ArrayList list = new ArrayList();//创建ArrayList对象，存放actor对象 try { connection = JDBCUtilsByDruid.getConnection(); preparedStatement = connection.prepareStatement(sql); preparedStatement.setInt(1, 1);//给?号赋值 //执行sql,得到结果集 set = preparedStatement.executeQuery(); //遍历该结果集 while (set.next()) { int id = set.getInt("id"); String name = set.getString("name"); String sex = set.getString("sex"); Date borndate = set.getDate("borndate"); String phone = set.getString("phone"); //把得到的当前 resultSet的一条记录，封装到一个Actor对象中，并放入arraylist集合 list.add(new Actor(id,name,sex,borndate,phone)); } System.out.println("list集合数据="+list); //or for (Actor actor:list) { System.out.println("id="+actor.getId()+"\t"+"name="+actor.getName()); } } catch (SQLException e) { e.printStackTrace(); } finally { //关闭资源（不是真的关闭连接，而是将Connection对象放回连接池中） JDBCUtilsByDruid.close(set, preparedStatement, connection); } //因为ArrayList 和 connection 没有任何关联，所以该集合可以复用 //return list; }}
10.5.3Apache-DBUtils
基本介绍
commons-dbutils是Apache组织提供的一个开源 JDBC工具类库，它是对 JDBC的封装，使用dbutils能极大简化 JDBC编码的工作量。
DbUtils类
- QueryRunner类：该类封装了SQL的执行，是线程安全的。可以实现增、删、改、查、批处理
- 使用QueryRunner类实现查询
- ResultSetHandler接口：该接口用于处理 java.sql.ResultSet，将数据按要求转换为另一种形式
| 方法 | 解释 |
|---|---|
| ArrayHandler | 将结果集中的第一行数据转成对象数组 |
| ArrayListHandler | 把结果集中的每一行数据都转成一个数组，再存放到List中 |
| BeanHandler | 将结果集中的第一行数据封装到一个对应的JavaBean实例中 |
| BeanListHandler | 将结果集中的每一行数据都封装到一个对应的JavaBean实例中，再存放到List中 |
| ColumnListHandler | 将结果集中某一列的数据存放到List中 |
| KeyedHandler（name） | 将结果集中的每行数据都封装到Map中，再把这些map再存放到一个map里，其key为指定的key |
| MapHandler | 将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值 |
| MapListHandler | 将结果集中的每一行数据都封装到一个Map里，然后再存放到List |
DBUtils的jar包下载可以去官网下载
应用实例
使用DBUtils+数据库连接池（德鲁伊）方式，完成对表actor的crud操作
首先将DBUtils的jar包添加到项目的libs文件夹下面，右键选择add as library
Actor类详见10.5.2
DBUtils_USE：
package li.jdbc.datasource;import org.apache.commons.dbutils.QueryRunner;import org.apache.commons.dbutils.handlers.BeanListHandler;import org.junit.Test;import java.sql.Connection;import java.sql.SQLException;import java.util.List;public class DBUtils_USE { //使用Apache-DBUtils工具类 + Druid 完成对表的crud操作 @Test public void testQueryMany() throws SQLException {//返回结果是多行的情况 //1.得到连接（Druid） Connection connection = JDBCUtilsByDruid.getConnection(); //2.使用DBUtils类和接口（先引入相关的jar，加入到本地的project） //3.创建QueryRunner QueryRunner queryRunner = new QueryRunner(); //4.然后就可以执行相关的方法，返回ArrayList结果集 //String sql = "Select * from actor where id >=?"; //注意 ：sql语句也可以查询部分的列,没有查询的属性就在actor对象中置空 String sql = "Select id,name from actor where id >=?"; /** * (1) query方法就是执行sql语句，得到resultSet--封装到-->Arraylist集合中 * (2) 然后返回集合 * (3) connection就是连接 * (4) sql：执行的sql语句 * (5) new BeanListHandler(Actor.class): 将resultSet->Actor对象->封装到ArrayList * 底层使用反射机制，去获取 Actor的属性，然后进行封装 * (6) 1 就是给sql语句中的?赋值,可以有多个值，因为是可变参数 * (7) 底层得到的resultSet，会在query关闭,同时也会关闭PreparedStatement对象 */ List list = queryRunner.query(connection, sql, new BeanListHandler(Actor.class), 1); System.out.println("输出集合的信息："); for (Actor actor : list) { System.out.print(actor); } //释放资源 JDBCUtilsByDruid.close(null, null, connection); }}
10.5.4ApDBUtils源码分析
在上述10.5.3代码中，在List list = queryRunner.query(connection, sql, new BeanListHandler(Actor.class), 1);语句旁打上断点，点击debug，点击step into
光标跳转到如下方法：
public T query(Connection conn, String sql, ResultSetHandler rsh, Object... params) throws SQLException { PreparedStatement stmt = null;//定义PreparedStatement对象 ResultSet rs = null;//接收返回的resultSet T result = null;//返回ArrayList try { stmt = this.prepareStatement(conn, sql);//创建PreparedStatement this.fillStatement(stmt, params);//对SQL语句进行?赋值 rs = this.wrap(stmt.executeQuery());//执行SQL，返回resultSet result = rsh.handle(rs);//将返回的resultSet-->封装到ArrayList中[使用反射，对传入的class对象进行处理] } catch (SQLException e) { this.rethrow(e, sql, params); } finally { try { close(rs);//关闭resultSet } finally { close(stmt);//关闭preparedStatement } } return result;//返回ArrayList}