数据库连接池

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

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

好处

  • 节约资源
  • 用户访问高效

实现

  1. 标准接口：DataSource javax.sql 包下的
  2. 方法：
    • 获取连接：getConnection()
    • 归还连接：Connection.close()。如果连接对象 Connection 是从连接池中获取的，那么调用 Connection.close()方法，则不会再关闭连接了。而是归还连接
    1. 一般我们不去实现它，有数据库厂商来实现
      1. C3P0：数据库连接池技术
      2. Druid：数据库连接池实现技术，由阿里巴巴提供的

C3P0：数据库连接池技术

  1. - 步骤： 1. 导入 jar 包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ，
  2.   _ 不要忘记导入数据库驱动 jar 包 2. 定义配置文件：
  3.   _ 名称： c3p0.properties 或者 c3p0-config.xml \* 路径：直接将文件放在 src 目录下即可。
  5.           3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
  6.           4. 获取连接： getConnection
  8. - 代码：
  9.   //1.创建数据库连接池对象
  10.   DataSource ds = new ComboPooledDataSource();
  11.   //2. 获取连接对象
  12.   Connection conn = ds.getConnection();

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

  1. 1. 步骤：
  2.    1. 导入 jar 包 druid-1.0.9.jar
  3.    2. 定义配置文件：
  4.       - 是 properties 形式的
  5.       - 可以叫任意名称，可以放在任意目录下
  6.    3. 加载配置文件。Properties
  7.    4. 获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
  8.    5. 获取连接：getConnection
  1. //3.加载配置文件
  2. Properties pro = new Properties();
  3. InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
  4. pro.load(is);
  5. //4.获取连接池对象
  6. DataSource ds = DruidDataSourceFactory.createDataSource(pro);
  7. //5.获取连接
  8. Connection conn = ds.getConnection();
  1. 定义工具类
    1. 定义一个类 JDBCUtils
    2. 提供静态代码块加载配置文件，初始化连接池对象
    3. 提供方法
      1. 获取连接方法：通过数据库连接池获取连接
      2. 释放资源
      3. 获取连接池的方法
  1. public class JDBCUtils {
  3.     //1.定义成员变量 DataSource
  4.     private static DataSource ds ;
  6.     static{
  7.         try {
  8.             //1.加载配置文件
  9.             Properties pro = new Properties();
  10.             pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
  11.             //2.获取DataSource
  12.             ds = DruidDataSourceFactory.createDataSource(pro);
  13.         } catch (IOException e) {
  14.             e.printStackTrace();
  15.         } catch (Exception e) {
  16.             e.printStackTrace();
  17.         }
  18.     }
  20.     /**
  21.         * 获取连接
  22.         */
  23.     public static Connection getConnection() throws SQLException {
  24.         return ds.getConnection();
  25.     }
  27.     /**
  28.         * 释放资源
  29.         */
  30.     public static void close(Statement stmt,Connection conn){
  31.         /* if(stmt != null){
  32.             try {
  33.                 stmt.close();
  34.             } catch (SQLException e) {
  35.                 e.printStackTrace();
  36.             }
  37.         }
  39.         if(conn != null){
  40.             try {
  41.                 conn.close();//归还连接
  42.             } catch (SQLException e) {
  43.                 e.printStackTrace();
  44.             }
  45.         }*/
  47.         close(null,stmt,conn);
  48.     }
  51.     public static void close(ResultSet rs , Statement stmt, Connection conn){
  54.         if(rs != null){
  55.             try {
  56.                 rs.close();
  57.             } catch (SQLException e) {
  58.                 e.printStackTrace();
  59.             }
  60.         }
  63.         if(stmt != null){
  64.             try {
  65.                 stmt.close();
  66.             } catch (SQLException e) {
  67.                 e.printStackTrace();
  68.             }
  69.         }
  71.         if(conn != null){
  72.             try {
  73.                 conn.close();//归还连接
  74.             } catch (SQLException e) {
  75.                 e.printStackTrace();
  76.             }
  77.         }
  78.     }
  80.     /**
  81.         * 获取连接池方法
  82.         */
  84.     public static DataSource getDataSource(){
  85.         return  ds;
  86.     }
  88. }