JDBC和数据库连接池_not loading a jdbc driver as driverclassname prope-CSDN博客

本文链接：https://blog.csdn.net/weixin_65508929/article/details/127592471

文章目录

JDBC概述

基本介绍

JDBC为访问不同的数据库提供了统一的接口，为使用者屏蔽了细节问题
Java程序员使用JDBC，可以连接任何提供了JDBC驱动程序的数据库系统，从而完成对数据库的各种操作
JDBC的基本原理图

一般将实现接口打包成jar包，只需要调用接口即可

模拟JDBC

JdbcInterface接口

package com.zanedu.jdbc.myjdbc;

//我们规定的jdbc接口(方法)
public interface JdbcInterface {

    //连接
    public Object getConnection();
    //crud操作
    public void crud();
    //关闭连接
    public void close();
}

MysqlJdbcImpl类

package com.zanedu.jdbc.myjdbc;

//模拟mysql数据库实现了jdbc接口
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的连接");
    }
}

OracleJdbcImpl类

package com.zanedu.jdbc.myjdbc;

//模拟oracle数据库实现jdbc
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的连接");
    }
}

测试类 TestJdbc

package com.zanedu.jdbc.myjdbc;

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

        //完成对oracle的操作
        JdbcInterface jdbcInterface2 = new OracleJdbcimpl();
        jdbcInterface2.getConnection();//通过接口来调用实现类 【动态绑定机制】
        jdbcInterface2.crud();
        jdbcInterface2.close();
    }
}

JDBC带来的好处

JDBC是Java提供一套用于数据库操作的接口API，Java程序员只需要面向这套接口编程即可，不同的数据库厂商，需要针对这套接口，提供不同的实现

JDBC API

JDBC API是一系列的接口，它统一和规范了应用程序与数据库的连接、执行SQL语句，并且得到返回结果等各类操作，相关类和接口在java.sql和javax.sql包中

JDBC快速入门

JDBC程序编写步骤

注册驱动 - 加载Driver类
获取连接 - 得到Connection
执行增删改查 - 发送SQL给mysql执行
释放资源 - 关闭相关连接

入门案例

通过JDBC对表actor进行添加、删除和修改操作

注意：首先要先将连接jar包导入到Java中【创建libs目录，将连接jar包放入里面】

这个包可以去官网下载，版本要跟MySQL的版本差不多
mysql-connector-java

然后将其添加为库【右键选择添加为库】

点击确定即可

连接connect

Statement接口

package com.zanedu.jdbc;

import com.mysql.cj.jdbc.Driver;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

//这是第一个JDBC程序，完成简单的操作
public class Jdbc01 {
    public static void main(String[] args) throws SQLException {

        //前置工作：在项目下创建一个文件夹，比如libs
        //将 mysql.jar 拷贝到该目录下，点击加入库中，加入到项目中才能使用

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

        //2. 得到连接
        // (1) jdbc:mysql:// 规定好的，表示协议，通过jdbc的方式连接mysql
        // (2) localhost 主机，也可以是ip地址
        // (3) 3306 表示mysql监听的端口
        // (4) bjpowernode 表示mysql dbms 的哪个数据库
        // (5) mysql的连接本质就是前面学过的socket连接
        String url = "jdbc:mysql://localhost:3306/bjpowernode";
        //将用户名和密码放入到Properties对象中
        Properties properties = new Properties();
        //说明：user 和 password 是规定好的，后面的值根据实际情况写
        properties.setProperty("user", "root");//用户
        properties.setProperty("password", "root");//密码

        Connection connect = driver.connect(url, properties);

        //3. 执行SQL语句
       	String sql = "insert into actor values(null, '刘德华', '男', '1970-11-11', '110')";
       	// String sql = "update actor set name = '周星驰' where id = 1";
        // String sql = "delete from actor where id = 1";
        //创建statement对象，用于执行静态SQL语句并返回其生成的结果的对象
        Statement statement = connect.createStatement();
        //statement.executeUpdate(sql) 即执行sql语句
        int rows = statement.executeUpdate(sql); //如果是DML语句，返回的就是影响的行数

        System.out.println(rows > 0 ? "成功" : "失败");

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

    }
}

注意：连接、驱动一般都是固定格式，不可改变

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

方式一

//方式一
@Test
public void connect01() throws SQLException {
    Driver driver = new Driver();
    String url = "jdbc:mysql://localhost:3306/bjpowernode";
    //将用户名和密码放入到Properties对象中
    Properties properties = new Properties();
    //说明：user 和 password 是规定好的，后面的值根据实际情况写
    properties.setProperty("user", "root");//用户
    properties.setProperty("password", "root");//密码

    Connection connect = driver.connect(url, properties);
    System.out.println(connect);
}

本方式属于静态加载，灵活性差，依赖性强

方式二

//方式二
@Test
public void connect02() throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
    //使用反射加载Driver，动态加载，更加的灵活，减少了依赖性
    Class<?> aClass = Class.forName("com.mysql.cj.jdbc.Driver");
    Driver driver = (Driver)aClass.newInstance();

    String url = "jdbc:mysql://localhost:3306/bjpowernode";
    //将用户名和密码放入到Properties对象中
    Properties properties = new Properties();
    //说明：user 和 password 是规定好的，后面的值根据实际情况写
    properties.setProperty("user", "root");//用户
    properties.setProperty("password", "root");//密码

    Connection connect = driver.connect(url, properties);
    System.out.println(connect);
}

本方式使用反射加载Driver，动态加载，更加的灵活，减少了依赖性

方式三

//方式三：使用 DriverManager 替代 Diver 进行统一管理
@Test
public void connect03() throws ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException {
    //使用反射加载Driver
    Class<?> aClass = Class.forName("com.mysql.cj.jdbc.Driver");
    Driver driver = (Driver)aClass.newInstance();

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

    DriverManager.registerDriver(driver); //注册Driver驱动

    Connection connection = DriverManager.getConnection(url, user, password);
    System.out.println("第三种方式 = " + connection);
}

本方式使用 DriverManager 替代 Diver 进行统一管理

方式四

//方式四：使用Class.forName 自动完成注册驱动，简化代码
//推荐使用，因为比较简便
@Test
public void connect04() throws ClassNotFoundException, SQLException {
    //使用反射加载了 Driver类
    //在加载 Driver类时，完成注册
    /*
    源码分析：1. 静态代码块，在类加载时会执行一次
             2. DriverManager.registerDriver(new Driver());
             3. 因此注册 driver 的工作已经完成了
        public class Driver extends NonRegisteringDriver implements java.sql.Driver {
            public Driver() throws SQLException {
            }

            static {
                try {
                    DriverManager.registerDriver(new Driver());
                } catch (SQLException var1) {
                    throw new RuntimeException("Can't register driver!");
                }
            }
        }
     */
    Class.forName("com.mysql.cj.jdbc.Driver");

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

    Connection connection = DriverManager.getConnection(url, user, password);
    System.out.println("第四种方式 = " + connection);
}

使用Class.forName 自动完成注册驱动，简化代码

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

但是建议还是写上Class.forName(“com.mysql.jc.jdbc.Driver”)，这样更加明确

方式五 - 推荐使用

mysql.properties配置文件

user=root
password=root
url=jdbc:mysql://localhost:3306/bjpowernode
driver=com.mysql.cj.jdbc.Driver
//方式五：在方式四的基础上改进，增加配置文件，让连接mysql更加灵活
@Test
public void connect05() throws IOException, ClassNotFoundException, SQLException {
    //通过Properties对象，获取配置文件的相关信息
    Properties properties = new Properties();
    properties.load(new FileInputStream("src\\mysql.properties"));
    //获取相关的值
    String user = properties.getProperty("user");
    String password = properties.getProperty("password");
    String driver = properties.getProperty("driver");
    String url = properties.getProperty("url");

    Class.forName(driver);//建议写上

    Connection connection = DriverManager.getConnection(url, user, password);

    System.out.println("方式五 = " + connection);
}

增加配置文件，让连接mysql更加灵活
将Connection connection = DriverManager.getConnection(“jdbc:mysql://localhost:3306/testdb”, “root”, “root”);中的字符串各个值，比如端口、数据库、用户名、密码写入配置文件.properties文件中

ResultSet[结果集]

基本介绍

表示数据库结果集的数据表，通常通过执行查询数据库的语句生成
ResultSet对象保持一个光标指向其当前的数据行。最初，光标位于第一行之前
next()方法可以将光标移动到下一行，并且由于在ResultSet对象中没有更多行时返回false，因此可以在while循环中使用循环来遍历结果集

应用实例

package com.zanedu.jdbc.resultset;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;

//演示 select 语句返回 ResultSet，并取出结果
@SuppressWarnings({"all"})
public class ResultSet_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
        //通过Properties对象，获取配置文件的相关信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        //1. 注册驱动
        Class.forName(driver);//建议写上

        //2. 得到连接
        Connection connection = DriverManager.getConnection(url, user, password);

        //3. 得到Statement
        Statement statement = connection.createStatement();

        //4. 组织SQL语句
        String sql = "select id, name, sex, borndate from actor";
        //executeQuery执行给定的SQL语句，该语句返回单个 ResultSet对象。
        /*
        +------+-----------+-----+---------------------+
        | id   | name      | sex | borndate            |
        +------+-----------+-----+---------------------+
        |    1 | 刘德华    | 男  | 1970-12-12 00:00:00 |
        |    7 | jack      | 男  | 1990-11-11 00:00:00 |
        +------+-----------+-----+---------------------+
         */
        /*
        看看 resultSet的源码

         */
        ResultSet resultSet = statement.executeQuery(sql);
        //刚开始就指向表头

        //5. 使用while循环取出数据
        while (resultSet.next()) { //next() 方法会让光标下移，如果没有更多的行，则返回false
            int id = resultSet.getInt(1); //获取该行的第一列数据
            //int id1 = resultSet.getInt("id");//通过列名来获取数据 - 推荐使用
            String name = resultSet.getString(2); //获取该行的第二列数据
            String sex = resultSet.getString(3); //获取该行的第三列数据
            String borndate = resultSet.getString(4);
            System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate);
        }

        //6. 关闭连接
        resultSet.close();
        statement.close();
        connection.close();

    }
}

Statement

基本介绍

Statement对象用于执行静态SQL语句并返回其生成的记过的对象
在建立连接后，需要对数据库进行访问，执行命名或是SQL语句，可以通过
1. Statement【存在SQL注入】
2. PreparedStatement【预处理】
3. CallableStatement【存储过程】
Statement对象执行SQL语句，存在SQL注入风险
SQL注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的SQL语句段或命令，恶意攻击数据库
要防范SQL注入，只要用PreparedStatement取代Statement就可以了

SQL注入

SQL注入就是即使不通过正确的账号密码，也可以通过万能密码进入系统

这种万能钥匙就是利用漏洞，将其变成一个name等于1或者name等于 and pwd =或者1等于1【恒成立】

package com.zanedu.jdbc.statement_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
import java.util.Scanner;

//演示Statement的注入问题
@SuppressWarnings({"all"})
public class Statement_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {

        Scanner scanner = new Scanner(System.in);
        //让用户输入管理员名和密码
        System.out.print("请输入管理员的名字："); // next(): 当接收到空格或者 '' 就表示结束了
        String admin_name = scanner.nextLine(); //说明：如果希望看到SQL注入效果，这里需要用nextLine: 回车才表示结束
        System.out.print("请输入管理员的密码：");
        String admin_pwd = scanner.nextLine();

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

        //1. 注册驱动
        Class.forName(driver);//建议写上

        //2. 得到连接
        Connection connection = DriverManager.getConnection(url, user, password);

        //3. 得到Statement
        Statement statement = connection.createStatement();

        //4. 组织SQL语句
        String sql = "select name, pwd from admin where name = '" + admin_name + "' and pwd = '" + admin_pwd + "' ";
        ResultSet resultSet = statement.executeQuery(sql);
        if (resultSet.next()) { //如果查询到一条记录，则说明该管理员存在
            System.out.println("恭喜，登录成功");
        } else {
            System.out.println("登录失败");
        }

        //关闭连接
        resultSet.close();
        statement.close();
        connection.close();

    }
}

本来我们的名字只有为tom，密码为123才能登录成功，但是现在用万能钥匙就可以登录

PreparedStatement

基本介绍

1， PreparedStatement执行的SQL语句中的参数用问号( ? )来表示，（ ? ）表示占位符，调用PreparedStatement对象的setXxx()方法来设置这些参数，setXxx()方法有两个参数，第一个参数是要设置的SQL语句中的参数的索引（从1开始），第二个是设置的SQL语句中的参数的值

调用executeQuery()，返回ResultSet对象
调用executeUpdate()，执行更新，包括增、删、修改

executeUpdate返回的是int类型
executeQuery返回的是ResultSet类型
setXxx()方法，第一个int表示第一个？号

预处理好处

不再使用 + 来拼接SQL语句，减少语法错误
有效的解决了SQL注入问题
大大减少了编译次数，效率较高

package com.zanedu.jdbc.preparedstatement_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
import java.util.Scanner;

//演示PreparedStatement使用
@SuppressWarnings({"all"})
public class PreparedStatement_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
//        PreparedStatement
        Scanner scanner = new Scanner(System.in);
        //让用户输入管理员名和密码
        System.out.print("请输入管理员的名字："); // next(): 当接收到空格或者 '' 就表示结束了
        String admin_name = scanner.nextLine(); //说明：如果希望看到SQL注入效果，这里需要用nextLine: 回车才表示结束
        System.out.print("请输入管理员的密码：");
        String admin_pwd = scanner.nextLine();

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

        //1. 注册驱动
        Class.forName(driver);//建议写上

        //2. 得到连接
        Connection connection = DriverManager.getConnection(url, user, password);

        //3. 得到PrepareStatement
        //3.1 组织SQL， sql语句的 ？号表示占位符
        String sql = "select name, pwd from admin where name = ? and pwd = ?";

        //3.2 preparedStatement 对象实现了PreparedStatement接口的实现类的对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //3.3 给 ？号赋值
        preparedStatement.setString(1, admin_name);
        preparedStatement.setString(2, admin_pwd);

        //4. 执行select 语句，使用executeQuery
        //   如果执行的是 DML（delete insert update） 那么要使用 executeUpdate()
        //   里面不用填sql，因为在前面已经构建连接了，即已经被前面的prepareStatement处理过了
        ResultSet resultSet = preparedStatement.executeQuery();
        if (resultSet.next()) {
            System.out.println("恭喜，登录成功");
        } else {
            System.out.println("对不起，登录失败");
        }

        //关闭连接
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}

这样子就能控制住了

注意：里面不需要再填sql了，因为在前面已经构建连接了，并且已经处理过了

加sql = error

JDBC的相关API小结

封装JDBCUtils【关闭连接，得到连接】

代码实现

说明：在jdbc操作中，获取连接和释放资源是经常使用到的，可以将其封装JDBC连接的工具类JDBCUtiles中

package com.zanedu.jdbc.utils;

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;

//这是一个工具类，完成mysql的连接和关闭资源
public class JDBCUtils {
    //定义相关的属性(4个)，因为只需要一份，因此，我们做成静态的static
    private static String user; //用户名
    private static String password; //密码
    private static String url; //url
    private static String driver; //驱动名

    //在static代码块去初始化
    static {
        try {
            Properties properties = new Properties();
            properties.load(new FileInputStream("src\\mysql.properties"));
            //读取相关的属性值
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            url = properties.getProperty("url");
            driver = properties.getProperty("driver");
        } catch (IOException e) {
            //在实际开发中，我们可以这样处理
            //原因：
            //1. 将编译异常转成运行异常
            //2. 这时调用者可以选择捕获，也可以选择默认处理该异常，比较方便
            throw new RuntimeException(e);
        }
    }

    //编写方法 - 连接，返回Connection
    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            //1. 将编译异常转成运行异常
            //2. 这时调用者可以选择捕获，也可以选择默认处理该异常，比较方便
            throw new RuntimeException(e);
        }
    }

    //关闭相关资源
    /*
        1. ResultSet 结果集
        2. Statement 或者 PreparedStatement
        3. Connection
        4. 如果需要关闭资源，就传入对象，否则传入null
     */
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
        //判断是否为null
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            //1. 将编译异常转成运行异常
            //2. 这时调用者可以选择捕获，也可以选择默认处理该异常，比较方便
            throw new RuntimeException(e);
        }
    }
}

实际使用工具类

package com.zanedu.jdbc.utils;

import org.junit.jupiter.api.Test;

import java.sql.*;

//该类演示如何使用JDBCUtils工具类，完成DML和select
public class JDBCUtils_Use {
    public static void main(String[] args) {

    }

    @Test
    public void testSelect() {
        //1. 得到连接
        Connection connection = null;

        //2. 组织一个sql
        String sql = "select * from actor";

        //3. 创建PreparedStatement对象
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            //给占位符赋值
            connection = JDBCUtils.getConnection();
            System.out.println(connection.getClass());//class com.mysql.cj.jdbc.ConnectionImpl
            preparedStatement = connection.prepareStatement(sql);

            //执行 - 得到结果集
            resultSet = preparedStatement.executeQuery();
            //遍历该结果集
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                String sex = resultSet.getString("sex");
                Date borndate = resultSet.getDate("borndate");
                String phone = resultSet.getString("phone");
                System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭资源
            JDBCUtils.close(resultSet, preparedStatement, connection);
        }
    }

    @Test
    public void testDML() { //insert update delete
        //1. 得到连接
        Connection connection = null;

        //2. 组织一个sql
        String sql = "update actor set name = ? where id = ?";

        //3. 创建PreparedStatement对象
        PreparedStatement preparedStatement = null;

        try {
            //给占位符赋值
            connection = JDBCUtils.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setString(1, "周星驰");
            preparedStatement.setInt(2, 1);
            //执行
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭资源
            JDBCUtils.close(null, preparedStatement, connection);
        }
    }
}

事务

基本介绍

JDBC程序中当一个Connection对象创建时，默认情况下是自动提交事务：每次执行一个SQL语句时，如果执行成功，就会向数据库自动提交，而不能回滚
JDBC程序中为了让多个SQL语句作为一个整体执行，需要使用事务
调用Connection的setAutoCommit(false)可以取消自动提交事务

在所有的SQL语句都成功执行后，调用Connection的commit()；方法提交事务
在其中某个操作失败或出现异常时，调用Connection的rollback()；方法回滚事务

应用实例

模拟转账业务

不使用事务可能出现的问题模拟 - 模拟转账业务

//没有使用事务
@Test
public void noTransaction() {
    //操作一个转账的业务
    //1. 得到连接
    Connection connection = null;

    //2. 组织一个sql
    String sql = "update account set balance = balance - 100 where id = 1";
    String sql2 = "update account set balance = balance + 100 where id = 2";

    //3. 创建PreparedStatement对象
    PreparedStatement preparedStatement = null;

    try {
        //给占位符赋值
        connection = JDBCUtils.getConnection(); //在默认情况下，connection对象是默认自动提交
        preparedStatement = connection.prepareStatement(sql);
        preparedStatement.executeUpdate(); //执行第一条语句

        int i = 1 / 0; //抛出异常

        preparedStatement = connection.prepareStatement(sql2);
        preparedStatement.executeUpdate(); //执行第二条语句
    } catch (SQLException e) {
        throw new RuntimeException(e);
    } finally {
        //关闭资源
        JDBCUtils.close(null, preparedStatement, connection);
    }
}

由于没有使用事务，即自动提交事务，因此执行第一条DML语句后，就直接提交了，而到异常那，结束，第二条DML语句没有执行提交，因此出现了马云少了100元，这就使得这100不知道去哪了

使用事务解决 - 模拟转账业务

//事务来解决
@Test
public void useTransaction() {
    //操作一个转账的业务
    //1. 得到连接
    Connection connection = null;

    //2. 组织一个sql
    String sql = "update account set balance = balance - 100 where id = 1";
    String sql2 = "update account set balance = balance + 100 where id = 2";

    //3. 创建PreparedStatement对象
    PreparedStatement preparedStatement = null;

    try {
        //给占位符赋值
        connection = JDBCUtils.getConnection(); //在默认情况下，connection对象是默认自动提交
        //将connection设置为不自动提交
        connection.setAutoCommit(false); //开启了事务

        preparedStatement = connection.prepareStatement(sql);
        preparedStatement.executeUpdate(); //执行第一条语句

        int i = 1 / 0; //抛出异常

        preparedStatement = connection.prepareStatement(sql2);
        preparedStatement.executeUpdate(); //执行第二条语句

        //这里提交事务
        connection.commit();

    } catch (SQLException e) {
        //这里我们可以进行回滚，即撤销执行的sql语句
        //默认回滚到事务开始的状态
        System.out.println("执行发生了异常，回滚，撤销执行的sql");
        try {
            connection.rollback();
        } catch (SQLException ex) {
            throw new RuntimeException(ex);
        }
        throw new RuntimeException(e);
    } finally {
        //关闭资源
        JDBCUtils.close(null, preparedStatement, connection);
    }
}

使用事务，就能将值控制住了，如果出现异常就直接回滚到上一次提交点（或开始事务的地方）
注意：connection.setAutoCommit(false); 就相当于开启了事务
正常情况

批处理

基本介绍

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

应用实例

演示向admin2表中添加5000条数据，看看使用批处理耗时多久

传统方式的处理

//传统方法，添加5000条数据到admin2
@Test
public void noBatch() throws SQLException {
    Connection connection = JDBCUtils.getConnection();
    String sql = "insert into admin2 values (null, ?, ?)";
    PreparedStatement preparedStatement = connection.prepareStatement(sql);

    System.out.println("开始执行");
    long start = System.currentTimeMillis();
    for (int i = 0; i < 5000; i++) { //5000次执行
        preparedStatement.setString(1, "jack" + i);
        preparedStatement.setString(2, "666");
        preparedStatement.executeUpdate();
    }
    long end = System.currentTimeMillis();
    System.out.println("传统的方式耗时 = " + (end - start));
    //关闭连接
    JDBCUtils.close(null, preparedStatement, connection);
}

批处理的方式

//使用批量方式添加数据
@Test
public void batch() throws SQLException {
    Connection connection = JDBCUtils.getConnection();
    String sql = "insert into admin2 values (null, ?, ?)";
    PreparedStatement preparedStatement = connection.prepareStatement(sql);

    System.out.println("开始执行");
    long start = System.currentTimeMillis();
    for (int i = 0; i < 5000; i++) { //5000次执行
        preparedStatement.setString(1, "jack" + i);
        preparedStatement.setString(2, "666");
        //将sql语句加入到批处理包中
        /*
        1. 第一次就创建ArrayList - elementData ==> Object[]
        2. elementData ==> Object[] 就会存放我们预处理的sql语句
        3. 当elementData满后，就按照1.5倍扩容
        4. 当添加到指定的值后，就执行批量处理executeBatch
        5. 批量处理会减少我们发送sql语句的网络开销，而且减少编译次数，因此效率提高

            public void addBatch() throws SQLException {
                synchronized(this.checkClosed().getConnectionMutex()) {
                    if (this.batchedArgs == null) {
                        this.batchedArgs = new ArrayList();
                    }

                    for(int i = 0; i < this.parameterValues.length; ++i) {
                        this.checkAllParametersSet(this.parameterValues[i], this.parameterStreams[i], i);
                    }

                    this.batchedArgs.add(new PreparedStatement.BatchParams(this.parameterValues, this.parameterStreams, this.isStream, this.streamLengths, this.isNull));
                }
            }
         */
        preparedStatement.addBatch();
        //当有1000条记录时，再批量执行
        if ((i + 1) % 1000 == 0) {
            preparedStatement.executeBatch();
            //再清空一把
            preparedStatement.clearBatch();
        }
    }
    long end = System.currentTimeMillis();
    System.out.println("批量方式耗时 = " + (end - start));
    //关闭连接
    JDBCUtils.close(null, preparedStatement, connection);
}
user=root
password=root
url=jdbc:mysql://localhost:3306/bjpowernode?rewriteBatchedStatements=true
driver=com.mysql.cj.jdbc.Driver

注意：使用批处理一定要在url后面加上?rewriteBatchedStatements=true，不然就不是批处理，速度不会变化

在url后加上?rewriteBatchedStatements=true后，速度明显提升

数据库连接池

引入

5000次连接数据库问题

package com.zanedu.jdbc.datasource;

import com.zanedu.jdbc.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.Connection;

public class ConQuestion {

    //连接 mysql 5000次
    @Test
    public void testCon() {
        for (int i = 0; i < 5000; i++) {
            //使用传统的JDBC方式，得到连接
            Connection connection = JDBCUtils.getConnection();
            //做一些工作，比如得到preparedStatement，发送sql
    }
}

数据库使用后，没有断开close，导致数据库内存泄漏

package com.zanedu.jdbc.datasource;

import com.zanedu.jdbc.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.Connection;

public class ConQuestion {

    //连接 mysql 5000次
    @Test
    public void testCon() {
        //看看连接-关闭 connection 会耗时多久
        long start = System.currentTimeMillis();
        System.out.println("开始连接");
        for (int i = 0; i < 5000; i++) {
            //使用传统的JDBC方式，得到连接
            Connection connection = JDBCUtils.getConnection();
            //做一些工作，比如得到preparedStatement，发送sql
            //关闭
            JDBCUtils.close(null, null, connection);
        }
        long end = System.currentTimeMillis();
        System.out.println("传统方式5000次，耗时 = " + (end - start));//传统方式5000次，耗时 = 49037
    }
}

传统获取Connection问题分析

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

基本介绍

预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从"缓冲池"当中取出一个，使用完毕之后再放回去
数据库连接池负责分配、管理和释放书库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个
当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中

数据库连接池种类

JDBC的数据库连接池使用javax.sql.DataSource来表示，DataSource只是一个接口，该接口通常由第三方提供实现【提供 .jar】
C3P0数据库连接池，速度相对较慢，稳定性不错【hibernate、spring】
DBCP数据库连接池，速度相对C3P0较快，但不稳定
Proxool数据库连接池，有监控连接池状态的功能，稳定性较C3P0差一点
BoneCP数据库连接池，速度快
Druid（德鲁伊）是阿里提供的数据库连接池，集DBCP、C3P0、Proxool优点于一身的数据库连接池

C3P0

使用之前也是跟connect一样，要先导入jar包
C3P0.jar

方式一：相关参数，在程序中指定user、url、password

//方式一：相关参数，在程序中指定user、url、password
@Test
public void testC3P0_01() throws Exception {
    //1. 创建一个数据源对象
    ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
    //2. 通过配置文件mysql.properties获取相关的信息
    Properties properties = new Properties();
    properties.load(new FileInputStream("src\\mysql.properties"));
    //读取相关的属性值
    String user = properties.getProperty("user");
    String password = properties.getProperty("password");
    String url = properties.getProperty("url");
    String driver = properties.getProperty("driver");

    //给数据源 comboPooledDataSource 设置相关的参数
    //注意：我们的连接的管理是由 comboPooledDataSource 来管理的，因此是其跟mysql建立连接，所以要设置各种参数
    comboPooledDataSource.setDriverClass(driver);
    comboPooledDataSource.setJdbcUrl(url);
    comboPooledDataSource.setUser(user);
    comboPooledDataSource.setPassword(password);
    //（初始化）设置数据源的连接数
    comboPooledDataSource.setInitialPoolSize(10);
    //最大连接数 - 即50个连接都被连接了，然后还有需要连接，那么就会进入等待队列
    comboPooledDataSource.setMaxPoolSize(50);
    //测试连接池的效率，测试连接mysql 5000次
    long start = System.currentTimeMillis();
    for (int i = 0; i < 5000; i++) {
        Connection connection = comboPooledDataSource.getConnection();//这个方法就是从DataSource接口实现的
        //        System.out.println("连接成功");
        connection.close();
    }

    long end = System.currentTimeMillis();
    System.out.println("c3p0 5000次连接mysql 耗时=" + (end - start));

}

方式二：使用配置文件模板来完成

使用的时候，只需要将数据源名称给上即可

//方式二：使用配置文件模板来完成
//1. 将c3p0 提供的 c3p0.config.xml配置文件拷贝到src目录下
//2. 该文件指定了连接数据库和连接池的相关参数
@Test
public void testC3P0_02() throws SQLException {

    ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("zan_edu");
    //测试 5000次 连接mysql
    long start = System.currentTimeMillis();
    for (int i = 0; i < 500000; i++) {
        Connection connection = comboPooledDataSource.getConnection();
//            System.out.println("连接成功");
        connection.close();
    }
    long end = System.currentTimeMillis();
    System.out.println("c3p0的第二种方式 耗时=" + (end - start));
}

c3p0-config.xml配置文件

<c3p0-config>
    <!-- 数据源名称代表连接池 -->
  <named-config name="zan_edu">
<!-- 驱动类 -->
  <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
  <!-- url-->
  	<property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/bjpowernode</property>
  <!-- 用户名 -->
  		<property name="user">root</property>
  		<!-- 密码 -->
  	<property name="password">root</property>
  	<!-- 每次增长的连接数-->
    <property name="acquireIncrement">5</property>
    <!-- 初始的连接数 -->
    <property name="initialPoolSize">10</property>
    <!-- 最小连接数 -->
    <property name="minPoolSize">5</property>
   <!-- 最大连接数 -->
    <property name="maxPoolSize">50</property>

	<!-- 可连接的最多的命令对象数 -->
    <property name="maxStatements">5</property> 
    
    <!-- 每个连接对象可连接的最多的命令对象数 -->
    <property name="maxStatementsPerConnection">2</property>
  </named-config>
</c3p0-config>

Druid（德鲁伊）

Druid的使用

使用之间，也是要加入Druid jar包

并且还要加入配置文件druid.properties

#key=value
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/bjpowernode?rewriteBatchedStatements=true
username=root
password=root
#initial connection Size
initialSize=10
#min idle connection size
minIdle=5
#max active connection size
maxActive=50
#max wait time (5000 mil seconds)
maxWait=5000
@Test
public void testDruid() throws Exception {
    //1. 加入 Druid jar包
    //2. 加入配置文件 druid.properties ，将该文件拷贝到项目的src目录下
    //3. 创建Properties对象，读取配置文件
    Properties properties = new Properties();
    properties.load(new FileInputStream("src\\druid.properties"));

    //4. 创建一个指定参数的数据库连接池 Druid连接池
    //dataSource就是数据源
    DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);

    long start = System.currentTimeMillis();
    for (int i = 0; i < 500000; i++) {
        Connection connection = dataSource.getConnection();
//            System.out.println("连接成功");
        connection.close();
    }
    long end = System.currentTimeMillis();
    System.out.println("druid连接池 操作500000次 耗时=" + (end - start));//druid连接池 操作5000次 耗时=1042
}

当循环次数为500000时，即连接500000次，就能发现druid的速度之快
C3P0连接500000次的速度

Druid连接500000次的速度

将JDBCUtils工具类改成Druid

package com.zanedu.jdbc.datasource;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

//基于Druid数据库连接池的工具类
public class JDBCUtilsByDruid {

    private static DataSource ds;

    //在静态代码块完成 ds的初始化
    static {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src\\druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //编写getConnection方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    //关闭连接，并不是真正的关闭，只是将连接放回连接池而已
    //在数据库连接池技术中，close方法不是真的断掉连接，而是把使用的连接对象Connection对象放回连接池
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

测试JDBCUtilsByDruid工具类

@Test
public void testSelect() {
    //1. 得到连接
    Connection connection = null;
    //2. 组织一个sql
    String sql = "select * from actor";
    //3. 创建PreparedStatement对象
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    try {
        //给占位符赋值
        connection = JDBCUtilsByDruid.getConnection();
        System.out.println(connection.getClass());//运行类型 class com.alibaba.druid.pool.DruidPooledConnection
        preparedStatement = connection.prepareStatement(sql);
        //执行 - 得到结果集
        resultSet = preparedStatement.executeQuery();
        //遍历该结果集
        while (resultSet.next()) {
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            String sex = resultSet.getString("sex");
            Date borndate = resultSet.getDate("borndate");
            String phone = resultSet.getString("phone");
            System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
        }
    } catch (SQLException e) {
        throw new RuntimeException(e);
    } finally {
        //关闭资源
        JDBCUtilsByDruid.close(resultSet, preparedStatement, connection);
    }
}

Apache-DBUtils

引入

关闭connection后，resultSet结果集无法使用
resultSet不利于数据的管理

被称为JavaBean或POJO或Domain

@Test
public void testSelect() {
    //1. 得到连接
    Connection connection = null;
    //2. 组织一个sql
    String sql = "select * from actor";
    //3. 创建PreparedStatement对象
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    try {
        //给占位符赋值
        connection = JDBCUtilsByDruid.getConnection();
        System.out.println(connection.getClass());//运行类型 class com.alibaba.druid.pool.DruidPooledConnection
        preparedStatement = connection.prepareStatement(sql);
        //执行 - 得到结果集
        resultSet = preparedStatement.executeQuery();
        connection.close();
        //遍历该结果集
        while (resultSet.next()) {
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            String sex = resultSet.getString("sex");
            Date borndate = resultSet.getDate("borndate");
            String phone = resultSet.getString("phone");
            System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
        }
    } catch (SQLException e) {
        throw new RuntimeException(e);
    } finally {
        //关闭资源
        JDBCUtilsByDruid.close(resultSet, preparedStatement, connection);
    }
}

将connection关闭后，就无法使用resultSet了

用土方法来解决 - 将resultSet封装成ArrayList

//使用土方法来解决ResultSet = 封装到 ArrayList中，即可以直接关闭connection
@Test
public /*ArrayList<Actor>*/ void testSelectToArrayList() {
    //1. 得到连接
    Connection connection = null;
    //2. 组织一个sql
    String sql = "select * from actor";
    //3. 创建PreparedStatement对象
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    ArrayList<Actor> list = new ArrayList<>();//创建ArrayList对象，存放actor对象
    try {
        //给占位符赋值
        connection = JDBCUtilsByDruid.getConnection();
        System.out.println(connection.getClass());//运行类型 class com.alibaba.druid.pool.DruidPooledConnection
        preparedStatement = connection.prepareStatement(sql);
        //执行 - 得到结果集
        resultSet = preparedStatement.executeQuery();
//            connection.close();
        //遍历该结果集
        while (resultSet.next()) {
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            String sex = resultSet.getString("sex");
            Date borndate = resultSet.getDate("borndate");
            String phone = resultSet.getString("phone");
            //把得到的resultSet的记录封装到Actor对象，然后放入到list集合中
            list.add(new Actor(id, name, sex, borndate, phone));
        }
//            System.out.println("list集合数据=" + list);
        for (Actor actor : list) {
            System.out.println("id=" + actor.getId() + "\tname=" + actor.getName());
        }

    } catch (SQLException e) {
        throw new RuntimeException(e);
    } finally {
        //关闭资源
        JDBCUtilsByDruid.close(resultSet, preparedStatement, connection);
    }
    //因为ArrayList和connection没有任何关联，所以该集合可以复用【再次使用】
//        return list;
}

这样子我们表里的数据就保存到了list集合里，如果要用直接调用list就可以了

基本介绍

commons-dbutils是Apache组织提供的一个开源JDBC工具类库，它是对JDBC的封装，使用dbutils能够极大的简化JDBC编码的工作量
DBUtils类
1. QueryRunner类：该类封装了SQL的执行，是线程安全的，可以实现增删改查、批处理
2. 使用QueryRunner类实现查询
3. ResultSetHandler接口：该接口用于处理java.sql.ResultSet，将数据按要求转换为另一种形式

ArrayHandler：把结果集中的每一行数据转换成对象数组

ArrayListHandler：把结果集中的每一行数据都转成一个数据，再存放到List中

BeanHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中

BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里

ColumnListHandler：将结果集中某一列的数据存放到List中

KeyedHandler(name)：将结果集中的每行数据都封装到Map里，再把这些map再存到一个map里，其key为指定的key

MapHandler：将结果集中的每一行数据封装到一个Map里，key是列名，value就是对应的值

MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List

应用实例

使用DBUtils + 数据库连接池（druid）方式，完成对表actor的crud

@Test
//使用 apache-DBUtils 工具类 + druid 完成对表的crud操作
public void testQueryMany() throws SQLException { //返回结果是多行的情况

    //1. 得到连接 (druid)
    Connection connection = JDBCUtilsByDruid.getConnection();
    //2. 使用 DBUtils 类和接口，那么就需要引入DBUtils相关的jar文件，加入到本项目
    //3. 创建 QueryRunner
    QueryRunner queryRunner = new QueryRunner();
    //4. 就可以执行相关的方法，返回一个ArrayList结果集
    String sql = "select * from actor where id >= ?";
    //   注意：该sql语句也可以查询部分列
    // String sql = "select id, name from actor where id >= ?";
    //解读：
    //(1) query方法 就是执行一个sql语句，得到resultSet，然后封装到 ArrayList集合中，然后返回集合
    //(2) connection：连接
    //(3) sql：执行的sql语句
    //(4) new BeanListHandler<>(Actor.class)：在将resultSet取出来，放到Actor对象，然后将其封装到ArrayList中
    //    底层会使用反射机制去获取 Actor 类的属性，然后进行封装
    //(5) 1：就是给sql语句中的？号赋值的，可以有多个值，因为它是可变参数
    //(6) 底层得到的resultSet，会在query关闭，还会关闭PreparedStatement
    /**
     * 分析query源码
     * public <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
     *         PreparedStatement stmt = null; //定义PreparedStatement
     *         ResultSet rs = null; //接受返回的ResultSet
     *         T result = null; //返回ArrayList
     *
     *         try {
     *             stmt = this.prepareStatement(conn, sql); //创建PreparedStatement
     *             this.fillStatement(stmt, params); //对sql语句进行 ？号赋值
     *             rs = this.wrap(stmt.executeQuery()); //执行sql语句，返回resultSet
     *             result = rsh.handle(rs); //返回的 resultSet 封装到 ArrayList[result] [使用到反射，对传入的class对象处理]
     *         } catch (SQLException var33) {
     *             this.rethrow(var33, sql, params);
     *         } finally {
     *             try {
     *                 this.close(rs); //关闭resultSet
     *             } finally {
     *                 this.close((Statement)stmt); //关闭PreparedStatement
     *             }
     *         }
     *
     *         return result;
     *     }
     */
    List<Actor> list =
            queryRunner.query(connection, sql, new BeanListHandler<>(Actor.class), 1);

    System.out.println("输出集合的信息");
    for (Actor actor : list) {
        System.out.println(actor);
    }

    //释放资源
    //底层得到的resultSet，会在query关闭，还会关闭PreparedStatement，因此两个null即可
    JDBCUtilsByDruid.close(null, null, connection);

}

看一下query的源码
我们可以看到query接受connection连接、sql语句、ResultSetHandler接口，还有可变参数params

public <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
    PreparedStatement stmt = null; //定义PreparedStatement
    ResultSet rs = null; //接受返回的ResultSet
    T result = null; //返回ArrayList
    	try {
            stmt = this.prepareStatement(conn, sql); //创建PreparedStatement
            this.fillStatement(stmt, params); //对sql语句进行 ？号赋值
            rs = this.wrap(stmt.executeQuery()); //执行sql语句，返回resultSet
            result = rsh.handle(rs); //返回的 resultSet 封装到 ArrayList[result] [使用到反射，对传入的class对象处理]
        } catch (SQLException var33) {
            this.rethrow(var33, sql, params);
        } finally {
            try {
            	this.close(rs); //关闭resultSet
            } finally {
                this.close((Statement)stmt); //关闭PreparedStatement
            }
        }
        return result;
	}

完成DML操作

@Test
//演示 apache-dbutils + druid 完成 DML操作（update、insert、delete）
public void testDML() throws SQLException {
    //1. 得到连接 (druid)
    Connection connection = JDBCUtilsByDruid.getConnection();
    //2. 使用 DBUtils 类和接口，那么就需要引入DBUtils相关的jar文件，加入到本项目
    //3. 创建 QueryRunner
    QueryRunner queryRunner = new QueryRunner();
    //4. 组织sql语句，完成 update、insert、delete
//        String sql = "update actor set name = ? where id = ?";
//        String sql = "insert into actor values (null, ?, ?, ?, ?)";
    String sql = "delete from actor where id = ?";

    //解读
    //(1) 执行DML操作是queryRunner.update()
    //(2) 返回值是受影响的行数 affectedRow
    int affectedRow = queryRunner.update(connection, sql, 8);
    System.out.println(affectedRow > 0 ? "执行成功" : "执行没有影响到表");

    //释放资源
    JDBCUtilsByDruid.close(null, null, connection);

表和JavaBean的类型映射关系

一般来说表中的类型对应的都是Java的引用类型

DAO和增删改查通用方法-BasicDAO

分析问题

apache-dbutils + Druid简化了JDBC开发，但还有不足：

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

基本介绍

DAO：data access object数据范围跟对象
这样的通用类，称为BasciDAO，是专门和数据库交互的，即完成对数据库(表)的crud操作
在BasicDAO的基础上，实现一张表对应一个DAO，更好的完成功能，比如Customer表-Customer.java(JavaBean)-CustomerDAO.java

BasicDAO应用实例

com.zanedu.dao_.utils //工具类
com.zanedu.dao_.domain //JavaBean
com.zanedu.dao_.dao //存放XxxDAO和BasicDAO
com.zanedu.dao_.test //写测试类

utils工具类

package com.zanedu.dao_.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

//基于Druid数据库连接池的工具类
public class JDBCUtilsByDruid {

    private static DataSource ds;

    //在静态代码块完成 ds的初始化
    static {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src\\druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //编写getConnection方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    //关闭连接，并不是真正的关闭，只是将连接放回连接池而已
    //在数据库连接池技术中，close方法不是真的断掉连接，而是把使用的连接对象Connection对象放回连接池
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

}

domain - Actor类

package com.zanedu.dao_.domain;

import java.util.Date;

//Actor对象和actor表的记录相对应
public class Actor { // Javabean、POJO、Domain对象
    private Integer id;
    private String name;
    private String sex;
    private Date borndate;
    private String phone;

    public Actor() { //一定要给个一个无参构造器，反射需要
    }

    public Actor(Integer id, String name, String sex, Date borndate, String phone) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.borndate = borndate;
        this.phone = phone;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBorndate() {
        return borndate;
    }

    public void setBorndate(Date borndate) {
        this.borndate = borndate;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Actor{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", borndate=" + borndate +
                ", phone='" + phone + '\'' +
                '}';
    }
}

BasicDAO类，完成各种方法

package com.zanedu.dao_.dao;

import com.zanedu.jdbc.datasource.JDBCUtilsByDruid;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

//开发BasicDAO，是其他DAO的父类
public class BasicDAO<T> { //泛型指定具体的类型

    private QueryRunner qr = new QueryRunner();

    //开发通用的DML方法，针对任意的表
    public int update(String sql, Object... parameters) {

        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();

            int update = qr.update(connection, sql, parameters);
            return update;

        } catch (SQLException e) {
            throw new RuntimeException(e); //将编译异常 -> 运行异常，抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

    //返回多个对象(即查询的结果是多行的)，针对任意的表
    /**
     *
     * @param sql sql语句，可以有 ?
     * @param clazz 传入一个类的Class对象，比如 Actor.class
     * @param parameters 传入 ? 的具体值，可以是多个
     * @return 根据 Actor.class 返回对应的 ArrayList集合
     */
    public List<T> queryMulti(String sql, Class<T> clazz, Object... parameters) {

        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return qr.query(connection, sql, new BeanListHandler<>(clazz), parameters);

        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

    //查询单行结果的通用方法
    public T querySingle(String sql, Class<T> clazz, Object... parameters) {
        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return qr.query(connection, sql, new BeanHandler<>(clazz), parameters);

        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

    //查询单行单列结果的方法，即返回单值的方法
    public Object queryScalar(String sql, Object... parameters) {
        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return qr.query(connection, sql, new ScalarHandler(), parameters);

        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }
}

ActorDAO类

package com.zanedu.dao_.dao;

import com.zanedu.dao_.domain.Actor;

public class ActorDAO extends BasicDAO<Actor>{
    //1. 就有 BasicDAO 的方法
    //2. 根据业务需求，可以编写特有的方法
}

测试类 - TestDAO

package com.zanedu.dao_.test;

import com.zanedu.dao_.dao.ActorDAO;
import com.zanedu.dao_.dao.GoodsDAO;
import com.zanedu.dao_.domain.Actor;
import org.junit.jupiter.api.Test;

import java.util.List;

public class TestDAO {

    //测试一下ActorDAO 对actor表的crud操作
    @Test
    public void testActorDAO() {
        ActorDAO actorDAO = new ActorDAO();
        //1. 查询语句
        List<Actor> actors = actorDAO.queryMulti("select * from actor where id >= ?", Actor.class, 1);
        for (Actor actor : actors) {
            System.out.println(actor);
        }

        //2. 查询单行记录
        Actor actor = actorDAO.querySingle("select * from actor where id = ?", Actor.class, 7);
        System.out.println("=========查询单行结果=========");
        System.out.println(actor);

        //3. 查询单行单列，即单值
        Object o = actorDAO.queryScalar("select name from actor where id = ?", 1);
        System.out.println("======查询单行单列结果======");
        System.out.println(o);

        //4. DML操作 - insert update delete
//        actorDAO.update("insert into actor values (null, '张无忌', '男', '2000-11-11', '999')");
        int update = actorDAO.update("insert into actor values (null, ?, ?, ?, ?)", "张无忌", "男", "2000-11-11", "999");

        System.out.println(update > 0 ? "执行成功" : "执行没有影响表");
    }
}