JDBC连接池&JDBCTemplate

Posted on | In | | Visitors:

后面学习经常用到数据库的操作，为了简化数据库代码操作，学习一下JDBC连接池&JDBCTemplate

内容

  1. 数据库连接池

  2. Spring JDBC : JDBC Template

数据库连接池

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

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

  2. 好处：

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

  3. 实现：

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

      1. 方法：
        • 获取连接：getConnection()
        • 归还连接：Connection.close()。如果连接对象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 ，

        • 不要忘记导入数据库驱动jar包

      2. 定义配置文件：

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

      3. 创建核心对象 数据库连接池对象 ComboPooledDataSource

      4. 获取连接： getConnection

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

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

    1. 步骤：
      1. 导入jar包 druid-1.0.9.jar
      2. 定义配置文件：
        • 是properties形式的
        • 可以叫任意名称，可以放在任意目录下
      3. 加载配置文件。Properties
      4. 获取数据库连接池对象：通过工厂类来获取 DruidDataSourceFactory
      5. 获取连接：getConnection
    • 代码：
      //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();
    1. 定义工具类
      1. 定义一个类 JDBCUtils
      2. 提供静态代码块加载配置文件，初始化连接池对象
      3. 提供方法
        1. 获取连接方法：通过数据库连接池获取连接
        2. 释放资源
        3. 获取连接池的方法
    • 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package cn.qjq.jdbc.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.sql.*;
import java.util.Properties;

/**
 * JDBC方法类
 * Created by qjq on 2020/2/11 16:52
 */
public class JDBCUtils {
    private static DataSource ds;
    //加载配置文件
    static {
        try {
            Properties ps = new Properties();
            ps.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(ps);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接
     * @return 连接
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /**
     * 关闭资源
     * @param stmt 连接
     * @param cnn 连接
     */
    public static void close(Statement stmt,Connection cnn){
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (cnn != null){
            try {
                cnn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void close(ResultSet rs, Statement stmt, Connection cnn){
        if (rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (cnn != null){
            try {
                cnn.close();//归还连接
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取资源
     * @return 资源
     */
    public static DataSource getDataSource(){
        return ds;
    }

}

Spring JDBC

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

  • 步骤：

    1. 导入jar包
    2. 创建JdbcTemplate对象。依赖于数据源DataSource

  • JdbcTemplate template = new JdbcTemplate(ds);

    1. 调用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：查询结果，将结果封装为对象
      • 一般用于聚合函数的查询

    2. 练习：

      • 需求：
        1. 修改1号数据的 salary 为 10000
        2. 添加一条记录
        3. 删除刚才添加的记录
        4. 查询id为1的记录，将其封装为Map集合
        5. 查询所有记录，将其封装为List
        6. 查询所有记录，将其封装为Emp对象的List集合
      1. 查询总记录数
      • 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package cn.qjq.jdbc.Template;

import cn.qjq.jdbc.domain.Emp;
import cn.qjq.jdbc.utils.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;

/**
 * 使用JDBCTemplate实现增删改查
 * Created by qjq on 2020/2/11 20:24
 */
public class JdbcTemplateDemo02 {
    //创建JdbcTemplate对象
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());

    /**
     * 增加一条记录
     */
    @Test
    public void add() {
        //调用方法
        String sql = "insert into users(username,age) values(?,?)";
        int count = template.update(sql, "lisi", 17);
        System.out.println(count);
        //不需要再关闭，会自动处理
    }

    /**
     * 改
     */
    @Test
    public void alter() {
        String sql = "update users set age = 20 where id = ?";
        int count = template.update(sql, 2);
        System.out.println(count);
    }

    /**
     * 删
     */
    @Test
    public void delete() {
        String sql = "delete from users where id = ?";
        int count = template.update(sql, 2);
        System.out.println(count);
    }

    /**
     * 查询id为1的记录，将其封装为Map集合
     * 注意：这个方法查询的结果集长度只能是1
     */
    @Test
    public void search2Map() {
        String sql = "select * from users where id = 1";
        Map<String, Object> map = template.queryForMap(sql);
        System.out.println(map);
    }
    /**
     * 查询所有记录，将其封装为List
     */
    @Test
    public void search2List(){
        String sql = "select * from users";
        List<Map<String, Object>> list = template.queryForList(sql);
        for (Map<String, Object> map : list) {
            System.out.println(map);
        }
    }

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

    /**
     * 查询总记录数
     */
    @Test
    public void total(){
        String sql = "select count(id) from users";
        Long total = template.queryForObject(sql, long.class);
        System.out.println(total);
    }

}

​

来源于黑马视频笔记。