JDBC连接池&&JdbcTemplate

数据库连接池

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

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

好处：

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

实现：

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

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

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

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

C3P0：数据库连接池技术

• 步骤：

• 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ， 不要忘记导入数据库驱动jar包

• 定义配置文件：

  • 名称： c3p0.properties 或者 c3p0-config.xml
  • 路径：直接将文件放在src目录下即可。

• 创建核心对象 数据库连接池对象 ComboPooledDataSource ,可以指定连接一个数据库

  • DataSource ds = new ComboPooledDataSource(“otherc3p0”);

• 获取连接： getConnection

• 代码：

c3p0-config.xml

<c3p0-config>
  
  <default-config>
  	
    <property name="driverClass">com.mysql.jdbc.Driverproperty>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/day03property>
    <property name="user">rootproperty>
    <property name="password">123456property>
    
    
    
    <property name="initialPoolSize">5property>
    
    <property name="maxPoolSize">10property>
    
    <property name="checkoutTimeout">3000property>
  default-config>

  <named-config name="otherc3p0"> 
    
    <property name="driverClass">com.mysql.jdbc.Driverproperty>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/db3property>
    <property name="user">rootproperty>
    <property name="password">rootproperty>
    
    
    <property name="initialPoolSize">5property>
    <property name="maxPoolSize">8property>
    <property name="checkoutTimeout">1000property>
  named-config>
c3p0-config>

连接池的使用

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

//3.归还连接给连接池
conn.close();

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

1. 步骤：

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

• 代码

  配置文件 druid.properties

  driverClassName=com.mysql.jdbc.Driver
  url=jdbc:mysql://localhost/day03
  username=root
  password=123456
  # 初始化连接数量
  initialSize=5
  # 最大连接数
  maxActive=10
  # 最大等待时间
  maxWait=3000
  

  连接示例

  public class DruidDemo {
      public static void main(String[] args) throws Exception {
          // 1. 导入jar包
          // 2. 定义配置文件
          // 3. 加载配置文件
          Properties prop = new Properties();
          InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
          prop.load(is);
          // 4. 获取数据库连接池对象
          DataSource ds = DruidDataSourceFactory.createDataSource(prop);
          // 5. 获取连接
          Connection conn = ds.getConnection();
          System.out.println(conn);
      }
  }
  

2. 定义工具类

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

• 代码：

  package util;
  
  import com.alibaba.druid.pool.DruidDataSourceFactory;
  
  import javax.sql.DataSource;
  import java.io.IOException;
  import java.io.InputStream;
  import java.sql.Connection;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.sql.Statement;
  import java.util.Properties;
  
  public class JDBCUtils {
  
      static DataSource ds = null;
      static {
  
          try {
              // 1.获取配置文件
              Properties prop = new Properties();
              InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
              prop.load(is);
              // 2.获取连接池对象
              ds = DruidDataSourceFactory.createDataSource(prop);
          } catch (IOException e) {
              e.printStackTrace();
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  
      /**
       * 获取连接
       * @return 连接对象
       * @throws SQLException
       */
      public static Connection getConnection() throws SQLException {
          return ds.getConnection();
      }
  
      /**
       * 关闭资源
       * @param res
       * @param state
       * @param conn
       */
      public static void close(ResultSet res, Statement state,Connection conn){
          if (res!=null){
              try {
                  res.close();
              } catch (SQLException e) {
                  e.printStackTrace();
              }
          }
  
          if (state != null){
              try {
                  state.close();
              } catch (SQLException e) {
                  e.printStackTrace();
              }
          }
  
          if (conn != null){
              try {
                  conn.close();  // 归还连接
              } catch (SQLException e) {
                  e.printStackTrace();
              }
          }
      }
  
      /**
       * 获取连接池
       * @return 返回连接池对象
       */
      public static DataSource getDataSource(){
          return ds;
      }
  }
  

  测试代码：

  import util.JDBCUtils;
  
  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.SQLException;
  
  /*
  * 给account 添加一个值
  * */
  public class DruidDemo2 {
      public static void main(String[] args) {
  
          Connection conn = null;
          PreparedStatement pstate = null;
  
          try {
              // 1. 获取连接
              conn = JDBCUtils.getConnection();
  
              // 2. 编写sql 语句
              String sql = "insert into account values(null,?,?)";
              // 3. 获取执行sql语句的对象
              pstate = conn.prepareStatement(sql);
              // 4. 给? 赋值
              pstate.setString(1,"zhangfei");
              pstate.setDouble(2,2000);
              // 5. 执行sql语句
              int res = pstate.executeUpdate();
              // 6. 处理结果
              if (res > 0){
                  System.out.println("插入成功！");
              }
          } catch (SQLException e) {
              e.printStackTrace();
          }finally {
              // 7. 关闭资源
              JDBCUtils.close(null,pstate,conn);
          }
      }
  }
  

Spring JDBC

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

步骤：

1. 导入jar包

2. 创建JdbcTemplate对象。依赖于数据源DataSource

   • JdbcTemplate template = new JdbcTemplate(ds);

3. 调用JdbcTemplate的方法来完成CRUD的操作
   

练习：

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

package JdbcTemplate;

import c3p0.Emp;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import util.JDBCUtils;

import java.util.List;
import java.util.Map;

public class JdbcTemplateDemo2 {

    //1. 获取JdbcTemplate对象
    static JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());


    /**
     * 修改1号数据的 salary 为 10000
     */
    @Test
    public void test1(){

        // 2. 编写sql 语句
        String sql = "update emp set salary=? where id = ?";

        // 3.调用方法
        int res = template.update(sql, 10000, 1);
        System.out.println(res);
    }

    /**
     * 添加一条记录
     */

    @Test
    public void test2(){
        String sql = "insert into emp values(null,?,?,?)";
        int res = template.update(sql, "wangwu", "2019-01-01", 6000);
        System.out.println(res);
    }

    /*删除添加的记录*/
    @Test
    public void test3(){
        String sql = "delete from emp where ename = ?";
        int res = template.update(sql, "wangwu");
        System.out.println(res);
    }

    /*
    * 查询id为1的记录，将其封装为Map集合
    *
    * 结果将会 将列名作为key,将值作为value,将这条记录封装为一个map集合
    * 这个方法查询的结果集长度只能是1个
    * */
    @Test
    public void test4(){
        String sql = "select * from emp where id = ?";
        Map<String, Object> empMap = template.queryForMap(sql, 1);
        System.out.println(empMap);

        // {id=1, ename=long, join_date=2019-09-17, salary=10000.00}
    }

    /**
     * 查询所有记录，将其封装为List
     * * 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
     */
    @Test
    public void test5(){
        String sql = "select * from emp";
        List<Map<String, Object>> maps = template.queryForList(sql);
        for(Map<String,Object> map:maps){
            System.out.println(map);
        }

        //{id=1, ename=long, join_date=2019-09-17, salary=10000.00}
        //{id=2, ename=lisi, join_date=2019-09-04, salary=99999.90}
        //{id=3, ename=zahngsan, join_date=2019-09-21, salary=11111.22}
    }

    /**
     * 查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void test6(){
        String sql = "select * from emp";
        List<Emp> query = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        System.out.println(query);

        // [Emp{id=1, ename='long', join_date=2019-09-17 00:00:00.0, salary=10000.0}, Emp{id=2, ename='lisi', join_date=2019-09-04 00:00:00.0, salary=99999.9}, Emp{id=3, ename='zahngsan', join_date=2019-09-21 00:00:00.0, salary=11111.22}]
    }

    /**
     * 查询总记录数
     */
    @Test
    public void test7(){
        String sql = "select count(id) from emp";

        // 第二个参数是返回的类型
        Integer res = template.queryForObject(sql, Integer.class);
        System.out.println(res);  // 3
    }
}