数据库连接池

概念：其实就是一个容器 (集合)，存放数据库连接的容器。

当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。image.png

好处

  1. 节约资源
  2. 用户访问高效

实现

标准接口：DataSource javax.sql 包下的
方法：

  • 获取连接：getConnection()
  • 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接

一般我们不去实现它，有数据库厂商来实现

  1. C3P0：数据库连接池技术
  2. Druid：数据库连接池实现技术，由阿里巴巴提供的

C3P0：数据库连接池技术

但有点老

步骤

  1. 导入jar包 (两个) c3p0-0.9.5.2.jar、mchange-commons-java-0.2.12.jar，不要忘记导入数据库驱动jar包
  2. 定义配置文件：
    名称： c3p0.properties 或者 c3p0-config.xml
    路径：直接将文件放在src目录下即可。
  3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
  4. 获取连接： getConnection
  1. <c3p0-config>
  2.   <!-- 使用默认的配置读取连接池对象 -->
  3.   <default-config>
  4.     <!--  连接参数 -->
  5.     <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
  6.     <property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>
  7.     <property name="user">root</property>
  8.     <property name="password">12345678</property>
  10.     <!-- 连接池参数 -->
  11.     <!--初始化申请的连接数-->
  12.     <property name="initialPoolSize">5</property>
  13.     <!--最大连接数-->
  14.     <property name="maxPoolSize">10</property>
  15.     <!--超时处理-->
  16.     <property name="checkoutTimeout">3000</property>
  17.   </default-config>
  19.   <named-config name="otherc3p0"> 
  20.     <!--  连接参数 -->
  21.     <property name="driverClass">com.mysql.jdbc.Driver</property>
  22.     <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
  23.     <property name="user">root</property>
  24.     <property name="password">root</property>
  26.     <!-- 连接池参数 -->
  27.     <property name="initialPoolSize">5</property>
  28.     <property name="maxPoolSize">8</property>
  29.     <property name="checkoutTimeout">1000</property>
  30.   </named-config>
  31. </c3p0-config>
  1. <c3p0-config>
  2.   <!-- 用户自定义配置 -->
  3.   <named-config name="c3p0Config">
  4.     <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
  5.     <property name="jdbcUrl">jdbc:mysql://localhost:3306/db_1?characterEncoding=utf-8&amp;useSSL=true</property>
  6.     <property name="user">root</property>
  7.     <property name="password">12345678</property>
  8.     <!-- 最大连接数 -->
  9.     <property name="maxPoolSize">10</property>
  10.     <!-- 最小连接数 -->
  11.     <property name="minPoolSize">5</property>
  12.     <!-- 初始化连接数,连接池创建初始化连接数 -->
  13.     <property name="initialPoolSize">3</property>
  14.     <!-- 多长时间检测一下链接的可用性，以秒做单位-->
  15.     <property name="idleConnectionTestPeriod">3600</property>
  16.     <!-- 如果连接处不够用，一次性创建多少链接 -->
  17.     <property name="acquireIncrement">5</property>
  18.     <!-- 链接的最大空闲时间，以分钟做为单位 -->
  19.     <property name="maxIdleTime">50</property>
  20.   </named-config>
  21. </c3p0-config>

代码

  1. //1.创建数据库连接池对象
  2. DataSource ds = new ComboPooledDataSource();
  3. //方式二（少用）
  4. DataSource ds = new ComboPooledDataSource( configName: "otherc3pe")；
  5. //2. 获取连接对象
  6. Connection conn = ds.getConnection();

Druid：数据库连接池实现技术，由阿里巴巴提供的

步骤

  1. 导入 jar 包 druid-1.0.9.jar

  2. 定义配置文件：

    • 是 properties 形式的
    • 可以叫任意名称，可以放在任意目录下 
      1. driverClassName=com.mysql.jdbc.Driver
      2. url=jdbc:mysql://127.0.0.1:3306/tmp
      3. username=root
      4. password=root
      5. initialSize=5
      6. maxActive=10
      7. maxWait=3000

  3. 加载配置文件。Properties

  4. 获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
  5. 获取连接：getConnection

代码

  1. package cn.itcast.datasource.druid;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  5. import javax.sql.DataSource;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.sql.Connection;
  9. import java.util.Properties;
  11. public class DruidDemo1 {
  12.     public static void main(String[] args) throws Exception {
  13.         //1.导入jar包
  14.         //2.定义配置文件
  15.         //3.加载配置文件
  16.         Properties pro = new Properties();
  17.         InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
  18.         pro.load(is);
  20.         //4.获取连接池对象
  21.         DataSource ds = DruidDataSourceFactory.createDataSource(pro);
  23.         //5.获取连接
  24.         Connection conn = ds.getConnection();
  25.         System.out.println(conn);
  26.     }
  27. }

练习

定义一个工具类来实现连接池

  1. 定义一个类 JDBCUtils
  2. 提供静态代码块加载配置文件，初始化连接池对象
  3. 提供方法
    1. 获取连接方法：通过数据库连接池获取连接
    2. 释放资源
    3. 获取连接池的方法

代码

  1. package cn.itcast.utils;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  5. import javax.sql.DataSource;
  6. import java.io.IOException;
  7. import java.sql.Connection;
  8. import java.sql.ResultSet;
  9. import java.sql.SQLException;
  10. import java.sql.Statement;
  11. import java.util.Properties;
  13. /**
  14.  * Druid连接池的工具类
  15.  */
  16. public class JDBCUtils {
  18.     //1.定义成员变量 DataSource
  19.     private static DataSource ds;
  21.     static {
  22.         try {
  23.             //1.加载配置文件
  24.             Properties pro = new Properties();
  25.             pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
  26.             //2.获取DataSource
  27.             ds = DruidDataSourceFactory.createDataSource(pro);
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         } catch (Exception e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  35.     /**
  36.      * 获取连接
  37.      */
  38.     public static Connection getConnection() throws SQLException {
  39.         return ds.getConnection();
  40.     }
  42.     /**
  43.      * 释放资源
  44.      */
  45.     public static void close(Statement stmt, Connection conn) {
  46.         /* if(stmt != null){
  47.             try {
  48.                 stmt.close();
  49.             } catch (SQLException e) {
  50.                 e.printStackTrace();
  51.             }
  52.         }
  54.         if(conn != null){
  55.             try {
  56.                 conn.close();//归还连接
  57.             } catch (SQLException e) {
  58.                 e.printStackTrace();
  59.             }
  60.         }*/
  62.         close(null, stmt, conn);
  63.     }
  66.     public static void close(ResultSet rs, Statement stmt, Connection conn) {
  69.         if (rs != null) {
  70.             try {
  71.                 rs.close();
  72.             } catch (SQLException e) {
  73.                 e.printStackTrace();
  74.             }
  75.         }
  78.         if (stmt != null) {
  79.             try {
  80.                 stmt.close();
  81.             } catch (SQLException e) {
  82.                 e.printStackTrace();
  83.             }
  84.         }
  86.         if (conn != null) {
  87.             try {
  88.                 conn.close();//归还连接
  89.             } catch (SQLException e) {
  90.                 e.printStackTrace();
  91.             }
  92.         }
  93.     }
  95.     /**
  96.      * 获取连接池方法
  97.      */
  99.     public static DataSource getDataSource() {
  100.         return ds;
  101.     }
  103. }

使用工具类测试

  1. package cn.itcast.datasource.druid;
  3. import cn.itcast.utils.JDBCUtils;
  5. import java.sql.Connection;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  10. /**
  11.  * 使用新的工具类
  12.  */
  13. public class DruidDemo2 {
  15.     public static void main(String[] args) {
  16.         /*
  17.          * 完成添加操作：给account表添加一条记录
  18.          */
  19.         Connection conn = null;
  20.         PreparedStatement pstmt = null;
  21.         try {
  22.             //1.获取连接
  23.             conn = JDBCUtils.getConnection();
  24.             //2.定义sql
  25.             String sql = "insert into sign_info values(null,?,?)";
  26.             //3.获取pstmt对象
  27.             pstmt = conn.prepareStatement(sql);
  28.             //4.给？赋值
  29.             pstmt.setString(1,"王五");
  30.             pstmt.setString(2,"123");
  31.             //5.执行sql
  32.             int count = pstmt.executeUpdate();
  33.             System.out.println(count);
  34.         } catch (SQLException e) {
  35.             e.printStackTrace();
  36.         }finally {
  37.             //6. 释放资源
  38.             JDBCUtils.close(pstmt,conn);
  39.         }
  40.     }
  42. }

spring JDBC ：JDBC template

Spring 框架对 JDBC 的简单封装。提供了一个 JDBCTemplate 对象简化 JDBC 的开发

步骤

  1. 导入 jar 包
  2. 创建 JdbcTemplate 对象。依赖于数据源 DataSource
    1. JdbcTemplate template = new JdbcTemplate(ds);
  3. 调用 JdbcTemplate 的方法来完成 CRUD 的操作
    1. update():执行DML语句。增、删、改语句
    2. queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
      1. 注意：这个方法查询的结果集长度只能是1
    3. queryForList():查询结果将结果集封装为list集合
      1. 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
    4. query():查询结果，将结果封装为JavaBean对象
      1. query的参数：RowMapper
      2. 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
      3. new BeanPropertyRowMapper<类型>(类型.class)
    5. queryForObject：查询结果，将结果封装为对象
      1. 一般用于聚合函数的查询

案例

  1. package SpringJDBC;
  3. import JDBC06.druid.JDBCUtils;
  4. import org.springframework.jdbc.core.JdbcTemplate;
  7. public class JdbcTemplateDemo1 {
  8.     public static void main(String[] args) {
  11.         JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
  13.         String sql = "update user set username = ? where id =?";
  14.         int count = jdbcTemplate.update(sql, "hello", "3");
  15.         System.out.println(count);
  16.     }
  17. }

练习

  1. 修改 1 号数据的 salary 为 10000
  2. 添加一条记录
  3. 删除刚才添加的记录
  4. 查询 id 为 1 的记录，将其封装为 Map 集合
  5. 查询所有记录，将其封装为 List
  6. 查询所有记录，将其封装为 Emp 对象的 List 集合
  7. 查询总记录数

代码

  1. import cn.itcast.domain.Emp;
  2. import cn.itcast.utils.JDBCUtils;
  3. import org.junit.Test;
  4. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  5. import org.springframework.jdbc.core.JdbcTemplate;
  6. import org.springframework.jdbc.core.RowMapper;
  8. import java.sql.Date;
  9. import java.sql.ResultSet;
  10. import java.sql.SQLException;
  11. import java.util.List;
  12. import java.util.Map;
  14. public class JdbcTemplateDemo2 {
  15.     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
  17.     @Test
  18.     public void test1(){
  21.         String sql = "update emp set salary = 10000 where id = 1001";
  23.         int count = template.update(sql);
  24.         System.out.println(count);
  25.     }
  28.     @Test
  29.     public void test2(){
  30.         String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
  31.         int count = template.update(sql, 1015, "郭靖", 10);
  32.         System.out.println(count);
  34.     }
  36.     @Test
  37.     public void test3(){
  38.         String sql = "delete from emp where id = ?";
  39.         int count = template.update(sql, 1015);
  40.         System.out.println(count);
  41.     }
  43.     @Test
  44.     public void test4(){
  45.         String sql = "select * from emp where id = ? or id = ?";
  46.         Map<String, Object> map = template.queryForMap(sql, 1001,1002);
  47.         System.out.println(map);
  50.     }
  53.     @Test
  54.     public void test5(){
  55.         String sql = "select * from emp";
  56.         List<Map<String, Object>> list = template.queryForList(sql);
  58.         for (Map<String, Object> stringObjectMap : list) {
  59.             System.out.println(stringObjectMap);
  60.         }
  61.     }
  65.     @Test
  66.     public void test6(){
  67.         String sql = "select * from emp";
  68.         List<Emp> list = template.query(sql, new RowMapper<Emp>() {
  70.             @Override
  71.             public Emp mapRow(ResultSet rs, int i) throws SQLException {
  72.                 Emp emp = new Emp();
  73.                 int id = rs.getInt("id");
  74.                 String ename = rs.getString("ename");
  75.                 int job_id = rs.getInt("job_id");
  76.                 int mgr = rs.getInt("mgr");
  77.                 Date joindate = rs.getDate("joindate");
  78.                 double salary = rs.getDouble("salary");
  79.                 double bonus = rs.getDouble("bonus");
  80.                 int dept_id = rs.getInt("dept_id");
  82.                 emp.setId(id);
  83.                 emp.setEname(ename);
  84.                 emp.setJob_id(job_id);
  85.                 emp.setMgr(mgr);
  86.                 emp.setJoindate(joindate);
  87.                 emp.setSalary(salary);
  88.                 emp.setBonus(bonus);
  89.                 emp.setDept_id(dept_id);
  91.                 return emp;
  92.             }
  93.         });
  94.         for (Emp emp : list) {
  95.             System.out.println(emp);
  96.         }
  97.     }
  99.     @Test
  100.     public void test6_2(){
  101.         String sql = "select * from emp";
  102.         List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
  103.         for (Emp emp : list) {
  104.             System.out.println(emp);
  105.         }
  106.     }
  109.     @Test
  110.     public void test7(){
  111.         String sql = "select count(id) from emp";
  112.         Long total = template.queryForObject(sql, Long.class);
  113.         System.out.println(total);
  114.     }
  116. }