数据库连接池

  1. 概念：其实就是一个容器（集合），存放数据库连接的容器。
    当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完后，会将连接对象归还给容器。
  2. 好处：
    1. 节约资源
    2. 用户访问高效
  3. 实现：
    1. 标准接口：DataSource javax.sql包下的
      1. 方法：
        • 获取连接：getConnection()
        • 归还连接：如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接，而是归还连接
    2. 一般我们不去实现它，由数据库厂商来说实现
      1. C3P0：数据库连接池技术
      2. Druid：数据库连接池实现技术，由阿里巴巴提供的
  4. C3P0：数据库连接池技术
    • 步骤：
      1. 导入jar包两个 c3p0-0.9.5.2 jar mchange-commons-java-0.2.12.jar 前提是有mysql的驱动jar包
      2. 定义配置文件：
        • 名称：c3p0.properties 或者 c3p0-config.xml
        • 路径：直接将文件放在src目录下即可。
      3. 创建核心对象 数据库连接池对象 ComboPolledDataSource
        配置文件的演示：

代码演示：```java package b_datesource.c3p0;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource; import java.sql.Connection; import java.sql.SQLException;

public class C3P0Demo2 {

  1. public static void main(String[] args) throws SQLException {
  2.     //1.获取DataSource,new ComboPooledDataSource()使用默认配置

// DataSource ds = new ComboPooledDataSource(); //1.1获取DataSource 使用指定名称的配置 DataSource ds = new ComboPooledDataSource(“otherc3p0”); //2.获取连接 for (int i = 1; i <= 11; i++) { Connection conn = ds.getConnection(); System.out.println(i + “” + conn);

  1.         if (i == 5){//归还连接
  2.             conn.close();
  3.         }
  4.     }
  6. }

}

  1. <br />结果：<br />（第五个归还连接，第六个使用第五个归还的连接，最大连接数量还是10）
  2. 5. Druid：数据库连接池实现技术，由阿里巴巴提供的
  3.    1. 步骤：
  4.       1. 导入jar包：druid -1.0.9.jar
  5.       2. 定义配置文件：
  6.          - 是properties形式的
  7.          - 可以叫任意名称，可以放在任意目录下
  8.       3. 加载配置文件。`Properties`
  9.       4. 获取数据路连接池对象：通过工厂类来获取    `DruidDataSourceFactory`
  10.       5. 获取连接：`getConnection`
  11.    2. 定义工具类
  12.       1. 定义一个类 `JDBCUtils`
  13.       2. 提供静态代码块加载配置文件，初始化连接池对象
  14.       3. 提供方法
  15.          1. 获取连接方法：通过数据库连接池获取连接
  16.          2. 释放资源
  17.          3. 获取连接池方法
  20. 工具类代码：
  21. ```java
  22. import com.alibaba.druid.pool.DruidDataSourceFactory;
  24. import javax.sql.DataSource;
  25. import java.io.IOException;
  26. import java.sql.Connection;
  27. import java.sql.ResultSet;
  28. import java.sql.SQLException;
  29. import java.sql.Statement;
  30. import java.util.Properties;
  31. @SuppressWarnings("All")
  32. public class JDBCUtils {
  34.     //1.定义成员变量 DataSource
  35.     private static DataSource dataSource;
  37.     static {
  38.         try {
  39.             //1.加载配置文件
  40.             Properties properties = new Properties();
  41.             properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
  42.             //2.获取DataSource
  43.             dataSource = DruidDataSourceFactory.createDataSource(properties);
  44.         } catch (IOException e) {
  45.             e.printStackTrace();
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         }
  49.     }
  51.     /**
  52.      * 获取连接的方法
  53.      */
  55.     public static Connection getConnection() throws SQLException {
  57.         return dataSource.getConnection();
  58.     }
  60.     public static void close(Statement statement,Connection connection){
  61.         if (statement != null){
  62.             try {
  63.                 statement.close();
  64.             } catch (SQLException e) {
  65.                 e.printStackTrace();
  66.             }
  67.         }
  68.         if (connection != null){
  69.             try {
  70.                 connection.close();//归还连接
  71.             } catch (SQLException e) {
  72.                 e.printStackTrace();
  73.             }
  74.         }
  75.     }
  76.     public static void close(ResultSet resultSet,Statement statement,Connection connection){
  77.         if (resultSet != null){
  78.             try {
  79.                 resultSet.close();
  80.             } catch (SQLException e) {
  81.                 e.printStackTrace();
  82.             }
  83.         }
  84.         close(statement,connection);
  85.     }
  87.     /**
  88.      * 获取连接池的方法
  89.      */
  90.     public static DataSource getDataSource(){
  91.         return dataSource;
  92.     }
  94. }

测试代码：

  1. import b_datesource.utils.JDBCUtils;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.SQLException;
  7. /**
  8.  * 使用新的工具类
  9.  */
  10. @SuppressWarnings("All")
  11. public class DruidDemo2 {
  13.     public static void main(String[] args) {
  14.         /***
  15.          * 给account表添加一条记录
  16.          */
  17.         Connection connection = null;
  18.         PreparedStatement pstm = null;
  20.         try {
  21.             //1.获取连接
  22.             connection = JDBCUtils.getConnection();
  23.             //2.定义Sql
  24.             String sql = "insert into account values(null,?,?)";
  25.             //3.获取pstm对象
  26.             pstm = connection.prepareStatement(sql);
  27.             //4.赋值
  28.             pstm.setString(1,"wudi");
  29.             pstm.setDouble(2,3000);
  30.             //5.执行sql
  31.             int update = pstm.executeUpdate();
  32.         } catch (SQLException e) {
  33.             e.printStackTrace();
  34.         }finally {
  35.             JDBCUtils.close(pstm,connection);
  36.         }
  37.     }
  38. }

Spring JDBC

  • Spring框架对JDBC简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
  • 步骤：
    1. 导入jar包
      • commons-logging-1.2.jar
      • spring-beans-5.0.0.RELEASE.jar
      • spring-core-5.0.0.RELEASE.jar
      • spring-jdbc-5.0.0.RELEASE.jar
      • spring-tx-5.0.0.RELEASE.jar
    2. 创建JdbcTemplate对象。依赖于数据源DataSource
      • JdbcTemplate template = new JdbcTemplate(ds);
    3. 调用JdbcTemplate的方法来完成CRUD的操作
      • update():执行DML语句。增，删，改语句
      • queryForMap():查询结果将结果集封装为map集合，将列名作为key，值作为value
        • 注意：这个方法查询的结果集长度只能是1
      • queryForLIst():查询结果将结果封装为list集合
        • 注意：将每一条记录封装为map集合，再将所有map集合封装为list集合
      • query()：查询结果，将结果集封装为JavaBean对象
      • queryForObject()：查询结果，将结果集封装为对象
        代码演示：```java package b_datesource.jdbctemplate;

import b_datesource.utils.JDBCUtils; import org.junit.jupiter.api.Test; import org.springframework.jdbc.core.BeanPropertyRowMapper; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet; import java.sql.SQLException; import java.util.List; import java.util.Map; @SuppressWarnings(“All”) public class JdbcTemplateDemo2 {

  1. //1.获取JDBCTemplate对象
  2. JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
  4. //Junit单元测试
  6. /**
  7.  * 修改id为3的数据balance为3000
  8.  */
  9. @Test
  10. public void test() {
  12.     //2.定义sql
  13.     String sql = "update account set balance = 3000 where id = ?";
  14.     //3.执行sql
  15.     int update = template.update(sql, 3);
  16.     if (update > 0) {
  17.         System.out.println("修改成功");
  18.     } else {
  19.         System.out.println("添加失败");
  20.     }
  21. }
  23. /**
  24.  * 添加一条记录
  25.  */
  26. @Test
  27. public void test2() {
  28.     String sql = "insert into account values(null,?,?)";
  29.     int jiege = template.update(sql, "jiege", 1000000);
  30.     if (jiege > 0) {
  31.         System.out.println("添加成功");
  32.     } else {
  33.         System.out.println("添加失败");
  34.     }
  35. }
  37. /**
  38.  * 删除刚添加的数据
  39.  */
  40. @Test
  41. public void test3() {
  42.     String sql = "Delete from account where id = ?";
  43.     int update = template.update(sql, 4);
  44.     if (update > 0) {
  45.         System.out.println("删除成功");
  46.     } else {
  47.         System.out.println("删除失败");
  48.     }
  49. }
  51. /**
  52.  * 查询id为1的记录，将其封装为Map集合
  53.  * 注意：这个方法的结果集长度只能是1
  54.  */
  55. @Test
  56. public void test4() {
  57.     String sql = "Select * from account where id = ?";
  58.     Map<String, Object> map = template.queryForMap(sql,1);
  59.     System.out.println(map);
  60.     map.forEach((s,q)-> System.out.println(s+"=="+q));
  61. }
  62. /**
  63.  * 查询所有的记录，将其封装为list集合
  64.  */
  65. @Test
  66. public void test5() {
  67.     String sql = "select * from account";
  68.     List<Map<String, Object>> list = template.queryForList(sql);
  70.     for (Map<String, Object> map : list) {
  71.         System.out.println(map);
  72.     }
  73. }
  75. /**
  76.  * 将所有对象封装为javaBean对象的list集合
  77.  */
  78. @Test
  79. public void test6() {
  80.     String sql = "Select * from account";
  81.     List<Accounts> list = template.query(sql, new RowMapper<Accounts>() {
  82.         @Override
  83.         public Accounts mapRow(ResultSet resultSet, int i) throws SQLException {
  84.             Accounts accounts = new Accounts();
  85.             int id = resultSet.getInt("id");
  86.             String name = resultSet.getString("name");
  87.             double balance = resultSet.getDouble("balance");
  89.             accounts.setId(id);
  90.             accounts.setUser(name);
  91.             accounts.setBalance(balance);
  93.             return accounts;
  94.         }
  95.     });
  97.     for (Accounts accounts : list) {
  98.         System.out.println(accounts );
  99.     }
  100. }
  101. /**
  102.  * 将所有对象封装为javaBean对象的list集合
  103.  */
  104. @Test
  105. public void test7() {
  106.     String sql = "Select * from account";
  107.     List<Accounts> list = template.query(sql, new BeanPropertyRowMapper<Accounts>(Accounts.class));
  109.     for (Accounts accounts : list) {
  110.         System.out.println(accounts);
  111.     }
  112. }
  113. /**
  114.  * 查询总记录数
  115.  */
  116. @Test
  117. public void test8(){
  118.     String sql = "Select count(1) from account";
  119.     Long aLong = template.queryForObject(sql, Long.class);
  120.     System.out.println(aLong);
  121. }

} ```