数据库连接池

一、数据库连接池

1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
2. 好处：
   ①节约资源
   ③用户访问高效
3. 实现：
   ①标准接口：DataSource javax.sql包下的

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

   ②一般我们不去实现它，有数据库厂商来实现
   （1）C3P0：数据库连接池技术
   （2）Druid：数据库连接池实现技术，由阿 里巴巴提供的
4. 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.创建数据库连接池对象
   DataSource ds  = new ComboPooledDataSource();
   //2. 获取连接对象
   Connection conn = ds.getConnection();
   

   ③注意：c3p0-config.xml中可以有多个配置，获取连接对象的时候可以指定名字

   //1.创建数据库连接池对象
   DataSource ds  = new ComboPooledDataSource();
   //2. 获取连接对象
   Connection conn = ds.getConnection("otherc3p0");
   

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

   1. 导入jar包 druid-1.0.9.jar
   2. 定义配置文件：
       是properties形式的
       可以叫任意名称，可以放在任意目录下
   3. 加载配置文件：Properties
   4. 获取数据库连接池对象：通过工厂来来获取  DruidDataSourceFactory
   5. 获取连接：getConnection
   

   ②代码：

   //1.导入jar包
   //2.定义配置文件druid.properties
   //3.加载配置文件
   Properties pro = new Properties();
   InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
   pro.load(is);
   //4.获取连接池对象
   DataSource ds = DruidDataSourceFactory.createDataSource(pro);
   //5.获取连接
   Connection conn = ds.getConnection();
   

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

   package cn.itcast.datasource.utils;
   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 JDBCUtil {
       //1.定义成员变量 DataSource
       private static DataSource ds;
   
       static {
           try {
               //1.加载配置文件
               Properties pro = new Properties();
               pro.load(JDBCUtil.class.getClassLoader().getResourceAsStream("druid.properties"));
               //2.获取DataSource
               ds = DruidDataSourceFactory.createDataSource(pro);
           } catch (IOException e) {
               e.printStackTrace();
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       /**
        * 获取连接
        */
       public static Connection getConnection() throws SQLException {
           return ds.getConnection();
       }
   
       /**
        * 释放资源
        */
       public static void close(Statement stmt, Connection conn) {
                      /* if(stmt != null){
                           try {
                               stmt.close();
                           } catch (SQLException e) {
                               e.printStackTrace();
                           }
                       }
   
                       if(conn != null){
                           try {
                               conn.close();//归还连接
                           } catch (SQLException e) {
                               e.printStackTrace();
                           }
                       }*/
   
           close(null, stmt, conn);
       }
   
       public static void close(ResultSet rs, Statement stmt, Connection conn) {
   
           if (rs != null) {
               try {
                   rs.close();
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
   
           if (stmt != null) {
               try {
                   stmt.close();
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
   
           if (conn != null) {
               try {
                   conn.close();//归还连接
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
       }
   
       /**
        * 获取连接池方法
        */
       public static DataSource getDataSource() {
           return ds;
       }
   }
   

二、Spring JDBC

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

2. 步骤：
   ①导入jar包
   ②创建JdbcTemplate对象。依赖于数据源DataSource
   JdbcTemplate template = new JdbcTemplate(ds);
   ③调用JdbcTemplate的方法来完成CRUD的操作

   update():执行DML语句。增、删、改语句
   queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
       * 注意：这个方法查询的结果集长度只能是1
   queryForList():查询结果将结果集封装为list集合
       * 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
   query():查询结果，将结果封装为JavaBean对象
       * query的参数：RowMapper
       * 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
       * new BeanPropertyRowMapper<类型>(类型.class)
   queryForObject：查询结果，将结果封装为对象
       * 一般用于聚合函数的查询
   

   ④练习：

   

    

   需求：

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

   代码：

   package cn.itcast.jdbctemplate;
   
   import cn.itcast.datasource.utils.JDBCUtil;
   import cn.itcast.jdbctemplate.domain.Emp;
   import org.junit.Test;
   import org.springframework.jdbc.core.BeanPropertyRowMapper;
   import org.springframework.jdbc.core.JdbcTemplate;
   
   import java.util.List;
   import java.util.Map;
   
   public class JdbcTemplateDemo2 {
       private JdbcTemplate jt = new JdbcTemplate(JDBCUtil.getDataSource());
   
       //使用junit可以使方法单独执行
       //1. 修改1号数据的 salary 为 10000
       @Test
       public void test1() {
   
           String sql = "update employee set salary = 10000 where id = 1";
           int count = jt.update(sql);
           System.out.println(count);
       }
   
       //2. 添加一条记录
       @Test
       public void test2() {
           String sql = "insert into employee values(?,?,?,?,?)";
           int conut = jt.update(sql, 5, "anfly", "男", 20, 20000);
           System.out.println(conut);
       }
   
       //3. 删除刚才添加的记录
       @Test
       public void test3() {
           String sql = "delete from employee where id = 5";
           int conut = jt.update(sql);
           System.out.println(conut);
       }
   
       //4. 查询id为1的记录，将其封装为Map集合
       // 注意：这个方法的结果长度只能是1
       @Test
       public void test4(){
           String sql = "select * from employee where id = ?";
           Map<String, Object> map = jt.queryForMap(sql, 1);
           System.out.println(map);
       }
   
       //5. 查询所有记录，将其封装为List
       @Test
       public void test5(){
           String sql = "select * from employee";
           List<Map<String, Object>> list = jt.queryForList(sql);
           System.out.println(list);
       }
   
       //6. 查询所有记录，将其封装为Emp对象的List集合
       @Test
       public void test6(){
           String sql = "select * from employee";
           List<Emp> list = jt.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
           System.out.println(list);
       }
       //7. 查询总记录数
       @Test
       public void test7(){
           String sql = "select count(*) from employee";
           Long count = jt.queryForObject(sql, Long.class);
           System.out.println(count);
       }
   }