一、数据库连接池
数据库连接池是一个容器，用于存储多个连接对象，这样java程序就不用向系统申请创建新的连接对象，提高了性能。
从连接池中获取的Connection连接对象，使用close方法不是释放掉，而是返回连接池。
标准连接池接口：DataSource
方法：
- 获取连接：getConnection()
- 归还连接：Connection.close()。
常用的连接池技术：
C3P0技术
Druid：阿里巴巴提供的。
C3P0的使用：
- 1、导包 c3p0-0.9.5.2.jar、mchange-commons-java-0.2.12.jar
- 2、定义配置文件：
- 名称： c3p0.properties 或者 c3p0-config.xml
- 路径：直接将文件放在src目录下即可。会自动读取配置文件。
- 3、创建连接池，获取连接对象，归还连接对象
public static void main(String[] args) {
Connection conn = null;
PreparedStatement psttm = null;
try {
DataSource ds = new ComboPooledDataSource();
conn = ds.getConnection();
String sql = "INSERT INTO USER VALUE (null,?,?)";
psttm = conn.prepareStatement(sql);
psttm.setString(1,"やちよ");
psttm.setString(2,"111");
int count = psttm.executeUpdate();
System.out.println(count);
} catch (SQLException e) {
e.printStackTrace();
}finally {
if (psttm != null){
try {
psttm.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null){
try {
conn.close(); //归还到连接池
psttm.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
Druid的使用，与C3P0不同，Druid需要自己写读配置文件的代码
- 1.导包 druid-1.0.9.jar
- 2.写配置文件
- 3.读取配置文件，创建连接池对象，获取连接，归还连接
我们这里也把这些步骤封装成一个JDBCUtils工具类
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
//封装Druid的创建，获取连接对象，释放连接对象，以及配置文件的读取的功能
public class JDBCUtils {
//读取配置文件
static DataSource ds = null;
static {
try {
Properties prop = new Properties();
prop.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
ds = DruidDataSourceFactory.createDataSource(prop);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取Druid连接池的连接对象
* @return
* @throws SQLException
*/
public static Connection getConnnection() throws SQLException {
return ds.getConnection();
}
/**
* 释放资源
* @param conn
* @param sttm
* @param rs
*/
public static void close(Connection conn, Statement sttm, ResultSet rs){
if (rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (sttm!=null){
try {
sttm.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null){
try {
conn.close(); //归还连接
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 释放资源
* @param conn
* @param sttm
*/
public static void close(Connection conn, Statement sttm){
close(conn,sttm,null);
}
}
DruidDemo，看代码变少了好多！
public class Demo {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement psttm = null;
try {
conn = JDBCUtils.getConnnection();
String sql = "DELETE FROM USER WHERE uid = ?;";
psttm = conn.prepareStatement(sql);
psttm.setInt(1,2);
int count = psttm.executeUpdate();
System.out.println(count);
} catch (SQLException e) {
e.printStackTrace();
}finally {
JDBCUtils.close(conn,psttm);
}
}
}
但是查询操作的结果处理也很麻烦，于是我们使用Spring JDBC来封装查询起来的结果。
Spring JDBC
Spring框架中提供了JDBCTemplate类来简化JDBC的开发。
JDBCTemplate的使用方法
- 1.导入jar包
- 2.创建jdbctemplate对象，构造方法的参数是DataSource对象
- 3.方法：
update():执行DML语句。增、删、改语句
-
queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
- 注意：这个方法查询的结果集长度只能是1
-
queryForList():查询结果将结果集封装为list集合
- 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
-
query():查询结果，将结果封装为JavaBean对象
- query的参数：RowMapper
- 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
- new BeanPropertyRowMapper<类型>(类型.class)
queryForObject：查询结果，将结果封装为对象
* 一般用于聚合函数的查询
使用实例：
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import utils.JDBCUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 需求：
1. 修改1号数据的 salary 为 10000
2. 添加一条记录
3. 删除刚才添加的记录
4. 查询id为1的记录，将其封装为Map集合
5. 查询所有记录，将其封装为List
6. 查询所有记录，将其封装为Emp对象的List集合
7. 查询总记录数
*/
public class TestDemo {
JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
@Test// 1. 修改1号数据的 salary 为 10000
public void test1(){
String sql = "UPDATE person SET salary = ? WHERE id = ? ";
template.update(sql,1000,1);
}
@Test // 2. 添加一条记录
public void test2(){
String sql = "INSERT INTO person VALUE (NULL,?,?)";
template.update(sql,"八千代",6000);
}
@Test // 3. 删除记录
public void test3(){
String sql = "DELETE FROM person WHERE id = ?";
template.update(sql,3);
}
@Test // 4. 查询id为4的记录，将其封装为Map集合
public void test4(){
String sql = "SELECT * FROM person WHERE id = ?";
Map<String, Object> map = template.queryForMap(sql, 4);
System.out.println(map); //重写了toString方法
}
// 5. 查询所有记录，将其封装为List
@Test
public void test5(){
String sql = "SELECT * FROM person;";
List<Map<String, Object>> maps = template.queryForList(sql);
for (Map<String, Object> map : maps) {
System.out.println(map.toString());
}
}
@Test
// 6. 查询所有记录，将其封装为Emp对象的List集合 ps:emp表在db1数据库，记得改配置文件
public void test6(){
String sql = "SELECT * FROM emp";
List<EMP> emps = template.query(sql, new BeanPropertyRowMapper<EMP>(EMP.class));
for (EMP emp : emps) {
System.out.println(emp);
}
}
@Test
// 7. 查询总记录数
public void test7(){
String sql = "SELECT COUNT(id) FROM person";
Long total = template.queryForObject(sql, Long.class);
System.out.println("一共条"+total+"记录");
}
}
