Java 数据库连接池

Java 数据库连接池

一、概念：

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

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

优点：

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

实现：

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

二、Druid：

步骤：

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

package cn.itcast.day.druid;

import com.alibaba.druid.pool.DruidConnectionHolder;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;

public class DruidDemo {
    public static void main(String[] args) throws Exception {
        // 1.导入jar包
        // 2.定义配置文件
        // 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();
        System.out.println(conn);
    }
}

// 输出结果：
4月 05, 2020 7:40:52 下午 com.alibaba.druid.pool.DruidDataSource info
信息: {dataSource-1} inited
com.mysql.jdbc.JDBC4Connection@5fbe4146

定义工具类：

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

使用工具类：

package cn.itcast.day.druid;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/*
    使用新的工具类
 */
public class DruidDemo01 {
    public static void main(String[] args) {
        /*
            完成添加操作;  给Course表添加一条记录
         */
        Connection connection = null;
        PreparedStatement pstmt = null;
        try {
            // 1.获取连接
            connection = JDBCUtils.getConnection();
            // 2.定义sql
            String sql = "insert into course values(null, ?, ?, ?)";
            // 3.获取pstmt对象
            pstmt = connection.prepareStatement(sql);
            // 4.给?号赋值;
            pstmt.setString(1,"哈尔滨石油学院");
            pstmt.setDouble(2,6000);
            pstmt.setInt(3, 1);
            // 5.执行sql
            int count  = pstmt.executeUpdate();
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 6.释放资源
            JDBCUtils.close(pstmt, connection);
        }
    }
}
// 输出结果：
4月 05, 2020 8:05:42 下午 com.alibaba.druid.pool.DruidDataSource info
信息: {dataSource-1} inited
1

三、JDBC Template:

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

步骤：

1. 导入 jar包；

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

   JdbcTemplate template = new JdbcTemplate(ds);

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

   update()：执行DML语句。增、删、改语句；

   queryForMap()：查询结果将结果集封装为map集合；

   • 这个方法查询的结果集长度只能是1;

   queryForList()：查看结果将结果封装为list集合；

   • 将每一条记录封装为一个Map集合，再将Map集合载到List集合中；

   query()：查询结果，将结果封装为JavaBean对象；

   • 参数：RowMapper
     • 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装；
     • new BeanPropertyRowMapper<类型>(类型.class)；

   queryForObject：查询结果，将结果封装为对象；

   • 一般用于聚合函数的查询；

JdbcTemplate入门：

package cn.itcast.day.druid;

import org.springframework.jdbc.core.JdbcTemplate;

/*
    JdbcTemplate入门
 */
public class JdbcTemplateDemo {
    public static void main(String[] args) {
        // 1.导入jar包;
        // 2.创建JDBCTemplate 对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        // 3.调用方法
        // 定义sql
        String sql = "update course set price = 10000 where id = ?";
        int count = template.update(sql, 10);
        System.out.println(count);
    }

}
// 输出结果：
4月 05, 2020 8:30:23 下午 com.alibaba.druid.pool.DruidDataSource info
信息: {dataSource-1} inited
1

四、JDBC Template 语句执行：

/*
需求：

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


package cn.itcast.day.domain;

import cn.itcast.day.druid.JDBCUtils;
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 JdbcTemplateDemo {
    // junit 单元测试, 可以让方法独立执行

    // 1.将创建JdbcTemplate对象放到成员变量中
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    // 给course表中id为1的课程价格改成5000元;
    @Test
    public void test(){
        // 2.定义sql
        String sql  = "update course set price = 5000 where id = ?";
        // 3.执行sql
        int count = template.update(sql, 1);
        System.out.println(count); // 返回结果:1
    }

    // 新增加一门课程, 课程名为"东北林业大学" 价格: 1234 class_id:0
    @Test
    public void test01(){
        // 定义sql
        String sql = "insert into course(name, price, class_id) values(?,?,?)";
        int count = template.update(sql, "东北林业大学", 1234,0);
        System.out.println(count); // 返回结果:1
    }

    // 删除id=11课程的记录
    @Test
    public void test02(){
        String sql = "delete from course where id = ?";
        int count = template.update(sql, 11);
        System.out.println(count); // 输出结果:1
    }

    // 查询id 为 1的记录, 将其封装为Map集合
    // 注意：这个方法的查询结果集长度只能是1
    @Test
    public void test03(){
        String sql = "select * from course where id =?";
        Map<String, Object> map = template.queryForMap(sql, 1);
        System.out.println(map); // 输出结果: {id=1, name=上海财经大学, price=5000.00, class_id=1}
    }

    // 查询所有记录，将其封装为list
    // 注意： 将每一条记录封装为一个Map集合，再将Map集合加载到list列表中
    @Test
    public void test04(){
        String sql = "select * from course";
        List<Map<String, Object>> maps = template.queryForList(sql);
        for (Map<String, Object> map : maps) {
            System.out.println(map);
            /*输出结果
                {id=1, name=上海财经大学, price=5000.00, class_id=1}
                {id=2, name=北京大学, price=199.99, class_id=1}
             */
        }
    }

    // 查询所有记录，将其封装为Course对象的List集合
    @Test
    public void test05(){
        String sql = "select * from course";
        List<Course> list = template.query(sql, new BeanPropertyRowMapper<Course>(Course.class));
        for (Course course : list) {
            System.out.println(course);
            /*
                输出结果：
                Course{id=1, name='上海财经大学', price=5000.0, class_id=1}
                Course{id=2, name='北京大学', price=199.99, class_id=1}
                Course{id=3, name='天津大学', price=299.99, class_id=1}
             */
        }
    }

    // 查询总记录数
    @Test
    public void test06(){
        String sql = "select count(id) from course";
        Long aLong = template.queryForObject(sql, long.class);
        System.out.println(aLong);  // 输出结果： 10 (数据库里总共10条数据 queryForObject 常统计聚合操作)
    }
}