JDBC数据库连接池&JDBCTemplate

数据库连接池

概念：

其实就是一个容器（集合），存放数据库连接的容器。

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

好处：

1.节约资源

2.用户访问高效

实现：

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

C3P0：数据库连接技术

• 步骤：
  • 1.导入jar包（两个）：c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar
  • 2.定义配置文件：
    • 名称：c3p0.properties 或者 c3p0-config.xml
    • 路径：直接将文件放在src目录下即可
  • 3.创建核心对象：数据库连接池对象 ComboPooledDataSource
  • 4.获取连接：getConnection()

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

1.步骤：

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

2.定义工具类

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

package com.java.util;

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 JDBCUtils2 {
    //1.定义成员变量
    private static DataSource dataSource;
    static {
        try {
            //1.加载配置文件
            Properties properties = new Properties();
            properties.load(JDBCUtils2.class.getClassLoader().getResourceAsStream("druid.properties"));
            //2.获取DataSource
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取连接
     */
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
    /**
     * 释放资源
     */
    public static void close(ResultSet resultSet, Statement statement,Connection connection){
        if (resultSet != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void close(Statement statement,Connection connection){
        close(null,statement,connection);
    }
    /**
     * 获取连接池方法
     */
    public static DataSource getDatasource(){
        return dataSource;
    }
}

测试工具类：

/**
 * JabcTemplate入门
 */
public class JdbcTemplateDemo1 {
    public static void main(String[] args) {
        //1.导入jar包
        //2.创建JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils2.getDatasource());
        //3.调用方法
        int count = jdbcTemplate.update("UPDATE account SET NAME = ? WHERE id = ?","赵六",4);
        System.out.println(count);
    }
}

Spring JDBC：JDBC Template

Spring框架对JDBC的简单封装。依赖于数据源DataSource

1.步骤：

• 1.导入jar包
• 2.创建JdbcTemplate对象。依赖于数据源DataSource
  • JdbcTemplate template = new JdbcTemplate(datasource);
• 3.调用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）修改id为1的数据的balance为10000

    //Junit单元测试，可以让方法独立执行，不再依赖于主方法

    private JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils2.getDatasource());

    /**
     *  1）修改id为1的数据的balance为10000
     */
    @Test
    public void test1(){
        //1.创建JDBCTemplate对象
        JdbcTemplate jdbcTemlate = new JdbcTemplate(JDBCUtils2.getDatasource());
        int count = jdbcTemplate.update("UPDATE account set balance = ? WHERE id = ?", 10000, 1);
        System.out.println(count);
    }

• 2）添加一条记录

	/**
     *  2）添加一条记录
     */
    @Test
    public void test2(){
        //1.创建JDBCTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils2.getDatasource());
        int count = jdbcTemplate.update("INSERT INTO account VALUES(NULL,?,?)", "奉七", 1);
        System.out.println(count);
    }

• 3）删除刚才添加的记录

    /**
     *  3）删除刚才添加的记录
     */
    @Test
    public void test3(){
        int count = jdbcTemplate.update("DELETE FROM account WHERE name = ?","奉七");
        System.out.println(count);
    }

• 4）查询id为1的记录，将其封装为Map集合

    /**
     *  4）查询id为1的记录，将其封装为Map集合
     *  注意：这个方法查询的结果集只能是1
     */
    @Test
    public void test4(){
        Map<String, Object> map = jdbcTemplate.queryForMap("SELECT * FROM account WHERE id = ? or id = ?",1,2);
        System.out.println(map);
        //{id=1, name=张三, balance=10000}
    }

• 5）查询所有的记录，将其封装为List

    /**
     *  5）查询所有的记录，将其封装为List
     */
    @Test
    public void test5(){
        List<Map<String, Object>> maps = jdbcTemplate.queryForList("SELECT * FROM account");
        for (Map<String, Object> map : maps) {
            System.out.println(map);
        }
    }

• 6）查询所有记录，将其封装为Emp对象的List集合

    /**
     *  6）查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void test6(){
        List<Emp> list = jdbcTemplate.query("select * from account", new RowMapper<Emp>() {
            @Override
            public Emp mapRow(ResultSet resultSet, int i) throws SQLException {
                Emp emp = new Emp();
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int balance = resultSet.getInt("balance");
                emp.setId(id);
                emp.setName(name);
                emp.setBalance(balance);
                return emp;
            }
        });
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }
    /**
     *  6）查询所有记录，将其封装为Emp对象的List集合
     */
    @Test
    public void test6_2(){
        List<Emp> list = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : list) {
            System.out.println(emp);
        }
    }

• 7）查询总记录数

    /**
     *  7）查询总记录数
     */
    @Test
    public void test7(){
        Long total = jdbcTemplate.queryForObject("select count(id) from account", Long.class);
        System.out.println(total);
    }