JDBC和连接池04
10.数据库连接池
10.1传统连接弊端分析
- 传统获取Connection问题分析
- 传统的 JDBC 数据库连接使用DriverManager来获取,每次向数据库建立连接的时候都要将Connection加载到内存中,再验证IP地址,用户名和密码(约0.05s~1s时间)。需要数据库连接的时候,就向数据库要求一个,频繁地进行数据库连接操作将会占用很多的系统资源,容易造成服务器崩溃
- 每一次数据库连接,使用完后都得断开,如果程序出现异常而未能关闭,将导致数据库内存泄漏,最终将导致重启数据库
- 传统获取连接的方式,不能控制创建的连接数量,如连接过多,也可能导致内存泄漏,MySQL崩溃
- 解决传统开发中的数据库连接问题,可以采用数据库连接池技术(connection pool)
![image-20221015204446601](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221015204446601.png)
例子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
![image-20221015202550962](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221015202550962.png)
10.2数据库连接池原理
- 数据库连接池基本介绍
- 预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从“缓冲池”中取出一个,使用完毕之后再将连接放回连接池中。
- 数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个
- 当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中
![image-20221015213901814](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221015213901814.png)
- 数据库连接池种类
- 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
![image-20221016163549798](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016163549798.png)
![image-20221016163342849](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016163342849.png)
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
![image-20221016170136839](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016170136839.png)
10.3.2方式2-使用配置文件模板来完成
首先如10.3.1一样将jar包加入到项目中
然后将c3p0提供的配置文件c3p0-config.xml复制到src目录下,该文件指定了连接数据库和连接池的相关参数
c3p0-config.xml:
<c3p0-config>
<!--数据源的名称,代表连接池,名字是随意的 -->
<named-config name="hello">
<!-- 驱动类 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<!-- url-->
<property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/hsp_db02</property>
<!-- 用户名 -->
<property name="user">root</property>
<!-- 密码 -->
<property name="password">123456</property>
<!-- 每次增长的连接数-->
<property name="acquireIncrement">5</property>
<!-- 初始的连接数 -->
<property name="initialPoolSize">10</property>
<!-- 最小连接数 -->
<property name="minPoolSize">5</property>
<!-- 最大连接数 -->
<property name="maxPoolSize">50</property>
<!-- 可连接的最多的命令对象数 -->
<property name="maxStatements">5</property>
<!-- 每个连接对象可连接的最多的命令对象数 -->
<property name="maxStatementsPerConnection">2</property>
</named-config>
</c3p0-config>
测试程序:
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
![image-20221016171934713](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016171934713.png)
10.4德鲁伊连接池
首先将Druid的jar包复制到项目的lib文件夹中,点击右键,选择add as library
![image-20221016172740596](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016172740596.png)
jar包在该网站可以下载 Central Repository: com/alibaba/druid (maven.org)
然后将提供的配置文件的druid.properties(文件名可以随意)复制到src目录下
druid.properties:
#key=value
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/hsp_02?rewriteBatchedStatements=true
#url=jdbc:mysql://localhost:3306/hsp_02
username=root
password=123456
#initial connection Size
initialSize=10
#min idle connecton size
minIdle=5
#max active connection size
maxActive=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
![image-20221016175530575](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016175530575.png)
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);
}
}
}
![image-20221016185603453](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016185603453.png)
注意:
Connection是个接口,是由sun公司定义的规范,根据Connection的实现类不同,close方法也不同
mysql的厂商的实现类是直接把连接关闭,Alibaba的实现是将引用的连接放回到连接池等待下一次引用
因此在Druid中的close方法并不是真正地关闭连接,而是将Connection对象放回连接池中
10.5Apache-DBUtils
10.5.1resultSet问题
先分析一个问题
在之前的程序中,执行sql语句后返回的结果集存在如下问题:
-
关闭connection后,resultSet结果集无法使用
如果要使用结果集,就不能关闭连接,不能关闭连接,就会反过来影响别的程序去连接数据库,就会对多并发程序造成很大的影响
-
resultSet不利于数据的管理
如果其它的方法或者程序想要使用结果集,也需要一直保持连接,影响其他程序对数据库的连接
-
使用返回信息也不方便
![image-20221016194216492](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016194216492.png)
解决方法:
定义一个类,该类的属性和表的字段是对应关系/映射关系,即用类的属性和表的字段(列)关联起来
我们把这种类叫做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<Actor> 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;
}
}
![image-20221016202536169](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016202536169.png)
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操作
![image-20221016205404120](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016205404120.png)
首先将DBUtils的jar包添加到项目的libs文件夹下面,右键选择add as library
![image-20221016210631987](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016210631987.png)
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<Actor> 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);
}
}
![image-20221016213812415](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016213812415.png)
10.5.4ApDBUtils源码分析
在上述10.5.3代码中,在List<Actor> list = queryRunner.query(connection, sql, new BeanListHandler<>(Actor.class), 1);
语句旁打上断点,点击debug,点击step into
![image-20221016214206359](https://liyuelian.oss-cn-shenzhen.aliyuncs.com/imgs/image-20221016214206359.png)
光标跳转到如下方法:
public <T> T query(Connection conn, String sql, ResultSetHandler<T> 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
}
标签:JDBC,04,public,connection,sql,import,连接,连接池
From: https://www.cnblogs.com/liyuelian/p/16797382.html