chapter25 JDBC 和 数据库连接池

JDBC概述

基本介绍

1.JDBC为访问不同的数据库提供了统一的接口, 为使用者屏蔽了细节问题.

2.Java程序员使用JDBC, 可以连接任何提供了JDBC驱动程序的数据库系统, 从而完成对数据库的各种操作.

模拟JDBC

1.新建java项目

2.新建com.zzw.jdbc.myjdbc.JdbcInterface接口

/**
 * @author 赵志伟
 * @version 1.0
 * 我们规定的jdbc接口(方法)
 */
public interface JdbcInterface {
    //连接
    public Object getConnection();

    //crud
    public void crud();

    //关闭连接
    public void close();
}

3.新建com.zzw.jdbc.myjdbc.MysqlJdbcImpl实现类

/**
 * @author 赵志伟
 * @version 1.0
 * mysql 数据库实现了 jdbc 接口[模拟 mysql厂商开发]
 */
@SuppressWarnings({"all"})
public class MysqlJdbcImpl implements JdbcInterface {
    @Override
    public Object getConnection() {
        System.out.println("得到 mysql 连接");
        return null;
    }

    @Override
    public void crud() {
        System.out.println("完成 mysql 增删改查");
    }

    @Override
    public void close() {
        System.out.println("关闭 mysql 的连接");
    }
}

4.新建com.zzw.jdbc.myjdbc.OracleJdbcImpl实现类

/**
 * @author 赵志伟
 * @version 1.0
 * 模拟 oracle 数据库实现 jdbc
 */
@SuppressWarnings({"all"})
public class OracleJdbcImpl implements JdbcInterface {
    @Override
    public Object getConnection() {
        System.out.println("得到 oracle 的连接 升级");
        return null;
    }

    @Override
    public void crud() {
        System.out.println("完成 对 oracle 的增删改查");
    }

    @Override
    public void close() {
        System.out.println("关闭 oracle 的连接");
    }
}

5.测试com.zzw.jdbc.myjdbc.TestJDBC

public class TestJDBC {
    public static void main(String[] args) {
        //完成对 mysql 的操作
        JdbcInterface jdbcInterface = new MysqlJdbcImpl();
        jdbcInterface.getConnection();//通过接口来调用实现类[动态绑定]
        jdbcInterface.crud();
        jdbcInterface.close();

        //完成对 oracle 的操作
        System.out.println("==========================");
        jdbcInterface = new OracleJdbcImpl();
        jdbcInterface.getConnection();//通过接口来调用实现类[动态绑定]
        jdbcInterface.crud();
        jdbcInterface.close();
    }
}

JDBC带来的好处

JDBC API

JDBC快速入门

JDBC程序编写步骤

1.注册驱动 - 加载Driver 类

2.获取连接 - 得到Connection

3.执行增删改查 - 发送SQL 给 mysql执行

4.释放资源 - 关闭相关连接

JDBC第一个程序

将包展开: 点击小齿轮(Options) -> Tree Appearance -> Compact Middle Packages

提供jar包: mysql-connector-java-5.1.7-bin.jar

1.新建表

CREATE DATABASE `zzw_db01`;
USE `zzw_db01`;
CREATE TABLE `actor` ( -- 演员表
	`id` INT PRIMARY KEY AUTO_INCREMENT,
	`name` VARCHAR(32) NOT NULL DEFAULT '',
	`sex` CHAR(1) NOT NULL DEFAULT '女',
	`borndate` DATETIME,
	`phone` VARCHAR(12)
)CHARSET=utf8

2.新建com.zzw.jdbc.Jdbc01

/**
 * @author 赵志伟
 * @version 1.0
 * 这是第一个 Jdbc 程序, 完成简单的操作
 */
@SuppressWarnings({"all"})
public class Jdbc01 {
    public static void main(String[] args) throws SQLException {

        //前置工作: 在项目下创建一个文件夹比如 libs
        //将 mysql.jar 拷贝到该目录下, 右键点击 add to project..加入到项目中

        //1.注册驱动 com.mysql.jdbc
        Driver driver = new Driver();//创建driver对象

        /**
         * 2.得到连接
         * 解读
         * (1) jdbc:mysql:// 规定好协议(类似http协议), 通过 jdbc 的方式连接 mysql
         * (2) localhost 主机, 可以是 ip 地址
         * (3) 3306 表示 mysql 监听的端口
         * (4) zzw_db01 连接到 mysql 数据库管理系统（Data Base Management System, DBMS） 的哪个数据库
         * (5) mysql 的连接本质就是前面学过的 socket 连接
         */
        String url = "jdbc:mysql://localhost:3306/zzw_db01";
        //将 用户名 和 密码 放入到 Properties 对象
        Properties properties = new Properties();
        //说明: user 和 password 是规定好的, 后面的值根据实际情况填写
        properties.setProperty("user", "root");//用户名
        properties.setProperty("password", "zzw");//密码
        Connection connection = driver.connect(url, properties);

        //3.执行sql
        String sql = "INSERT INTO `actor`(`id`, `name`, `sex`, `borndate`, `phone`) VALUES (NULL, 'zzw', '男', '2000-10-15 00:00:00', '110')";
        Statement statement = connection.createStatement();
        int rows = statement.executeUpdate(sql);//如果是 dml 语句, 返回的就是影响行数
        System.out.println(rows > 0 ? "成功" : "失败");

        //4.关闭连接资源
        statement.close();
        connection.close();
    }
}

获取数据库连接的5种方式

方式一

1.获取Driver类实现对象. 新建com.zzw.jdbcJdbcConn

/**
 * @author 赵志伟
 * @version 1.0
 * 分析 java 连接 mysql 的 5 种方式
 */
@SuppressWarnings({"all"})
public class JdbcConn {

    //方式1 获取Driver类实现对象
    @Test
    public void connect01() throws SQLException {
        Driver driver = new Driver();//创建 driver 对象
        String url = "jdbc:mysql://localhost:3306/zzw_db01";
        //将用户名和密码放入到Properties对象
        Properties properties = new Properties();
        //说明: user和password是规定好的, 后面的值根据实际情况填写
        properties.setProperty("user", "root");//用户名
        properties.setProperty("password", "zzw");//密码
        Connection connection = driver.connect(url, properties);
        System.out.println("方式1 connection=" + connection);
    }
}

方式二

使用反射加载Driver类

public class JdbcConn {//
    //方式2
    @Test
    public void connect02() throws Exception {
        //方式1 会直接使用 com.mysql.jdbc.Driver(), 属于静态加载, 灵活性差
        //--推出-->方式2 使用反射加载 Driver 类, 动态加载, 更加的灵活, 减少依赖性
        Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
        Driver driver = (Driver) aClass.newInstance();

        String url = "jdbc:mysql://localhost:3306/zzw_db01";
        //将用户名和密码放入到Properties对象
        Properties properties = new Properties();
        //说明: user和password是规定好的, 后面的值根据实际情况填写
        properties.setProperty("user", "root");//用户名
        properties.setProperty("password", "zzw");//密码
        Connection connection = driver.connect(url, properties);
        System.out.println("方式2 connection=" + connection);
    }
}

方式三

使用反射加载Driver类并使用DriverManager替代Driver进行统一管理

public class JdbcConn {

    //方式3 使用 DriverManager 替代 driver 进行统一管理
    @Test
    public void connect03() throws Exception {
        //使用反射加载 Driver
        Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
        Driver driver = (Driver) aClass.newInstance();

        //创建 url 和 user 和 password
        String url = "jdbc:mysql://localhost:3306/zzw_db01";
        String user = "root";
        String password = "zzw";

        DriverManager.registerDriver(driver);//注册Driver驱动
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println("方式3 connection=" + connection);
    }
}

方式四

使用Class.forName() 加载Driver类时, 在Driver类中自动完成注册驱动

public class JdbcConn {

    //方式4 使用 Class.forName 自动完成注册驱动, 简化代码
    //这种方式获取连接是使用的最多, 推荐使用
    @Test
    public void connect04() throws Exception {
        //使用反射加载 Driver 类
        //在加载 Driver 类时, 完成注册
        /*
        源码:
        1. 静态代码块, 在类加载时, 会执行一次
        2. DriverManager.registerDriver(new Driver());
        3. 因此注册 driver 的工作已经完成
        static {
            try {
                DriverManager.registerDriver(new Driver());
            } catch (SQLException var1) {
                throw new RuntimeException("Can't register driver!");
            }
        }
         */
        Class.forName("com.mysql.jdbc.Driver");

        //创建 url 和 user 和 password
        String url = "jdbc:mysql://localhost:3306/zzw_db01";
        String user = "root";
        String password = "zzw";
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println("方式4 connection=" + connection);
    }
}

●细节
1.mysql驱动5.1.6之后可以无需Class.forName("com.mysql.jdbc.Driver");

2.从jdk1.5之后使用了jdbc4，不需再显式调用Class.forName()注册驱动而是自动注册驱动jar包下META-INF\services\java.sql.Driver文本中的类名称去注册

3.建议还是写上Class.forName("com.mysql.jdbc.Driver");, 更加明确

方式五

1.src/mysql.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/zzw_db01
user=root
password=zzw

2.在方式四的基础上，增加一些配置文件

public class JdbcConn {

    //方式5 在方式4的基础上改进, 增加配置文件, 让连接 mysql 更加灵活
    @Test
    public void connect05() throws Exception {

        //通过 Properties 对象获取配置文件的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");
        String user = (String) properties.get("user");
        String password = properties.getProperty("password");

        Class.forName(driver);//建议写上
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println("方式5 connection=" + connection);
    }
}

课堂练习

2.ResultSet底层

1. 表示数据库结果集的数据表；
2. ResultSet对象保持一个光标指向当前的数据行。最初，光标位于第一行之前；
3. next()方法将光标移动到下一行，previous()方法将光标移动到上一行，当ResultSet对象中没有更多行时返回false，一般可以在while循环中使用循环来遍历结果集；

3.Statement sql注入

3.1 PreparedStatement

4. Jdbc工具类

• 原理
  
  
  
  
  

4.1 工具类应用

5.Jdbc事务

1. JDBC程序中当一个Connection对象创建时，默认情况下是自动提交事务，每执行一次SQL语句时，会自动向数据库提交一次，而不能回滚；
2. JDBC为了让多个SQL语句作为一个整体执行，需要使用事务；
3. 调用Connection的setAutoCommit(false)可以取消自动提交事务；
4. 在所有的SQL语句都成功执行后，调用Connection的commit()方法提交事务；
5. 在其中某个操作失败或出现异常时，调用rollback()方法回滚事务；
   
   

6.批处理

1. 当需要成批地插入或者更新记录时，可以采用Java地批量更新机制，这一机制允许许多条语句一次性提交给数据库批量处理，通常情况下比单独提交处理效率高；
2. JDBC地批量处理语句
   addBatch()：添加需要批量处理的SQL语句或参数
   executeBatch()：执行批量处理语句
   clearBatch()：清空批处理包的语句
3. JDBC连接MySQL时，如果要使用批处理功能，请在url中添加参数?rewriteBatchedStatements=true
4. 批处理往往和PreparedStatement一起使用

• 批处理
  
  

6.1 批处理原理

7.数据库连接池

1. 传统的JDBC数据库连接使用DriverManager来获取，每次向数据库建立连接的时候都要将Connection加载到内存中，再验证IP地址、用户名和密码(0.05s~1s时间)。需要数据库连接的时候，就向数据库索求一个，频繁地进行数据库连接操作将占用很多的系统资源，容易出现服务器崩溃；
2. 每一次数据库连接，使用完后都得断开，如果程序出现异常而未能关闭，将导致数据库内存泄漏，最终将导致重启数据库；
3. 传统获取连接的方式，不能控制创建的连接数量，如果连接过多，也可能导致内存泄漏，MySQL崩溃；
4. 解决传统开发中的数据库连接问题，可以采用数据库连接池技术；
   

• 数据库连接池基本介绍
  1. 预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕再放回去；
  2. 数据库连接池负责分配、管理和释放数据库的连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个；
  3. 当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中；
     
• 数据库连接池种类：
  1. JDBC 的连接池使用javax.sql.DataSource 来表示，DataSource只是一个接口，该接口通常由第三方提供实现【提供jar包】；
  2. C3P0数据库连接池，速度相对较慢(稳定性不错) （hibernate, spring）
  3. DBCP数据库连接池，速度相对C3P0较快，但不稳定
  4. Proxool数据库连接池，有监控连接池状态的功能，稳定性较C3P0差一点
  5. BoneCP数据库连接池，速度快
  6. Druid(德鲁伊)是阿里提供的数据库连接池，集DBCP、C3P0、Proxool优点于一身的数据库连接池；

7.1 c3p0

作为第三方，一定会把DataSource接口实现；不同的数据库连接池技术实现方式不一样！
C3P0实现了DataSource接口，一定会提供一个jar包；
导入jar包：c3p0-0.9.1.2.jar

• 方式一，手动设置参数
  
  
  
• 方式二，配置文件c3p0-config.xml
  
  

7.2 德鲁伊

加入jar包: druid-1.1.10.jar, 版本要正确

7.2.1 德鲁伊工具类

基于Druid数据库连接池的工具类
import java.sql.Connection;

继续：在数据库连接池技术中，connection.close()表示将和连接之间的引用断掉，将连接放回到连接池

8.Apache-DBUtils工具类

1. commons-dbutils 是 Apache 组织提供的一个开源JDBC工具类库，它是对JDBC的封装，使用dbutils能极大地简化jdbc编码的工作量；
2. DbUtils类. QueryRunner类：该类封装了SQL的执行，是线程安全的，可以实现增、删、改、查、批处理；
3. 使用QueryRunner类实现查询；
4. ResultSetHandler接口：该接口用于处理java.sql.ResultSet, 将数据按要求转换为另一种形式；
   ArrayHandler：将结果集中的唯一一行数据转成对象数组；
   ArrayListHandler：将结果集中的每一行数据都转换成一个数组，再存放到List中；
   BeanHandler：将结果集中的唯一一行数据封装到一个对应的JavaBean实例中；
   BeanListHandler：将结果集中的每一行数据都封装到对应的JavaBean实例中，再存放到List中；
   ColumnListHandler：将结果集中的某一列的数据存放到List中；
   KeyedHandler(name)：将结果集中的唯一一行数据封装到Map中，再把这些Map再存放到一个Map中，其key为指定的key；
   MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后在存放到List中；

8.1多条查询，BeanListHandler

引入commons-dbutils-1.3.jar包
1. 实体类必须有无参构造器, 因为反射newInstance()需要调用缺省[默认]构造器;
2. 实体类属性名可以和数据库里的字段不一样, 但setter方法名要一样. 比如数据库里有一个id字段, 反射时对应实体类里的setId()方法
3. 如下所示, 此时的age属性也会被赋予id字段的值

private Integer age;
public void setId(Integer age) {
        this.age = age;
    }

其它值会为空, 类似下图

• queryRunner 源码分析
  
  
  

8.2单条查询，BeanHandler

8.3返回单行单列，ScalarHandler

8.4完成dml操作

8.5表和JavaBean的类型映射关系

数据库表	JavaBean
int	Integer
varchar	String
char	String
double	Double
date	String或者Date(java.util.Date而不是java.sql.Date)

注释：int, double等在Java中都用包装类，因为 mysql 中的所有类型都可能为NULL，而 Java 中只有引用数据类型才能为NULL值；

你的美（镁）偷走了我的❤（赵培竹）（锌)!!!

Mg + ZnSO₄ == MgSO₄ + Zn

9. BasicDAO

apache-druid 不足之处

1. SQL语句是固定的，不能通过参数传入，通用性不好，需要进行改进；
2. 对于select操作，如果有返回值，返回类型不能固定，需要使用泛型；
3. 将来的表很多，业务复杂，不可能靠一个Java类完成；
   

• 衍生
  

DAO基本说明
4. DAO，data access object，数据访问对象（访问数据库数据的对象）
5. 这样的通用类，称为 BasicDao，是专门和数据库交互的，即完成对数据库（表）的crud操作；
6. 在Basic基础上，可以实现一张表对应一个Dao，更好地完成操作；比如goods表-Goods.java类（javabean）-GoodsDao.java

9.1 DAO层

com.zzw.utils //工具类
com.zzw.domain //javabean
com.zzw.dao //存放XxxDAO和BasicDAO

• BasicDAO实现

/**
 * @author 赵志伟
 * @version 1.0
 * 开发BasicDAO，是其它DAO的父类
 */
public class BasicDAO<T> { //泛型指定具体类型

    private QueryRunner qr = new QueryRunner();

    //开发通用的dml方法，用来操作任意的表
    public int update(String sql, Object... param) {

        Connection connection = null;

        try {
            connection = JDBCUtilsDruid.getConnection();
            int update = qr.update(connection, sql, param);
            return update;
        } catch (SQLException e) {
            throw new RuntimeException(e);//将编译异常->运行异常，抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

    //返回多个对象，针对任意的表

    /**
     * @param sql sql语句，可以有 ?
     * @param clazz 传入一个类的Class对象，比如Actor.class
     * @param param 传入 占位符? 具体的值，可以有多个
     * @return 根据Actor.class 返回对应的ArrayList集合
     */
    public List<T> queryMany(String sql, Class<T> clazz, Object... param) {

        Connection connection = null;
        try {
            connection = JDBCUtilsDruid.getConnection();
            List<T> list =
                    qr.query(connection, sql, new BeanListHandler<T>(clazz), param);
            return list;
        } catch (SQLException e) {
            throw new RuntimeException(e);//将编译异常转换为运行异常，抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

    //查询单行
    public T querySingle(String sql, Class<T> clazz, Object... param) {

        Connection connection = null;

        try {
            connection = JDBCUtilsDruid.getConnection();
            T t = qr.query(connection, sql, new BeanHandler<T>(clazz), param);
            return t;
        } catch (SQLException e) {
            throw new RuntimeException(e);//编译异常->运行异常, 抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

    //查询单行单列的方法，即返回单值的方法
    public Object queryScalar(String sql, Object... param) {

        Connection connection = null;

        try {
            connection = JDBCUtilsDruid.getConnection();
            Object query =
                    qr.query(connection, sql, new ScalarHandler(), param);
            return query;
        } catch (SQLException e) {
            throw new RuntimeException(e);//编译异常->运行异常 抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }
}

• ActorDAO实现，别忘了规定BasicDAO的泛型

public class ActorDAO extends BasicDAO<Actor> {
    //ActorDAO对actor表的操作，而actor表是和Actor.java类相映射的
    //1.根据业务需求，可以编写特有的方法.

}

9.2 数据层

德鲁伊工具类

9.3 应用层

public class TestDAO {
    //测试ActorDAO对actor表的crud操作
    @Test
    public void testActorDAO() {
        ActorDAO actorDAO = new ActorDAO();
        //1.测试查询多行记录
        String sql = "select * from actor where id >= ?";
        List<Actor> list =
                actorDAO.queryMultiply(sql, Actor.class, 1);
        //(1 list.for
        //(2 iter
        for (Actor actor : list) {
            System.out.print(actor);
        }
        //2.测试查询单行记录
        Actor actor =
                actorDAO.querySingle("select * from actor where id = ?", Actor.class, 3);
        System.out.println(actor);
        //3.测试查询单行单列
        Object name = actorDAO.queryScalar("select `name` from actor where id = ?", 3);
        System.out.println(name);
        //4.执行 dml操作，insert, update, delete
        int update = actorDAO.update("insert into actor values (null, ?, ?, ?, ?)", "赵志伟❤赵培竹", "人", "2000-10-15", "133");
        System.out.println(update > 0 ? "执行成功" : "执行失败");
        int update1 = actorDAO.update("update actor set name = '奶头' where id = ?", 6);
        System.out.println(update1 > 0 ? "更新成功" : "更新失败");
        int update2 = actorDAO.update("delete from actor where id = ?", 6);
        System.out.println(update2 > 0 ? "删除成功" : "删除失败");
    }
}

10. 小结

数据库连接池有个接口DataSource，实现它时提供一个jar包。
mysql遵循jdbc规范提供了一个jar包，
这个jar包中有mysql实现的com.mysql.jdbc.driver类，利用它获得和数据库的连接