一、JDBC概述

1.1 基本介绍

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

1.2 模拟JDBC

  1. package com.hspedu.jdbc.myjdbc;
  3. /**
  4. * @author 韩顺平
  5. * @version 1.0
  6. * 我们规定的 jdbc 接口(方法)
  7. */
  8. public interface JdbcInterface {
  10. //连接
  11. public Object getConnection() ;
  12. //crud
  13. public void crud();
  14. //关闭连接
  15. public void close();
  17. }
  1. package com.hspedu.jdbc.myjdbc;
  3. /**
  4. * @author 韩顺平
  5. * @version 1.0
  6. * mysql 数据库实现了 jdbc 接口 [模拟] 【mysql 厂商开发】
  7. */
  8. public class MysqlJdbcImpl implements JdbcInterface{
  9. @Override
  10. public Object getConnection() {
  11. System.out.println("得到 mysql 的连接");
  12. return null;
  13. }
  15. @Override
  16. public void crud() {
  17. System.out.println("完成 mysql 增删改查");
  18. }
  20. @Override
  21. public void close() {
  22. System.out.println("关闭 mysql 的连接");
  23. }
  25. }
  1. package com.hspedu.jdbc.myjdbc;
  3. /**
  4. * @author 韩顺平
  5. * @version 1.0
  6. * 模拟 oracle 数据库实现 jdbc
  7. */
  8. public class OracleJdbcImpl implements JdbcInterface {
  9. @Override
  10. public Object getConnection() {
  11. System.out.println("得到 oracle 的连接 升级");
  12. return null;
  13. }
  14.     @Override
  15. public void crud() {
  16. System.out.println("完成 对 oracle 的增删改查");
  17. }
  19. @Override
  20. public void close() {
  21. System.out.println("关闭 oracle 的连接");
  22. }
  24. }
  1. package com.hspedu.jdbc.myjdbc;
  3. import org.junit.jupiter.api.Test;
  5. import java.io.FileInputStream;
  6. import java.sql.Connection;
  7. import java.sql.DriverManager;
  8. import java.sql.ResultSet;
  9. import java.sql.Statement;
  10. import java.util.Properties;
  11. import java.util.Scanner;
  13. /**
  14. * @author 韩顺平
  15. * @version 1.0
  16. */
  17. public class TestJDBC {
  18. public static void main(String[] args) throws Exception {
  19. //完成对 mysql 的操作
  20. JdbcInterface jdbcInterface = new MysqlJdbcImpl();
  21. jdbcInterface.getConnection(); //通过接口来调用实现类[动态绑定]
  22. jdbcInterface.crud();
  23. jdbcInterface.close();
  25. //完成对 oracle 的操作
  26. System.out.println("==============================");
  27. jdbcInterface = new OracleJdbcImpl();
  28. jdbcInterface.getConnection(); //通过接口来调用实现类[动态绑定]
  29. jdbcInterface.crud();
  30. jdbcInterface.close();
  32. }
  34. }

1.3 JDBC 带来的好处

  1. 如果Java 直接访问数据库，而数据库的种类又很多，这无疑增大了学习成本和操作难度
    image.png
  2. JDBC 是Java提供的一套用于数据库操作的接口 API，Java程序员只需要面向这套接口编程即可。不同的数据库厂商，需要针对这套接口，提供不同的实现
    image.png

1.4 JDBC API

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

二、JDBC快速入门

2.1 JDBC 程序编写步骤

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

2.2 快速上手

  1. package com.hspedu.jdbc;
  3. import com.mysql.jdbc.Driver;
  5. import java.sql.Connection;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  8. import java.util.Properties;
  10. /**
  11.  * @author HarborGao
  12.  * @version 1.0
  13.  * 这是第一个JDBC程序，完成简单的操作
  14.  */
  15. public class Jdbc01 {
  16.     public static void main(String[] args) throws SQLException {
  17.         //前置工作： 在项目下创建一个文件夹比如 libs
  18.         // 将 mysql.jar 拷贝到该目录下，点击 add to project ..加入到项目中
  19.         //1. 注册驱动
  20.         Driver driver = new Driver();
  21.         //2. 建立连接
  22.         // 解读
  23.         //(1) jdbc:mysql:// 规定好表示协议，通过 jdbc 的方式连接 mysql
  24.         //(2) localhost 主机，可以是 ip 地址
  25.         //(3) 3306 表示 mysql 监听的端口
  26.         //(4) hsp_db02 连接到 mysql dbms 的哪个数据库
  27.         //(5) mysql 的连接本质就是前面学过的 socket 连接
  28.         String url = "jdbc:mysql://localhost:3306/db01";
  29.         //将 用户名和密码放入到 Properties 对象
  30.         Properties properties = new Properties();
  31.         //说明 user 和 password 是规定好，后面的值根据实际情况写
  32.         properties.setProperty("user","root");
  33.         properties.setProperty("password","111");
  34.         Connection connect = driver.connect(url, properties);
  36.         //3. 执行 sql
  37.         //String sql = "insert into actor values(null,'黄蓉','女','1985-10-15','15636')";
  38.         //String sql = "update actor set `name` = '周星驰' where id = 1";
  39.         String sql = "delete from actor where id = 2";
  40.         //statement 用于执行静态 SQL 语句并返回其生成的结果的对象
  41.         Statement statement = connect.createStatement();
  42.         int rows = statement.executeUpdate(sql); // 如果是 dml 语句，返回的就是影响行数
  44.         System.out.println(rows > 0 ? "成功" : "失败");
  46.         //4. 断开连接
  47.         statement.close();
  48.         connect.close();
  49.     }
  50. }

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

  1. 方式一
    image.png
  2. 方式二
    image.png
  3. 方式三
    image.png
  4. 方式四
    image.png
  5. 方式五
    image.png
  1. package com.hspedu.jdbc;
  3. import com.mysql.jdbc.Driver;
  4. import org.junit.jupiter.api.Test;
  6. import java.io.FileInputStream;
  7. import java.io.IOException;
  8. import java.sql.Connection;
  9. import java.sql.DriverManager;
  10. import java.sql.SQLException;
  11. import java.util.Properties;
  13. /**
  14.  * @author HarborGao
  15.  * @version 1.0
  16.  * 分析Java连接MySQL的五种方式
  17.  */
  19. public class JdbcConn {
  20.     //方式一
  21.     @Test
  22.     public void connect01() throws SQLException {
  23.         Driver driver = new Driver();
  24.         String url = "jdbc:mysql://localhost:3306/db01";
  25.         Properties properties = new Properties();
  26.         properties.setProperty("user","root");
  27.         properties.setProperty("password","111");
  28.         Connection connect = driver.connect(url, properties);
  29.         System.out.println("第一种方式" + connect);
  30.         connect.close();
  31.     }
  32.     //方式二
  33.     @Test
  34.     public void connect02() throws Exception {
  35.         //使用反射加载Driver类，动态加载，更加灵活，减少依赖性
  36.         Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
  37.         Driver driver = (Driver)aClass.newInstance();
  39.         String url = "jdbc:mysql://localhost:3306/db01";
  40.         Properties properties = new Properties();
  41.         properties.setProperty("user","root");
  42.         properties.setProperty("password","111");
  43.         Connection connect = driver.connect(url, properties);
  44.         System.out.println("第二种方式 " + connect);
  45.         connect.close();
  46.     }
  47.     //方式三 使用 DriverManager 替代 Driver 进行统一管理
  48.     @Test
  49.     public void connect03() throws Exception {
  50.         Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
  51.         Driver driver = (Driver)aClass.newInstance();
  53.         //创建 url 和 user 和 password
  54.         String url = "jdbc:mysql://localhost:3306/db01";
  55.         String user = "root";
  56.         String password = "111";
  58.         DriverManager.registerDriver(driver);  //注册Driver驱动
  60.         Connection connection = DriverManager.getConnection(url, user, password);
  61.         System.out.println("第三种方式 " + connection);
  62.         connection.close();
  63.     }
  65.     //方式四:使用 Class.forName 自动完成注册驱动，简化代码
  66.     //这种方式在工作中使用最多，推荐使用
  67.     @Test
  68.     public void connect04() throws ClassNotFoundException, SQLException {
  69.         //使用反射加载 Driver类
  70.         //在加载 Driver类时，自动完成注册
  71.         /*
  72.         源码：
  73.         1. 静态代码块，在类加载时，执行一次
  74.         2. DriverManager.registerDriver(new Driver());
  75.         3. 因此注册 Driver 的工作已经自动完成
  76.         static {
  77.             try {
  78.                 DriverManager.registerDriver(new Driver());
  79.             } catch (SQLException var1) {
  80.                 throw new RuntimeException("Can't register driver!");
  81.             }
  82.         }
  83.          */
  84.         //Class.forName("com.mysql.jdbc.Driver");  //驱动5.1.6版之后可以省略不写，建议写上
  86.         //创建 url 和 user 和 password
  87.         String url = "jdbc:mysql://localhost:3306/db01";
  88.         String user = "root";
  89.         String password = "111";
  91.         Connection connection = DriverManager.getConnection(url, user, password);
  92.         System.out.println("第四种方式 " + connection);
  94.         connection.close();
  95.     }
  97.     //方式五 在方式四的基础上改进，增加配置文件，让连接MySQL更加灵活
  98.     @Test
  99.     public void connect05() throws ClassNotFoundException, SQLException, IOException {
  100.         //通过Properties对象获取配置文件信息
  101.         Properties properties = new Properties();
  102.         properties.load(new FileInputStream("src\\mysql.properties"));
  103.         String user = properties.getProperty("user");
  104.         String password = properties.getProperty("password");
  105.         String driver = properties.getProperty("driver");
  106.         String url = properties.getProperty("url");
  108.         Class.forName(driver);
  109.         Connection connection = DriverManager.getConnection(url, user, password);
  110.         System.out.println("第五种方式 " + connection);
  112.         connection.close();
  113.     }
  114. }
  1. user=root
  2. password=123456
  3. url=jdbc:mysql://localhost:3306/db01
  4. driver=com.mysql.jdbc.Driver

三、ResultSet【结果集】

3.1 基本介绍

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

3.2 应用案例

image.png

  1. package com.hspedu.jdbc;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.sql.*;
  6. import java.util.Properties;
  8. /**
  9.  * @author HarborGao
  10.  * @version 1.0
  11.  */
  12. @SuppressWarnings({"all"})
  13. public class ResultSet_ {
  14.     public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
  15.         Properties properties = new Properties();
  16.         properties.load(new FileInputStream("src\\mysql.properties"));
  17.         String user = properties.getProperty("user");
  18.         String password = properties.getProperty("password");
  19.         String driver = properties.getProperty("driver");
  20.         String url = properties.getProperty("url");
  22.         //1. 注册驱动
  23.         Class.forName(driver);
  24.         //2. 得到连接
  25.         Connection connection = DriverManager.getConnection(url, user, password);
  26.         //3. 得到Statement
  27.         Statement statement = connection.createStatement();
  28.         //4. 组织sql
  29.         String sql = "select id,`name`,sex,borndate from actor";
  30.         //执行给定的 SQL语句，该语句返回单个ResultSet结果集
  31.         ResultSet resultSet = statement.executeQuery(sql);
  32.         //5. 使用while取出数据
  33.         while (resultSet.next()) {
  34.             int id = resultSet.getInt(1);  //获取该行的第1列数据
  35.             String name = resultSet.getString(2); //获取该行的第2列数据
  36.             String sex = resultSet.getString(3); //获取该行的第3列数据
  37.             Date borndate = resultSet.getDate(4); //获取该行的第4列数据
  38.             System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate);
  39.         }
  40.         //6. 关闭连接
  41.         resultSet.close();
  42.         statement.close();
  43.         connection.close();
  44.     }
  45. }

四、Statement

4.1 基本介绍

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

4.2 演示SQL注入

  1. -- 演示 sql 注入
  2. -- 创建一张表
  3. CREATE TABLE admin ( -- 管理员表
  4. `user` VARCHAR(32) NOT NULL UNIQUE,
  5. `password` VARCHAR(32) NOT NULL DEFAULT '') CHARACTER SET utf8;
  7. -- 添加数据
  8. INSERT INTO admin VALUES('tom', '123');
  10. -- 查找某个管理是否存在
  12. SELECT *
  13. FROM admin
  14. WHERE `user` = 'tom' AND `password` = '123';
  15. -- SQL
  16. -- 输入用户名 为 1' or
  17. -- 输入万能密码 为 or '1'= '1
  18. SELECT *
  19. FROM admin
  20. WHERE `user` = '1' OR' AND `password` = 'OR '1'= '1';
  21. SELECT * FROM admin;
  1. package com.hspedu.jdbc.statement_;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.sql.Connection;
  6. import java.sql.DriverManager;
  7. import java.sql.ResultSet;
  8. import java.sql.Statement;
  9. import java.util.Properties;
  10. import java.util.Scanner;
  12. /**
  13.  * @author HarborGao
  14.  * @version 1.0
  15.  * 演示 Statement 的SQL注入问题
  16.  */
  17. @SuppressWarnings({"all"})
  18. public class Statement_ {
  19.     public static void main(String[] args) throws Exception {
  20.         Properties properties = new Properties();
  21.         properties.load(new FileInputStream("src\\mysql.properties"));
  22.         String user = properties.getProperty("user");
  23.         String password = properties.getProperty("password");
  24.         String driver = properties.getProperty("driver");
  25.         String url = properties.getProperty("url");
  27.         Scanner scanner = new Scanner(System.in);
  28.         System.out.print("请输入用户名：");  //next() 当接收到空格或者'就是表示结束
  29.         //输入 1' or
  30.         String admin_user = scanner.nextLine(); //如果希望看到SQL注入效果，这里需要用nextLine
  31.         System.out.print("请输入密码：");
  32.         //输入 or '1' = '1
  33.         String admin_pwd = scanner.nextLine();
  35.         Class.forName(driver);
  36.         Connection connection = DriverManager.getConnection(url, user, password);
  37.         Statement statement = connection.createStatement();
  38.         String sql = "select `user`,`password` from `admin` where `user` = '"+ admin_user +"' " +
  39.                 "and `password` = '" + admin_pwd + "'";
  40.         ResultSet resultSet = statement.executeQuery(sql);
  41.         if (resultSet.next()) {
  42.             System.out.println("恭喜，登陆成功！");
  43.         } else {
  44.             System.out.println("登陆失败");
  45.         }
  46.         resultSet.close();
  47.         statement.close();
  48.         connection.close();
  49.     }
  50. }

五、 PreparedStatement

5.1 基本介绍

  1. PrepareStatement 执行的SQL 语句中的参数用问号( ? ) 来表示，调用 PrepareStatement 对象的 setXxx() 方法来设置这些参数。setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引（从1开始），第二个是设置的SQL语句中的参数的值
  2. 调用 executeQuery()，返回 ResultSet 对象
  3. 调用 executeUpdate() ，执行更新，包括 增、删、修改

5.2 预处理的好处

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

5.3 应用案例

  1. package com.hspedu.jdbc.preparestatement_;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.sql.*;
  6. import java.util.Properties;
  7. import java.util.Scanner;
  9. /**
  10.  * @author HarborGao
  11.  * @version 1.0
  12.  * 演示 PrepareStatement 使用
  13.  */
  14. public class PrepareStatement_ {
  15.     public static void main(String[] args) throws Exception {
  16.         Properties properties = new Properties();
  17.         properties.load(new FileInputStream("src\\mysql.properties"));
  18.         String user = properties.getProperty("user");
  19.         String password = properties.getProperty("password");
  20.         String driver = properties.getProperty("driver");
  21.         String url = properties.getProperty("url");
  23.         Scanner scanner = new Scanner(System.in);
  24.         System.out.print("请输入用户名：");  //next() 当接收到空格或者'就是表示结束
  25.         String admin_user = scanner.nextLine(); //如果希望看到SQL注入效果，这里需要用nextLine
  26.         System.out.print("请输入密码：");
  27.         String admin_pwd = scanner.nextLine();
  29.         Class.forName(driver);
  30.         Connection connection = DriverManager.getConnection(url, user, password);
  31.         String sql = "select `user`,`password` from admin where `user` = ? and `password` = ?";
  32. //        preparedStatement 对象实现了 PreparedStatement 接口的实现类的对象
  33.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  34.         preparedStatement.setString(1,admin_user);
  35.         preparedStatement.setString(2,admin_pwd);
  36.         ResultSet resultSet = preparedStatement.executeQuery();
  37.         if (resultSet.next()) {
  38.             System.out.println("恭喜，登陆成功！");
  39.         } else {
  40.             System.out.println("登陆失败");
  41.         }
  42.         resultSet.close();
  43.         preparedStatement.close();
  44.         connection.close();
  45.     }
  46. }
  1. package com.hspedu.jdbc.preparedstatement_;
  3. import java.io.FileInputStream;
  4. import java.sql.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8. import java.util.Properties;
  9. import java.util.Scanner;
  10. /**
  11.  * @author 韩顺平
  12.  * @version 1.0
  13.  * 演示 PreparedStatement 使用 dml 语句
  14.  */
  15. @SuppressWarnings({"all"})
  16. public class PreparedStatementDML_ {
  17.     public static void main(String[] args) throws Exception {
  19.         //看 PreparedStatement 类图
  21.         Scanner scanner = new Scanner(System.in);
  23.         //让用户输入管理员名和密码
  24.         System.out.print("请输删除管理员的名字: "); //next(): 当接收到 空格或者 '就是表示结束
  25.         String admin_name = scanner.nextLine(); // 老师说明，如果希望看到 SQL 注入，这里需要用 nextLine
  26.         // System.out.print("请输入管理员的新密码: ");
  27.         // String admin_pwd = scanner.nextLine();
  29.         //通过 Properties 对象获取配置文件的信息
  31.         Properties properties = new Properties();
  32.         properties.load(new FileInputStream("src\\mysql.properties"));
  33.         //获取相关的值
  34.         String user = properties.getProperty("user");
  35.         String password = properties.getProperty("password");
  36.         String driver = properties.getProperty("driver");
  37.         String url = properties.getProperty("url");
  39.         //1. 注册驱动
  40.         Class.forName(driver);//建议写上
  42.         //2. 得到连接
  43.         Connection connection = DriverManager.getConnection(url, user, password);
  45.         //3. 得到 PreparedStatement
  46.         //3.1 组织 SqL , Sql 语句的 ? 就相当于占位符
  47.         //添加记录
  48.         //String sql = "insert into admin values(?, ?)";
  49.         //String sql = "update admin set pwd = ? where name = ?";
  50.         String sql = "delete from admin where name = ?";
  51.         //3.2 preparedStatement 对象实现了 PreparedStatement 接口的实现类的对象
  52.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  53.         //3.3 给 ? 赋值
  54.         preparedStatement.setString(1, admin_name);
  56.         //preparedStatement.setString(2, admin_name);
  58.         //4. 执行 dml 语句使用 executeUpdate
  59.         int rows = preparedStatement.executeUpdate();
  60.         System.out.println(rows > 0 ? "执行成功" : "执行失败");
  61.         //关闭连接
  62.         preparedStatement.close();
  63.         connection.close();
  64.     }
  65. }

5.4 小练习

  1. 创建admin表
  2. 使用PreparedStatement添加5条数据
  3. 修改tom的记录，将name改成king
  4. 删除一条的记录
  5. 查询全部记录，并显示在控制台

六、JDBC 的相关API 小结

JDBC 和数据库连接池 - 图12

七、封装 JDBCUtils

7.1 说明

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

7.2 代码实现

  1. package com.hspedu.jdbc.utils;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.sql.*;
  6. import java.util.Properties;
  8. /**
  9.  * @author HarborGao
  10.  * @version 1.0
  11.  */
  12. public class JDBCUtils {
  13.     //定义相关属性(4个),因为只需要一份，因此，我们做成 static
  14.     private static String user;
  15.     private static String password;
  16.     private static String driver;
  17.     private static String url;
  19.     //在static代码块初始化
  20.     static {
  21.         Properties properties = null;
  22.         try {
  23.             properties = new Properties();
  24.             properties.load(new FileInputStream("src\\mysql.properties"));
  25.             user = properties.getProperty("user");
  26.             password = properties.getProperty("password");
  27.             driver = properties.getProperty("driver");
  28.             url = properties.getProperty("url");
  29.         } catch (IOException e) {
  30.             //在实际开发中，可以做以下处理
  31.             //1. 将编译异常转成运行异常
  32.             //2. 这时调用者可以选择捕获该异常，也可以选择默认处理该异常，比较方便
  33.             throw new RuntimeException(e);
  34.         }
  35.     }
  37.     public static Connection getConnection() throws IOException {
  38.         try {
  39.             return DriverManager.getConnection(url, user, password);
  40.         } catch (SQLException e) {
  41.             throw new RuntimeException(e);
  42.         }
  43.     }
  45.     //关闭相关资源
  46.     /*
  47.     1. ResultSet 结果集
  48.     2. Statement 或者 PreparedStatement
  49.     3. Connection
  50.     4. 如果需要关闭资源，就传入对象，否则传入 null
  51.      */
  52.     public static void close(ResultSet set, Statement statement, Connection connection) {
  53.         try {
  54.             if (set != null) {
  55.                 set.close();
  56.             }
  57.             if (statement != null) {
  58.                 statement.close();
  59.             }
  60.             if (connection != null) {
  61.                 connection.close();
  62.             }
  63.         } catch (SQLException e) {
  64.             throw new RuntimeException(e);
  65.         }
  66.     }
  67. }

7.3 使用案例

  1. package com.hspedu.jdbc;
  3. import com.hspedu.jdbc.utils.JDBCUtils;
  5. import java.io.IOException;
  6. import java.sql.Connection;
  7. import java.sql.PreparedStatement;
  8. import java.sql.ResultSet;
  9. import java.sql.SQLException;
  11. /**
  12.  * @author HarborGao
  13.  * @version 1.0
  14.  * 演示如何使用JDBCUtils 工具类，完成DML和select操作
  15.  */
  16. public class JDBCUtils_Use {
  17.     public static void main(String[] args){
  18.         //1. 得到连接
  19.         Connection connection = JDBCUtils.getConnection();
  20.         //2. DML操作
  21.         //String sql = "insert into admin values(?,?)";
  22.         //String sql = "update admin set `password` = ? where `user` = ?";
  23.         /*String sql = "delete from admin where `user` = ?";
  24.         PreparedStatement preparedStatement = connection.prepareStatement(sql);
  25. //        preparedStatement.setString(1,"0000");
  26. //        preparedStatement.setString(2,"bob");
  27.         preparedStatement.setString(1,"xin");
  28.         int rows = preparedStatement.executeUpdate();
  29.         System.out.println(rows > 0 ? "成功" : "失败");*/
  30.         //Query操作
  31.         String sql = "select * from admin where `user` = ?";
  32.         PreparedStatement preparedStatement = null;
  33.         ResultSet resultSet = null;
  34.         try {
  35.             preparedStatement = connection.prepareStatement(sql);
  36.             preparedStatement.setString(1,"jack");
  37.             resultSet = preparedStatement.executeQuery();
  39.             while (resultSet.next()) {
  40.                 String user = resultSet.getString("user");
  41.                 String password = resultSet.getString("password");
  42.                 System.out.println(user + "\t" + password);
  43.             }
  44.         } catch (SQLException e) {
  45.             e.printStackTrace();
  46.         } finally {
  47.             //3. 关闭连接
  48.             //JDBCUtils.close(null,preparedStatement,connection);
  49.             JDBCUtils.close(resultSet,preparedStatement,connection);
  50.         }
  51.     }
  52. }

八、事务

8.1 基本介绍

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

8.2 应用实例

  1. 不使用事务时模拟转账出现的问题 ``sql CREATE table account ( id INT PRIMARY KEY AUTO_INCREMENT,name` VARCHAR(32) NOT NULL DEFAULT ‘’, balance DOUBLE NOT NULL DEFAULT 0 ) CHARACTER SET utf8;

INSERT INTO account VALUES(null,’马云’,3000),(null,’马化腾’,10000);

SELECT * FROM account;

  1. ```java
  2. package com.hspedu.jdbc.transaction_;
  4. import com.hspedu.jdbc.utils.JDBCUtils;
  6. import java.sql.Connection;
  7. import java.sql.PreparedStatement;
  8. import java.sql.SQLException;
  10. /**
  11.  * @author HarborGao
  12.  * @version 1.0
  13.  * 模拟不使用事务出现的问题 - 转账
  14.  */
  15. public class Transaction_ {
  16.     public static void main(String[] args) {
  17.         Connection connection = JDBCUtils.getConnection();
  18.         PreparedStatement preparedStatement = null;
  19.         try {
  20.             String sql1 = "update account set `balance` = balance - 1000 where `name` = '马云'";
  21.             preparedStatement = connection.prepareStatement(sql1);
  22.             int rows = preparedStatement.executeUpdate();
  23.             System.out.println(rows > 0 ? "扣款成功" : "扣款失败");
  24.             int i = 10/0;
  25.             String sql2 = "update account set `balance` = balance + 1000 where `name` = '马化腾'";
  26.             preparedStatement = connection.prepareStatement(sql2);
  27.             int rows2 = preparedStatement.executeUpdate();
  28.             System.out.println(rows2 > 0 ? "成功到账" : "没有到账");
  29.         } catch (SQLException e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.             JDBCUtils.close(null,preparedStatement,connection);
  33.         }
  34.     }
  35. }

image.png
image.png

  1. 使用事务解决上述问题 ```java package com.hspedu.jdbc.transaction_;

import com.hspedu.jdbc.utils.JDBCUtils;

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

/**

  • @author HarborGao
  • @version 1.0

  • 模拟使用事务解决问题 - 转账 */ public class Transaction_ { public static void main(String[] args) {

    1.  Connection connection = JDBCUtils.getConnection();
    2.  String sql1 = "update account set `balance` = balance - 1000 where `name` = '马化腾'";
    3.  String sql2 = "update account set `balance` = balance + 1000 where `name` = '马云'";
    4.  PreparedStatement preparedStatement = null;
    5.  try {
    6.      connection.setAutoCommit(false);
    7.      preparedStatement = connection.prepareStatement(sql1);
    8.      preparedStatement.executeUpdate();
    9.      int i = 1 / 0;
    10.      preparedStatement = connection.prepareStatement(sql2);
    11.      preparedStatement.executeUpdate();
    13.  } catch (Exception e) {
    14.      try {
    15.          System.out.println("发生了异常，回滚...");
    16.          connection.rollback();
    17.      } catch (SQLException ex) {
    18.          ex.printStackTrace();
    19.      }
    20.      System.out.println(e.getMessage());
    21.  } finally {
    22.      try {
    23.          connection.commit();
    24.      } catch (SQLException e) {
    25.          e.printStackTrace();
    26.      }
    27.      JDBCUtils.close(null,preparedStatement,connection);
    28.  }

    } } ```

九、批处理

9.1 基本介绍

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

9.2 应用实例

  1. 演示向 admin2 表中添加 5000 条数据，看看使用批处理耗时多久
  2. 注意：需要修改配置文件，在url中加参数 ```java package com.hspedu.jdbc.batch_;

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

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

/**

  • @author HarborGao
  • @version 1.0

  • 演示Java的批处理 */ public class Batch_ { //传统方法，添加5000条数据到admin2 @Test public void noBatch() throws Exception {

    1.  long start = System.currentTimeMillis();
    2.  Connection connection = JDBCUtils.getConnection();
    3.  String sql = "insert into admin2 values(null,?,?)";
    4.  PreparedStatement preparedStatement = connection.prepareStatement(sql);
    5.  for (int i = 0; i < 5000; i++) {
    6.      preparedStatement.setString(1,"jack" + i);
    7.      preparedStatement.setString(2,"666");
    8.      preparedStatement.executeUpdate();
    9.  }
    10.  //关闭连接
    11.  JDBCUtils.close(null,preparedStatement,connection);
    12.  long stop = System.currentTimeMillis();
    13.  System.out.println("传统方式耗时 " + (stop - start));  //传统方式耗时 16725

    }

    //使用批量处理添加数据 @Test public void useBatch() throws Exception {

    1.  long start = System.currentTimeMillis();
    2.  Connection connection = JDBCUtils.getConnection();
    3.  String sql = "insert into admin2 values(null,?,?)";
    4.  PreparedStatement preparedStatement = connection.prepareStatement(sql);
    5.  for (int i = 0; i < 5000; i++) {
    6.      preparedStatement.setString(1,"jack" + i);
    7.      preparedStatement.setString(2,"666");
    8.      //将SQL语句加入到批量处理包中
    9.      preparedStatement.addBatch();
    10.      //当有1000条记录时，再批量执行
    11.      if ((i + 1) % 1000 == 0) {
    12.          preparedStatement.executeBatch();
    13.          //清空批量处理包，以备下次使用
    14.          preparedStatement.clearBatch();
    15.      }
    16.  }
    17.  //关闭连接
    18.  JDBCUtils.close(null,preparedStatement,connection);
    19.  long stop = System.currentTimeMillis();
    20.  System.out.println("批量方式耗时 " + (stop - start));  //批量方式耗时 273

    } } ```

十、数据库连接池

10.1 5k次连接数据库问题

  1. 编写程序完成连接MySQL数据库5000次的操作
  2. 看看有什么问题，耗时多久？ ```java package com.hspedu.jdbc.datasource;

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

import java.sql.Connection;

/**

  • @author HarborGao
  • @version 1.0 */ public class ConQuestion { //连接5000次 MySQL @Test public void testCon() {
    1.  for (int i = 0; i < 5000; i++) {
    2.      //使用传统的JDBC方式，得到连接
    3.      Connection connection = JDBCUtils.getConnection();
    4.      //做一些工作，比如得到PreparedStatement,发送 sql
    5.      //.....
    6.      //关闭
    7.      JDBCUtils.close(null,null,connection);
    8.  }
    } } ```

10.2 传统获取 Connection问题分析

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

10.3 数据库连接池基本介绍

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

10.4 数据库连接池种类

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

10.5 C3P0 应用实例

  1. package com.hspedu.jdbc.datasource;
  3. import com.mchange.v2.c3p0.ComboPooledDataSource;
  4. import org.junit.jupiter.api.Test;
  6. import java.io.FileInputStream;
  7. import java.sql.Connection;
  8. import java.sql.SQLException;
  9. import java.util.Properties;
  11. /**
  12.  * @author HarborGao
  13.  * @version 1.0
  14.  * 演示 C3P0的使用
  15.  */
  16. public class C3P0_ {
  17.     //方式一 相关的参数再程序中指定 user,url,password 等
  18.     @Test
  19.     public void useC3P0_01() throws Exception {
  20.         //1. 创建一个数据源对象
  21.         ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
  22.         //2. 通过配置文件 mysql.properties 获取相关连接的信息
  23.         Properties properties = new Properties();
  24.         properties.load(new FileInputStream("src\\mysql.properties"));
  25.         //读取相关属性值
  26.         String url = properties.getProperty("url");
  27.         String user = properties.getProperty("user");
  28.         String password = properties.getProperty("password");
  29.         String driver = properties.getProperty("driver");
  31.         //给数据源 comboPooledDataSource 设置相关的参数
  32.         //注意：连接管理是由 comboPooledDataSource 负责
  33.         comboPooledDataSource.setDriverClass(driver);
  34.         comboPooledDataSource.setJdbcUrl(url);
  35.         comboPooledDataSource.setUser(user);
  36.         comboPooledDataSource.setPassword(password);
  38.         //设置初始化连接数
  39.         comboPooledDataSource.setInitialPoolSize(10);
  40.         //设置最大连接数
  41.         comboPooledDataSource.setMaxPoolSize(50);
  42.         for (int i = 0; i < 5000; i++) {
  43.             Connection connection = comboPooledDataSource.getConnection();
  44.             connection.close();
  45.         }
  46.     }
  48.     //方式二 使用配置文件模板来完成
  49.     //1. 将C3P0 提供的配置文件 复制到src下
  50.     //2. 该文件指定了连接数据库和连接池的相关参数
  51.     @Test
  52.     public void testC3P0_02() throws SQLException {
  53.         ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("my_sql");
  54.         for (int i = 0; i < 5000; i++) {
  55.             Connection connection = comboPooledDataSource.getConnection();
  56.             connection.close();
  57.         }
  58.     }
  59. }

c3p0-config.xml

10.6 Druid（德鲁伊）应用实例

  1. package com.hspedu.jdbc.datasource;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  4. import org.junit.jupiter.api.Test;
  6. import javax.sql.DataSource;
  7. import java.io.FileInputStream;
  8. import java.sql.Connection;
  9. import java.util.Properties;
  11. /**
  12.  * @author HarborGao
  13.  * @version 1.0
  14.  * 演示 Druid 德鲁伊 数据库连接池的使用
  15.  */
  16. public class Druid_ {
  17.     @Test
  18.     public void testDruid() throws Exception {
  19.         //1. 加入 Druid jar包
  20.         //2. 加入配置文件 druid.properties ,将该文件拷贝到项目 src 目录下
  21.         //3. 读取配置文件
  22.         Properties properties = new Properties();
  23.         properties.load(new FileInputStream("src\\druid.properties"));
  24.         //4. 创建一个指定参数的数据库连接池
  25.         DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
  26.         for (int i = 0; i < 5000; i++) {
  27.             Connection connection = dataSource.getConnection();
  28.             connection.close();
  29.         }
  30.     }
  31. }
  1. # druid.properties 配置文件
  2. #key=value
  3. driverClassName=com.mysql.jdbc.Driver
  4. url=jdbc:mysql://localhost:3306/db01?rewriteBatchedStatements=true
  5. #url=jdbc:mysql://localhost:3306/girls
  6. username=root
  7. password=111
  8. #initial connection Size
  9. initialSize=10
  10. #min idle connection size
  11. minIdle=5
  12. #max active connection size
  13. maxActive=50
  14. #max wait time (5000 mil seconds)
  15. maxWait=5000

10.7 将JDBCUtils 工具类改成Druid(德鲁伊)实现

  1. package com.hspedu.jdbc.datasource;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  5. import javax.sql.DataSource;
  6. import java.io.FileInputStream;
  7. import java.sql.Connection;
  8. import java.sql.ResultSet;
  9. import java.sql.SQLException;
  10. import java.sql.Statement;
  11. import java.util.Properties;
  13. /**
  14.  * @author HarborGao
  15.  * @version 1.0
  16.  * 基于Druid数据库连接池的工具类
  17.  */
  18. public class JDBCUtilsByDruid {
  19.     private static DataSource ds;
  21.     //在静态代码块中完成初始化
  22.     static {
  23.         Properties properties = new Properties();
  24.         try {
  25.             properties.load(new FileInputStream("src\\druid.properties"));
  26.             ds = DruidDataSourceFactory.createDataSource(properties);
  27.         } catch (Exception e) {
  28.             throw new RuntimeException(e);
  29.         }
  30.     }
  31.     public static Connection getConnection() {
  32.         try {
  33.             return ds.getConnection();
  34.         } catch (SQLException e) {
  35.             throw new RuntimeException(e);
  36.         }
  37.     }
  39.     public static void close(ResultSet resultSet, Statement statement, Connection connection) {
  40.         try {
  41.             if (resultSet != null) {
  42.                 resultSet.close();
  43.             }
  44.             if (statement != null) {
  45.                 statement.close();
  46.             }
  47.             if (connection != null) {
  48.                 connection.close();
  49.             }
  50.         } catch (SQLException e) {
  51.             throw new RuntimeException(e);
  52.         }
  53.     }
  54. }

十一、Apache - DBUtils

11.1 先分析一个问题

  1. 关闭 connection后，resultSet 结果集无法使用
  2. resultSet 不利于数据的管理
  3. 示意图
    image.png

11.2 用已学知识自己尝试写一个工具类实现

  1. @Test
  2. public void testSelectToArrayList() {
  3.     Connection connection = null;
  4.     String sql = "select * from actor";
  5.     PreparedStatement preparedStatement = null;
  6.     ResultSet resultSet = null;
  7.     ArrayList<Actor> list = new ArrayList<>();
  8.     try {
  9.         connection = JDBCUtilsByDruid.getConnection();
  10.         preparedStatement = connection.prepareStatement(sql);
  12.         resultSet = preparedStatement.executeQuery();
  13.         while (resultSet.next()) {
  14.             int id = resultSet.getInt("id");
  15.             String name = resultSet.getString("name");
  16.             String sex = resultSet.getString("sex");
  17.             Date borndate = resultSet.getDate("borndate");
  18.             String phone = resultSet.getString("phone");
  19.             //把得到的 resultSet 记录，封装到一个Actor对象，再放入到ArrayList
  20.             list.add(new Actor(id,name,sex,borndate,phone));
  21.         }
  22.     } catch (SQLException e) {
  23.         e.printStackTrace();
  24.     } finally {
  25.         JDBCUtilsByDruid.close(resultSet,preparedStatement,connection);
  26.     }
  27.     System.out.println("集合中的数据:" + list);
  28. }
  1. package com.hspedu.jdbc.datasource;
  3. import java.util.Date;
  5. /**
  6.  * @author HarborGao
  7.  * @version 1.0
  8.  */
  9. public class Actor {
  10.     private Integer id;
  11.     private String name;
  12.     private String sex;
  13.     private Date borndate;
  14.     private String phone;
  16.     public Actor() {}  //一定要给一个无参构造器，反射需要
  18.     public Actor(Integer id, String name, String sex, Date borndate, String phone) {
  19.         this.id = id;
  20.         this.name = name;
  21.         this.sex = sex;
  22.         this.borndate = borndate;
  23.         this.phone = phone;
  24.     }
  26.     public Integer getId() {
  27.         return id;
  28.     }
  29.     public void setId(Integer id) {
  30.         this.id = id;
  31.     }
  32.     public String getName() {
  33.         return name;
  34.     }
  35.     public void setName(String name) {
  36.         this.name = name;
  37.     }
  38.     public String getSex() {
  39.         return sex;
  40.     }
  41.     public void setSex(String sex) {
  42.         this.sex = sex;
  43.     }
  44.     public Date getBorndate() {
  45.         return borndate;
  46.     }
  47.     public void setBorndate(Date borndate) {
  48.         this.borndate = borndate;
  49.     }
  50.     public String getPhone() {
  51.         return phone;
  52.     }
  53.     public void setPhone(String phone) {
  54.         this.phone = phone;
  55.     }
  57.     @Override
  58.     public String toString() {
  59.         return "\nActor{" +
  60.                 "id=" + id +
  61.                 ", name='" + name + '\'' +
  62.                 ", sex='" + sex + '\'' +
  63.                 ", borndate=" + borndate +
  64.                 ", phone='" + phone + '\'' +
  65.                 '}';
  66.     }
  67. }

11.3 DBUtils 基本介绍

  1. commons-dbutils 是 Apache组织提供的一个开源 JDBC工具类库，它是对JDBC的封装，使用dbutils 能极大简化 JDBC 编码的工作量
  2. 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

11.4 应用实例

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

  1. package com.hspedu.jdbc.dbutis_;
  3. import com.hspedu.jdbc.datasource.Actor;
  4. import com.hspedu.jdbc.datasource.JDBCUtilsByDruid;
  5. import org.apache.commons.dbutils.QueryRunner;
  6. import org.apache.commons.dbutils.ResultSetHandler;
  7. import org.apache.commons.dbutils.handlers.BeanListHandler;
  8. import org.junit.jupiter.api.Test;
  10. import java.sql.Connection;
  11. import java.sql.SQLException;
  12. import java.util.List;
  14. /**
  15.  * @author HarborGao
  16.  * @version 1.0
  17.  * 使用apache-DBUtils 工具类+druid完成对表的crud
  18.  */
  19. public class DBUtils_USE {
  20.     @Test
  21.     public void testQueryMany() throws SQLException {
  22.         //1. 得到连接
  23.         Connection connection = JDBCUtilsByDruid.getConnection();
  24.         //2. 使用 DBUtils 类和接口，先引入相关的 jar包
  25.         //3. 创建 QueryRunner
  26.         QueryRunner queryRunner = new QueryRunner();
  27.         //4. 就可以执行相关方法，返回ArrayList结果集
  28.         //String sql = "select * from actor where id >= ?";
  29.         String sql = "select id,name from actor where id > ?";
  30.         //说明：
  31.         //(1) query方法 执行一个sql语句，得到resultSet --封装到--> ArrayList集合中
  32.         //(2) 返回集合
  33.         //(3) connection: 连接
  34.         //(4) sql: 执行的sql语句
  35.         //(5) new BeanListHandler<>(Actor.class): 在将resultSet -> Actor 对象 -> 封装到 ArrayList
  36.         //    底层使用反射机制 去获取Actor类的属性，然后进行封装
  37.         //(6) 1: 可变形参，可以有多个，作用是给sql语句中的 ? 赋值
  38.         //(7) 底层得到的resultSet, 会在query 关闭，并关闭 preparedStatement
  39.         List<Actor> list = queryRunner.query(connection, sql, new BeanListHandler<>(Actor.class), 1);
  40.         System.out.println("输出集合的信息");
  41.         for (Actor actor : list) {
  42.             System.out.print(actor);
  43.         }
  45.         JDBCUtilsByDruid.close(null,null,connection);
  46.     }
  47.     @Test
  48.     public void testScaler() throws SQLException {
  49.         Connection connection = JDBCUtilsByDruid.getConnection();
  50.         QueryRunner queryRunner = new QueryRunner();
  51.         String sql = "select name from actor where id = ?";
  52.         //说明：返回单行单列记录 使用的是ScalarHandler()
  53.         Object obj = queryRunner.query(connection, sql, new ScalarHandler(), 2);
  54.         System.out.println(obj);
  55.         JDBCUtilsByDruid.close(null,null,connection);
  56.     }
  58.     //演示 apache-dbutils + druid 完成DML操作 (update,delete,insert)
  59.     @Test
  60.     public void testDML() throws SQLException {
  61.         Connection connection = JDBCUtilsByDruid.getConnection();
  62.         QueryRunner queryRunner = new QueryRunner();
  63.         //这里组织sql语句完成相应的 DML操作
  64.         //String sql = "insert into actor values(null,?,?,?,?)";
  65.         //String sql = "update actor set `name` = ? where id = ?";
  66.         String sql = "delete from actor where id = ?";
  67.         //int rows = queryRunner.update(connection, sql,"张三丰","男","1956-08-19","133");
  68.         //int rows = queryRunner.update(connection, sql,"爱丽丝",3);
  69.         int affectedRow = queryRunner.update(connection, sql,4);
  70.         System.out.println(affectedRow > 0 ? "成功" : "失败");
  72.         JDBCUtilsByDruid.close(null,null,connection);
  74.     }
  75. }

11.5 表和JavaBean 的类型映射关系

image.png

十二、DAO 和增删改查通用方法-BasicDao

12.1 先分析一个问题

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

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

BasicDAO 示意图
img01.jpg

12.2 基本说明

  1. DAO：data access object 数据访问对象
  2. BasicDAO，是专门和数据库交互的，即完成对数据库（表）的CRUD操作
  3. 在BasicDAO的基础上，实现一张表对应一个DAO，更好的完成功能，比如Customer表 - Customer.java类 - CunsomerDAO.java

12.3 应用实例

完成一个简单设计

  1. com.hspedu.dao_.utils 工具类
  2. com.hspedu.dao_.domain javaBean
  3. com.hspedu.dao_.dao 存放XxxDao 和 BasicDao
  4. com.hspedu.dao_.test 写测试类

image.png
JDBCUtilsByDruid.java 【工具类】

  1. package com.hspedu.dao_.utils;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  5. import javax.sql.DataSource;
  6. import java.io.FileInputStream;
  7. import java.sql.Connection;
  8. import java.sql.ResultSet;
  9. import java.sql.SQLException;
  10. import java.sql.Statement;
  11. import java.util.Properties;
  13. /**
  14.  * @author HarborGao
  15.  * @version 1.0
  16.  * 基于Druid数据库连接池的工具类
  17.  */
  18. public class JDBCUtilsByDruid {
  19.     private static DataSource ds;
  21.     //在静态代码块中完成初始化
  22.     static {
  23.         Properties properties = new Properties();
  24.         try {
  25.             properties.load(new FileInputStream("src\\druid.properties"));
  26.             ds = DruidDataSourceFactory.createDataSource(properties);
  27.         } catch (Exception e) {
  28.             throw new RuntimeException(e);
  29.         }
  30.     }
  31.     public static Connection getConnection() {
  32.         try {
  33.             return ds.getConnection();
  34.         } catch (SQLException e) {
  35.             throw new RuntimeException(e);
  36.         }
  37.     }
  39.     public static void close(ResultSet resultSet, Statement statement, Connection connection) {
  40.         try {
  41.             if (resultSet != null) {
  42.                 resultSet.close();
  43.             }
  44.             if (statement != null) {
  45.                 statement.close();
  46.             }
  47.             if (connection != null) {
  48.                 connection.close();
  49.             }
  50.         } catch (SQLException e) {
  51.             throw new RuntimeException(e);
  52.         }
  53.     }
  54. }

Actor.java 【JavaBean】

  1. package com.hspedu.dao_.domain;
  3. import java.util.Date;
  5. /**
  6.  * @author HarborGao
  7.  * @version 1.0
  8.  */
  9. public class Actor {
  10.     private Integer id;
  11.     private String name;
  12.     private String sex;
  13.     private Date borndate;
  14.     private String phone;
  16.     public Actor() {}  //一定要给一个无参构造器，反射需要
  18.     public Actor(Integer id, String name, String sex, Date borndate, String phone) {
  19.         this.id = id;
  20.         this.name = name;
  21.         this.sex = sex;
  22.         this.borndate = borndate;
  23.         this.phone = phone;
  24.     }
  26.     public Integer getId() {
  27.         return id;
  28.     }
  30.     public void setId(Integer id) {
  31.         this.id = id;
  32.     }
  34.     public String getName() {
  35.         return name;
  36.     }
  38.     public void setName(String name) {
  39.         this.name = name;
  40.     }
  42.     public String getSex() {
  43.         return sex;
  44.     }
  46.     public void setSex(String sex) {
  47.         this.sex = sex;
  48.     }
  50.     public Date getBorndate() {
  51.         return borndate;
  52.     }
  54.     public void setBorndate(Date borndate) {
  55.         this.borndate = borndate;
  56.     }
  58.     public String getPhone() {
  59.         return phone;
  60.     }
  62.     public void setPhone(String phone) {
  63.         this.phone = phone;
  64.     }
  66.     @Override
  67.     public String toString() {
  68.         return "\nActor{" +
  69.                 "id=" + id +
  70.                 ", name='" + name + '\'' +
  71.                 ", sex='" + sex + '\'' +
  72.                 ", borndate=" + borndate +
  73.                 ", phone='" + phone + '\'' +
  74.                 '}';
  75.     }
  76. }

BasicDAO.java 【DAO】

  1. package com.hspedu.dao_.dao;
  3. import com.hspedu.dao_.utils.JDBCUtilsByDruid;
  4. import org.apache.commons.dbutils.QueryRunner;
  5. import org.apache.commons.dbutils.handlers.BeanHandler;
  6. import org.apache.commons.dbutils.handlers.BeanListHandler;
  7. import org.apache.commons.dbutils.handlers.ScalarHandler;
  9. import java.sql.Connection;
  10. import java.util.List;
  12. /**
  13.  * @author HarborGao
  14.  * @version 1.0
  15.  * 开发 BasicDAO，是其他DAO的父类
  16.  */
  17. public class BasicDAO<T> {
  18.     private QueryRunner qr = new QueryRunner();
  20.     //开发通用的 DML方法，针对任意表
  21.     public int update(String sql,Object... parameters) {
  22.         Connection connection = null;
  23.         try {
  24.             connection = JDBCUtilsByDruid.getConnection();
  25.             int update = qr.update(connection, sql, parameters);
  26.             return update;
  27.         } catch (Exception e) {
  28.             throw new RuntimeException(e);
  29.         } finally {
  30.             JDBCUtilsByDruid.close(null,null,connection);
  31.         }
  32.     }
  34.     /**
  35.      *
  36.      * @param sql sql语句，可以有 ?
  37.      * @param clazz 传入一个类的Class对象 比如 Actor.class
  38.      * @param parameters 传入 ? 的具体的值，可以是多个
  39.      * @return 根据 Actor.class 返回对应的 ArrayList
  40.      */
  41.     //返回多个对象（即查询的结果是多行），针对任意表
  42.     public List<T> queryMulti(String sql, Class<T> clazz, Object... parameters) {
  43.         Connection connection = null;
  44.         try {
  45.             connection = JDBCUtilsByDruid.getConnection();
  46.             List<T> query = qr.query(connection, sql, new BeanListHandler<T>(clazz), parameters);
  47.             return query;
  48.         } catch (Exception e) {
  49.             throw new RuntimeException(e);
  50.         } finally {
  51.             JDBCUtilsByDruid.close(null,null,connection);
  52.         }
  53.     }
  55.     //查询单行结果的通用方法
  56.     public T querySingle(String sql,Class<T> clazz,Object... parameters) {
  57.         Connection connection = null;
  58.         try {
  59.             connection = JDBCUtilsByDruid.getConnection();
  60.             return qr.query(connection, sql, new BeanHandler<T>(clazz), parameters);
  61.         } catch (Exception e) {
  62.             throw new RuntimeException(e);
  63.         } finally {
  64.             JDBCUtilsByDruid.close(null,null,connection);
  65.         }
  66.     }
  67.     //查询单行单列 即单值的方法
  68.     public Object queryScalar(String sql, Object... parameters) {
  69.         Connection connection = null;
  70.         try {
  71.             connection = JDBCUtilsByDruid.getConnection();
  72.             return qr.query(connection, sql, new ScalarHandler(), parameters);
  73.         } catch (Exception e) {
  74.             throw new RuntimeException(e);
  75.         } finally {
  76.             JDBCUtilsByDruid.close(null,null,connection);
  77.         }
  78.     }
  79. }

ActorDAO.java 【DAO】

  1. package com.hspedu.dao_.dao;
  3. import com.hspedu.dao_.domain.Actor;
  5. /**
  6.  * @author HarborGao
  7.  * @version 1.0
  8.  */
  9. public class ActorDAO extends BasicDAO<Actor>{
  10.     //1. 自动继承BasicDAO的方法
  11.     //2. 根据业务需求，编写特有的方法
  12. }

TestDAO.java 【测试】

  1. package com.hspedu.dao_.test;
  3. import com.hspedu.dao_.dao.ActorDAO;
  4. import com.hspedu.dao_.dao.GoodsDAO;
  5. import com.hspedu.dao_.domain.Actor;
  6. import com.hspedu.dao_.domain.Goods;
  7. import org.junit.jupiter.api.Test;
  9. import java.util.List;
  11. /**
  12.  * @author HarborGao
  13.  * @version 1.0
  14.  */
  15. public class TestDAO {
  16.     //测试 ActorDAO 对 actor 表的 crud 操作
  17.     @Test
  18.     public void testActorDAO() {
  19.         ActorDAO actorDAO = new ActorDAO();
  20.         //1. 查询
  21.         List<Actor> actors = actorDAO.queryMulti("select * from actor where id >= ?", Actor.class, 1);
  22.         System.out.println("===查询多行结果===");
  23.         for (Actor actor : actors) {
  24.             System.out.println(actor);
  25.         }
  26.         //2. 查询单行记录
  27.         Actor actor = actorDAO.querySingle("select * from actor where id = ?", Actor.class, 1);
  28.         System.out.println("===查询单行结果===");
  29.         System.out.println(actor);
  30.         //3. 查询单值
  31.         Object o = actorDAO.queryScalar("select name from actor where id = ?", 1);
  32.         System.out.println("===查询单行单列值===");
  33.         System.out.println(o);
  34.         //4. DML操作
  35.         int update = actorDAO.update("insert into actor values (null,?,?,?,?)", "宋祖儿", "女", "1997-06-19", "120");
  36.         System.out.println(update > 0 ? "成功" : "失败");
  37.     }
  38. }

　

学习参考（致谢）：

  1. B站 @程序员鱼皮 Java学习一条龙
  2. B站 @韩顺平 零基础30天学会Java