浅谈JDBC（二）：数据库连接池以及Spring JDBC：JDBCTemplate
一. 数据库连接池
1. 概述
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。
其实就是一个容器(集合)，存放数据库连接的容器。
当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
2. 好处
1． 资源重用
2． 更快的系统响应速度
3． 新的资源分配手段
4． 统一的连接管理，避免数据库连接泄漏
简单的来说就是：
- 节约资源
- 用户访问高效
3. 实现
-
标准接口：DataSource javax.sql包下的
1. 方法：
* 获取连接：getConnection()
* 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接 -
一般我们不去实现它，有数据库厂商来实现
1. C3P0：数据库连接池技术
2. Druid：数据库连接池实现技术，由阿里巴巴提供的
4. C3P0:数据库连接池技术
- 导入jar包 (两个) c3p0-0.9.5.2.jar，mchange-commons-java-0.2.12.jar。
不要忘记导入数据库驱动jar包
- 定义配置文件：
* 名称： c3p0.properties 或者 c3p0-config.xml
* 路径：直接将文件放在src目录下即可。
例：（ c3p0-config.xml）：
<c3p0-config>
<!-- 使用默认的配置读取连接池对象 -->
<default-config>
<!-- 连接参数 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db2</property>
<property name="user">username</property>
<property name="password">password</property>
<!-- 连接池参数 -->
<!-- 初始化申请的连接数量 -->
<property name="initialPoolSize">5</property>
<!-- 最大的连接数 -->
<property name="maxPoolSize">10</property>
<!-- 超时时间（等待时间） -->
<property name="checkoutTimeout">3000</property>
</default-config>
<!-- 使用指定的“otherc3p0”的配置读取连接池对象 -->
<named-config name="otherc3p0">
<!-- 连接参数 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db2</property>
<property name="user">username</property>
<property name="password">passwod</property>
<!-- 连接池参数 -->
<!-- 初始化申请的连接数量 -->
<property name="initialPoolSize">5</property>
<!-- 最大连接数 -->
<property name="maxPoolSize">8</property>
<!-- 超时时间（等待时间） -->
<property name="checkoutTimeout">1000</property>
</named-config>
</c3p0-config>
如果是使用c3p0.properties，则需要创建Properties对象，通过调用类加载器ClassLoad的getResourceAsStream()方法获取c3p0.properties的字节流，然后使用Properties获取对应的字符串。
- 创建核心对象 数据库连接池对象 ComboPooledDataSource
DataSource ds = new ComboPooledDataSource();
- 获取连接： getConnection
Connection connection = ds.getConnection();
- 代码演示：
package Test01;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
public class JDBCDemo05 {
public static void main(String[] args) throws SQLException {
// 1. 创建数据库连接池对象
DataSource ds = new ComboPooledDataSource();
// 2. 获取连接对象
Connection connection = ds.getConnection();
System.out.println(connection);
}
}
5.Druid:数据库连接池实现技术
数据库连接池实现技术，由阿里巴巴提供的
- 步骤：
1. 导入jar包 druid-1.0.9.jar
2. 定义配置文件：
* 是properties形式的
* 可以叫任意名称，可以放在任意目录下
3. 加载配置文件。Properties
4. 获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
5. 获取连接：getConnection - 代码演示：
package Test01;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
public class DruidDemo01 {
public static void main(String[] args){
Connection connection = null;
try {
// 1. 加载配置文件
Properties pro = new Properties();
ClassLoader classLoader = DruidDemo01.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("druid.properties");
pro.load(is);
// 2. 获取连接池对象
DataSource ds = DruidDataSourceFactory.createDataSource(pro);
// 3. 获取连接
connection = ds.getConnection();
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
-
定义工具类
- 定义一个类 JDBCUtils
- 提供静态代码块加载配置文件，初始化连接池对象
- 提供方法
- 获取连接方法：通过数据库连接池获取连接
- 释放资源
- 获取连接池的方法
-
代码演示：
package Test01;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
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;
public class JDBCUtilsDemo02 {
private static DataSource ds;
static {
try {
Properties pro = new Properties();
ClassLoader classLoader = JDBCUtilsDemo02.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("druid.properties");
pro.load(is);
ds = DruidDataSourceFactory.createDataSource(pro);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public static DataSource getDs(){
return ds;
}
public static void close(Statement statement, Connection connection){
if(statement != null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(connection != null){
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(ResultSet resultSet,Statement statement,Connection connection){
if(resultSet != null){
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
close(statement,connection);
}
}
二. Spring JDBC
1. 概述
为了使JDBC更加易于使用，Spring 在 JDBC API 上定义了一个抽象层，以此建立一个 JDBC 存取框架
作为 Spring JDBC 框架的核心，JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法。每个模板方法都能控制整个过程，并允许覆盖过程中的特定任务。通过这种方式，可以在尽可能保留灵活性的情况下，将数据库存取工作量降到最低。
Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
2. 步骤
- 导入jar包
- 创建JdbcTemplate对象。依赖于数据源DataSource
JdbcTemplate template = new JdbcTemplate(ds);
- 调用JdbcTemplate的方法来完成CRUD的操作
- 执行DML语句。增、删、改语句
update()
- 查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
queryForMap()
注意：这个方法查询的结果集长度只能是1
3. 查询结果将结果集封装为list集合
queryForList():
注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
- 查询结果，将结果封装为JavaBean对象
query()
query的参数：RowMapper
一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
new BeanPropertyRowMapper<类型>(类型.class)
- 查询结果，将结果封装为对象
queryForObject()
一般用于聚合函数的查询
3. 练习
- 需求：
- 修改1号数据的 salary 为 10000
- 添加一条记录
- 删除刚才添加的记录
- 查询id为1的记录，将其封装为Map集合
- 查询所有记录，将其封装为List
- 查询所有记录，将其封装为Emp对象的List集合
- 查询总记录数
代码演示（只是用Test注解测试）：
package Test01;
import datasource.domain.Emp;
import datasource.utils.JDBCUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
public class JDBCTemplateTest {
// 获取JdbcTemplate对象
private JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtilsDemo02.getDs());
// 1. 修改1号数据的 salary 为 10000
@Test
public void test01(){
String sql = "update emp set salary = 10000 where id = ?";
int count = jdbcTemplate.update(sql,1);
System.out.println(count);
}
// 2. 添加一条记录
@Test
public void test02(){
String sql = "insert into emp(id,name,salary) values(1015,?,?)";
int count = jdbcTemplate.update(sql,"郭靖",9797);
System.out.println(count);
}
// 3. 删除刚才添加的记录
@Test
public void test03(){
String sql = "delete from emp where id = ?";
int count = jdbcTemplate.update(sql,1015);
System.out.println(count);
}
// 4. 查询id为1的记录，将其封装为Map集合
@Test
public void test04(){
String sql = "select * from emp where id = ?";
Map<String, Object> map = jdbcTemplate.queryForMap(sql,1);
System.out.println(map);
}
// 5. 查询所有记录，将其封装为List
@Test
public void test05(){
String sql = "select * from emp";
List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
Iterator<Map<String, Object>> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
// 6. 查询所有记录，将其封装为Emp对象的List集合
@Test
public void test06(){
String sql = "select * from emp";
List<Emp> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
Iterator<Emp> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
// 7. 查询总记录数
@Test
public void test07(){
JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
String sql = "select count(id) from emp";
Long aLong = jdbcTemplate.queryForObject(sql, Long.class);
System.out.println(aLong);
}
}