JDBC

https://github.com/sanshisi/JDBC_Study.git

MySql — 8.0.20

Java — 11.0.11

2021.12.12

  1. =====emp表的结构=====
  2. +---------+-------------+------+-----+---------+----------------+
  3. | Field   | Type        | Null | Key | Default | Extra          |
  4. +---------+-------------+------+-----+---------+----------------+
  5. | id      | int         | NO   | PRI | NULL    | auto_increment |
  6. | name    | varchar(10) | YES  |     | NULL    |                |
  7. | dept_id | int         | YES  |     | NULL    |                |
  8. +---------+-------------+------+-----+---------+----------------+
  10. =====dept表的结构=====
  11. +-------+-------------+------+-----+---------+-------+
  12. | Field | Type        | Null | Key | Default | Extra |
  13. +-------+-------------+------+-----+---------+-------+
  14. | id    | int         | YES  |     | NULL    |       |
  15. | name  | varchar(10) | YES  |     | NULL    |       |
  16. | intro | varchar(10) | YES  |     | NULL    |       |
  17. +-------+-------------+------+-----+---------+-------+

1.JDBC介绍

JDBC(Java DataBase Connectivity)是Java和数据库之间的一个桥梁，是一个规范而不是一个实现，能够执行SQL语句。

JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的 SQL 数据库存取和操作的公共接口（一组 API)，定义了用来访问 数据库的标准Java 类库,(java.sql,javax.sql)使用这个类库可以以一种 标准的方法、方便地访问数据库资源

JDBC 为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题JDBC 的目标是使 Java 程序员使用 JDBC 可以连接任何提供了 JDBC 驱动程 序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过 多的了解，从而大大简化和加快了开发过程

2.链接数据库

先导包

  1. package com.blog;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  7. public class TestConnection {
  8.     public static void main(String[] args) {
  9.         try {
  10.             // 1.加载驱动 [可以不写]
  11.             Class.forName("com.mysql.cj.jdbc.Driver");
  13.             // 2.通过DriverManager类来获取驱动
  14.             // 2.1 提供Properties的对象，指明用户名和密码
  15.             // 因为是本地链接,所以jdbc:mysql://localhost:3306/db_web...可以简写
  16.             DriverManager.getConnection("jdbc:mysql:///db_web?user=root&password=root&serverTimezome=Asia/Shanghai");
  17.             //Properties 该类主要用于读取Java的配置文件
  18. //            Properties info = new Properties();
  19. //            info.setProperty("user", "root");
  20. //            info.setProperty("password", "root");
  21. //            info.setProperty("serverTimezone", "Asia/Shanghai"); // 设置时区
  22. //            DriverManager.getConnection("jdbc:mysql:///db_web", info);
  24.             // 2.2 直接在获取驱动时传入
  25.             Connection connection = DriverManager.getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai",
  26.                     "root", "root");
  28.             System.out.println(connection); // 输出获取的connection
  29.         } catch (ClassNotFoundException e) {
  30.             e.printStackTrace();
  31.         } catch (SQLException throwables) {
  32.             throwables.printStackTrace();
  33.         }
  34.     }
  35. }

通过配置文件链接数据库

  1. @Test
  2. public void testFile() {
  3.     try {
  5.         // 最终解决 硬编码问题
  6.         // Properties 主要用于读取Java配置文件信息
  7.         Properties properties = new Properties();
  8.         properties.load(this.getClass().getClassLoader().getResourceAsStream("jdbc.properties"));
  10.         String classDriver = properties.getProperty("jdbc.classDriver");
  11.         String url = properties.getProperty("jdbc.url");
  12.         String user = properties.getProperty("jdbc.user");
  13.         String password = properties.getProperty("jdbc.password");
  15.         // 加载驱动
  16.         Class.forName(classDriver);
  17.         Connection connection = null;
  18.         // 传入参数
  19.         connection = DriverManager.getConnection(url, user, password);
  20.         System.out.println(connection);
  21.     } catch (IOException e) {
  22.         e.printStackTrace();
  23.     } catch (ClassNotFoundException e) {
  24.         e.printStackTrace();
  25.     } catch (SQLException throwables) {
  26.         throwables.printStackTrace();
  27.     }
  28. }

配置文件声明在工程的 src 目录下：【jdbc.properties】

  1. jdbc.classDriver=com.mysql.cj.jdbc.Driver
  2. jdbc.url=jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai
  3. jdbc.user=root
  4. jdbc.password=root
  1. // JDBC调用存储过程
  2. // CallableStatement 该对象是用来调用数据库的存储过程
  3. CallableStatement prepareCall = connection.prepareCall("call 存储过程名称");

3.PreparedStatement 实现 CRUD 操作

CRUD：增加(Create)、检索(Retrieve)、更新(Update)和删除(Delete)

🍕Statement：用于执行静态 SQL 语句并返回它所生成结果的对象

🍕PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句

🍕CallableStatement：用于执行 SQL 存储过程

3.1 Statement操作数据表

在 Java 早期使用的是Statement 接口来操作 SQL，但是因为这用字符串拼接 SQL 的方式完成 SQL 语句的，容易引发 SQL 注入漏洞问题，所以现在几乎都不再是用来，取而代之的则是使用 PreparedStatement 接口

通过调用Connection对象的 createStatement()方法创建该对象。该对象用于执行静态的 SQL 语句，并且返回执行结果

  1. execute(sql)           执行SQL，返回值是个boolean值，表示是否成功，主要用来执行 create drop等等语句（主要用于初始化）
  2. executeBatch()                    用于执行批量SQL
  3. statement.executeQuery(sql)    用于查询语句（DQL）
  4. statement.executeUpdate(sql)   主要用于DML语句 返回的是

Statement做 插入和查询

  1. package com.blog;
  3. import com.study001.Emp;
  4. import org.junit.Test;
  6. import java.sql.*;
  7. import java.util.ArrayList;
  8. import java.util.List;
  10. public class TestStatement {
  11.     @Test
  12.     public void InnerTest() {
  13.         try {
  14.             // 1.加载驱动
  15.             Class.forName("com.mysql.cj.jdbc.Driver");
  16.             // 2.通过DriverManager类获取数据库链接
  17.             Connection connection = DriverManager.getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai",
  18.                     "root", "root");
  19.             // 3.获取Statement对象
  20.             Statement statement = connection.createStatement();
  22.             String sql = "insert emp(id,name,dept_id) values(10,'小鱼二',3)";
  23.             int count = statement.executeUpdate(sql);
  24.             System.out.println(sql);
  25.             if (count > 0) {
  26.                 System.out.println("count=" + count + ",插入成功");
  27.             } else {
  28.                 System.out.println("count=" + count + ",插入失败");
  29.             }
  31.         } catch (ClassNotFoundException e) {
  32.             e.printStackTrace();
  33.         } catch (SQLException throwables) {
  34.             throwables.printStackTrace();
  35.         }
  36.     }
  38.     @Test
  39.     public void QueryAllTest() {
  40.         Connection connection = null; // 获取数据库链接
  41.         Statement statement = null; // 获取Statement对象进行CRUD操作
  42.         ResultSet resultSet = null; // 接受 statement.executeQuery(sql) 查询对象
  44.         List<com.study001.Emp> emps = new ArrayList<>();
  45.         Emp emp = null;
  46.         try {
  47.             // 1.加载驱动
  48.             Class.forName("com.mysql.cj.jdbc.Driver");
  49.             // 2.通过DriverManager类获取数据库链接
  50.             connection = DriverManager.getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai",
  51.                     "root", "root");
  52.             // 3.获取Statement对象
  53.             statement = connection.createStatement();
  55.             String sql = "select id,name,dept_id from emp"; // 在真正开发时不能使用 select *
  56.             resultSet = statement.executeQuery(sql);
  57.             // 因为可能存在多条数据，所以使用循环不断的取值，直到没有值为止
  58.             while (resultSet.next()) {
  59.                 // 进入循环，意味着开始读取一行数据2211
  60.                 // sql中的顺序都是从1开始的
  61. //                int id = resultSet.getInt(1);
  62. //                String name = resultSet.getString(2);
  63. //                int deptId = resultSet.getInt(3);
  64.                 int id = resultSet.getInt("id");
  65.                 String name = resultSet.getString("name");
  66.                 int deptId = resultSet.getInt("dept_Id");
  67. //                System.out.println("id=" + id + ", name=" + name + ", dept_id=" + deptId); 
  68.                 emp = new Emp(id,name,deptId);
  69.                 emps.add(emp);
  70.             }
  71.         } catch (ClassNotFoundException e) {
  72.             e.printStackTrace();
  73.         } catch (SQLException throwables) {
  74.             throwables.printStackTrace();
  75.         } finally {
  76.             // 释放资源
  77.             this.closeResource(connection, statement, resultSet);
  78.         }
  79.         // 使用方法引用对emps进行遍历
  80.         emps.forEach(System.out::println);
  81.     }
  83.     // 做一个公共的关闭资源的工具
  84.     public static void closeResource(Connection connection, Statement statement, ResultSet resultSet) {
  85.         if (resultSet != null) {
  86.             try {
  87.                 resultSet.close();
  88.             } catch (SQLException e) {
  89.                 e.printStackTrace();
  90.             }
  91.         }
  92.         if (statement != null) {
  93.             try {
  94.                 statement.close();
  95.             } catch (SQLException e) {
  96.                 e.printStackTrace();
  97.             }
  98.         }
  99.         if (connection != null) {
  100.             try {
  101.                 connection.close();
  102.             } catch (SQLException e) {
  103.                 e.printStackTrace();
  104.             }
  105.         }
  106.     }
  107. }

✨emp.java

  1. package com.blog;
  3. public class Emp {
  4.     private Integer id;
  5.     private String name;
  6.     private Integer deptId;
  8.     public Emp(Integer id, String name, Integer dept_id) {
  9.         this.id = id;
  10.         this.name = name;
  11.         this.deptId = dept_id;
  12.     }
  14.     @Override
  15.     public String toString() {
  16.         return "Emp{" +
  17.                 "id=" + id +
  18.                 ", name='" + name + '\'' +
  19.                 ", dept_id=" + deptId +
  20.                 '}';
  21.     }
  22. }

释放资源

释放 ResultSet, Statement,Connection

数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果 Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放

可以在 finally中关闭，保证及时其他代码出现异常，资源也一定能被关闭

SQL 注入

SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令(如：SELECT user, password FROM user_table WHEREuser='a' OR 1 = ' AND password = ' b'1' ='1') ，从而利用系统的 SQL 引擎完成恶意行为的做法。对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从 Statement 扩展而来) 取代 Statement 就可以了

3.2 PreparedStatement操作数据表

可 以 通 过 调 用 Connection 对 象 的 preparedStatement(String sql) 方 法 获 取PreparedStatement对象

PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句PreparedStatement 对象所 代 表 的 SQL 语 句 中 的 参 数 用 问 号 (?) 来 表 示 ， 调 用PreparedStatement对象的setXxx()方法来设置这些参数.

setXxx()方法有两个参数，第一个参数是要设置的 SQL语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

PrepareStatement 做 插入

其它操作会在工具类中统一给出

  1. @Test
  2. public void testPs() {
  3.     Connection connection = null;
  4.     PreparedStatement ps = null;
  5.     ResultSet rs = null;
  6.     Scanner sc = new Scanner(System.in);
  7.     try {
  8.         connection = DriverManager
  9.             .getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai",
  10.                            "root", "root");
  11.         System.out.print("请输入用户名:");
  12.         String name = sc.nextLine().trim(); // 去除空格
  13.         System.out.print("请输入密码:");
  14.         String password = sc.nextLine().trim(); // 去除空格
  16.         String sql = "select * from t_user where name = ? and password = ?";
  17.         System.out.println(sql);
  18.         ps = connection.prepareStatement(sql);
  20.         ps.setString(1,name);
  21.         ps.setString(2,password);
  23.         rs = ps.executeQuery();
  24.         if (rs.next()) {
  25.             System.out.println("登录成功");
  26.         } else {
  27.             System.out.println("登录失败");
  28.         }
  29.     } catch (SQLException throwables) {
  30.         throwables.printStackTrace();
  31.     } finally {
  32.         sc.close();
  33.         closeResource(connection, ps, rs);
  34.     }
  35. }

3.3 ResultSet 与 ResultSetMetaData

3.3.1 ResultSet

查询需要调用PreparedStatement 的 executeQuery()方法，查询结果是一个ResultSet对象

ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现’

ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。

ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator 对象的 hasNext()和 next()方法 的 结 合 体 。 当 指 针 指 向 一 行 时 , 可 以 通 过 调 用 getXxx(int index)或 getXxx(intcolumnName) 获取每一列的值。

例如: getInt(1), getString("name")

注意：Java 与数据库交互涉及到的相关 Java API 中的索引都从 1 开始。

✨ResultSet 接口的常用方法：

  1. boolean next()
  3. getString()

3.3.2 ResultSetMetaData

可用于获取关于 ResultSet 对象中列的类型和属性信息的对象

ResultSetMetaData meta = rs.getMetaData();

✨常用方法：

  1. ====✨
  2. getColumnName(int column)  :获取指定列的名称
  4. getColumnLabel(int column)  :获取指定列的别名
  6. getColumnCount()  :返回当前 ResultSet 对象中的列数
  7. ====✨
  9. getColumnTypeName(int column):检索指定列的数据库特定的类型名称
  11. getColumnDisplaySize(int column):指示指定列的最大标准宽度，以字符为单位
  13. isNullable(int column):指示指定列中的值是否可以为 null
  15. isAutoIncrement(int column):指示是否自动为指定列进行编号，这样这些列仍然是只读的
  1. @Test
  2. void testResultSetMetaData() {
  3.     Connection connection = null;
  4.     PreparedStatement ps = null;
  5.     try {
  6.         connection = DriverManager
  7.             .getConnection("jdbc:mysql:///db_web?serverTimezone=Asia/Shanghai", 
  8.                            "root", "root");
  9.         // 获取PrepareStatement对象
  10.         ps = connection.prepareStatement("select id, name userName, age, intros from t_user");
  12.         // 获取ResultSetMetaData对象
  13.         ResultSetMetaData metaData = ps.getMetaData();
  15.         System.out.println("查询的字段的数量:"+ metaData.getColumnCount());
  16.         System.out.println("查询的结果的列的名称:"+ metaData.getColumnName(2));
  17.         System.out.println("查询的结果的字段的名称(别名):"+ metaData.getColumnLabel(2));
  19.     } catch (SQLException e) {
  20.         e.printStackTrace();
  21.     } finally {
  22.         TestConnection.closeResource(connection, ps, null);
  23.     }
  24. }

4.JDBC通用工具类的实现

一般在开发中，我们会封装数据，实现一些好用的工具类

PropertieUtil.java

通过传入配置文件的名称获取 Properties 对象

  1. package com.util;
  3. import java.io.IOException;
  4. import java.util.Properties;
  6. public class PropertieUtil {
  7.     private static Properties properties;
  9.     public static Properties getProperties(String name) {
  10.         if (properties == null) {
  11.             properties = new Properties();
  12.         }
  13.         try {
  14.             // 获取配置文件 properties
  15.             properties.load(PropertieUtil.class.getClassLoader().getResourceAsStream(name));
  16.         } catch (IOException e) {
  17.             e.printStackTrace();
  18.         }
  19.         return properties;
  20.     }
  21. }

DbUtil.java

进一步获取 Connection 对象

  1. package com.util;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  6. import java.util.Properties;
  8. public class DbUtil {
  9.     public static Connection getConnectionByJdbc() {
  10.         Properties prop = PropertieUtil.getProperties("jdbc.properties"); // 通过配置文件获取 properties
  11.         String CalssDrive = prop.getProperty("jdbc.classDriver");
  12.         String url = prop.getProperty("jdbc.url");
  13.         String user = prop.getProperty("jdbc.user");
  14.         String password = prop.getProperty("jdbc.password");
  16.         // 加载驱动
  17.         try {
  18.             Class.forName(CalssDrive);
  19.             Connection conn = DriverManager.getConnection(url,user,password);
  20.             return conn;
  21.         } catch (ClassNotFoundException e) {
  22.             e.printStackTrace();
  23.         } catch (SQLException throwables) {
  24.             throwables.printStackTrace();
  25.         }
  26.         return null;
  27.     }
  28. }

DBHepler.java

执行 DML 操作

  1. package com.util;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.InvocationTargetException;
  5. import java.sql.*;
  6. import java.util.ArrayList;
  7. import java.util.List;
  10. public class DBHepler {
  11.     /**
  12.      * 功能:更新工具方法DML语句 (增删改查操作)
  13.      *
  14.      * @param sql  DML SQL
  15.      * @param args 问号的参数
  16.      * @return 影响的行数
  17.      */
  18.     public static int update(String sql, Object... args) {
  19.         Connection connection = null;
  20.         PreparedStatement ps = null;
  21.         try {
  22.             connection = DbUtil.getConnectionByJdbc();
  23.             ps = connection.prepareStatement(sql);
  24.             for (int i = 0; i < args.length; i++) {
  25.                 ps.setObject(i + 1, args[i]);
  26.             }
  27.             int count = ps.executeUpdate();
  28.             return count;
  29.         } catch (SQLException throwables) {
  30.             throwables.printStackTrace();
  31.         } finally {
  32.             closeResource(connection, ps, null);
  33.         }
  34.         return 0;
  35.     }
  37.     /***
  38.      * 封装查询所有对象的结果集,返回的泛型对象的List
  39.      *
  40.      * @param <T>  对象类型
  41.      * @param clzz 对象的字节码文件
  42.      * @param sql  查询SQL
  43.      * @param args 问号的参数
  44.      * @return 泛型对象的List, 表示符合条件的所有数据库记录(对象)
  45.      */
  46.     public static <T> T queryOne(Class<T> clzz, String sql, Object... args) {
  47.         Connection connection = null;
  48.         PreparedStatement ps = null;
  49.         ResultSet rs = null;
  50.         T t = null;
  51.         connection = DbUtil.getConnectionByJdbc();
  52.         try {
  53.             ps = connection.prepareStatement(sql);
  54.             // 为?赋值
  55.             for (int i = 0; i < args.length; i++) {
  56.                 ps.setObject(i + 1, args[i]);
  57.             }
  58.             rs = ps.executeQuery();
  59.             ResultSetMetaData metaData = ps.getMetaData();
  60.             if (rs.next()) {
  61.                 // 通过反射获取对象
  62.                 t = clzz.getConstructor().newInstance();
  63.                 int columCount = metaData.getColumnCount();
  64.                 for (int i = 1; i <= columCount; i++) {
  65.                     // 通过下标获取列的别名
  66.                     // 此处应当注意 获取的是别名 而别名应当是 Emp类 中的属性
  67.                     String columnLabel = metaData.getColumnLabel(i);
  68.                     Object columValue = rs.getObject(columnLabel);
  70.                     // 通过反射获取属性
  71.                     Field field = clzz.getDeclaredField(columnLabel);
  72.                     field.setAccessible(true); // 解除属性私有性的影响
  73.                     field.set(t, columValue);
  74.                 }
  75.             }
  76.         } catch (SQLException throwables) {
  77.             throwables.printStackTrace();
  78.         } catch (InvocationTargetException e) {
  79.             e.printStackTrace();
  80.         } catch (InstantiationException e) {
  81.             e.printStackTrace();
  82.         } catch (IllegalAccessException e) {
  83.             e.printStackTrace();
  84.         } catch (NoSuchMethodException e) {
  85.             e.printStackTrace();
  86.         } catch (NoSuchFieldException e) {
  87.             e.printStackTrace();
  88.         }
  89.         return t;
  90.     }
  92.     /***
  93.      * 封装查询所有对象的结果集,返回的泛型对象的List
  94.      *
  95.      * @param <T>  对象类型
  96.      * @param clzz 对象的字节码文件
  97.      * @param sql  查询SQL
  98.      * @param args 问号的参数
  99.      * @return 泛型对象的List, 表示符合条件的所有数据库记录(对象)
  100.      */
  101.     public static <T> List<T> queryAll(Class<T> clzz, String sql, Object... args) {
  102.         Connection connection = null;
  103.         PreparedStatement ps = null;
  104.         ResultSet rs = null;
  105.         List<T> list = new ArrayList<>();
  106.         T t = null;
  107.         try {
  108.             connection = DbUtil.getConnectionByJdbc();
  109.             ps = connection.prepareStatement(sql);
  111.             for (int i = 0; i < args.length; i++) {
  112.                 ps.setObject(i + 1, args[i]);
  113.             }
  115.             rs = ps.executeQuery();
  116.             ResultSetMetaData metaData = ps.getMetaData();
  118.             while (rs.next()) {
  119.                 t = clzz.getConstructor().newInstance();
  120.                 int columnCount = metaData.getColumnCount();
  121.                 for (int i = 1; i <= columnCount; i++) {
  122.                     String columnLabel = metaData.getColumnLabel(i);
  123.                     Object columnValue = rs.getObject(columnLabel);
  124.                     Field field = clzz.getDeclaredField(columnLabel);
  125.                     field.setAccessible(true);
  126.                     field.set(t, columnValue);
  127.                 }
  128.                 list.add(t);
  129.             }
  130.         } catch (SQLException e) {
  131.             e.printStackTrace();
  132.         } catch (NoSuchFieldException e) {
  133.             e.printStackTrace();
  134.         } catch (SecurityException e) {
  135.             e.printStackTrace();
  136.         } catch (IllegalArgumentException e) {
  137.             e.printStackTrace();
  138.         } catch (IllegalAccessException e) {
  139.             e.printStackTrace();
  140.         } catch (InstantiationException e) {
  141.             e.printStackTrace();
  142.         } catch (InvocationTargetException e) {
  143.             e.printStackTrace();
  144.         } catch (NoSuchMethodException e) {
  145.             e.printStackTrace();
  146.         } finally {
  147.             closeResource(connection, ps, rs);
  148.         }
  149.         return list;
  150.     }
  152.     // 公共的关闭资源的工具
  153.     private static void closeResource(Connection connection, PreparedStatement ps, ResultSet resultSet) {
  154.         if (resultSet != null) {
  155.             try {
  156.                 resultSet.close();
  157.             } catch (SQLException throwables) {
  158.                 throwables.printStackTrace();
  159.             }
  160.         }
  162.         if (connection != null) {
  163.             try {
  164.                 connection.close();
  165.             } catch (SQLException throwables) {
  166.                 throwables.printStackTrace();
  167.             }
  168.         }
  169.         if (ps != null) {
  170.             try {
  171.                 ps.close();
  172.             } catch (SQLException throwables) {
  173.                 throwables.printStackTrace();
  174.             }
  175.         }
  176.     }
  177. }

TestUtil.java

  1. package com.util;
  3. import com.study001.Emp;
  4. import org.junit.Test;
  6. import java.util.List;
  8. public class TestUtil {
  9.     @Test
  10.     public void test00() {
  11.         String sql = "insert emp(id,name,dept_id) values(?,?,?)";
  12.         int count = DBHepler.update(sql, 21, "小小鱼", 3);
  13.         if (count>0) {
  14.             System.out.println("插入成功");
  15.         } else {
  16.             System.out.println("插入失败");
  17.         }
  18.     }
  20.     @Test
  21.     public void test01() {
  22.         String sql = "select id,name,dept_id deptId from emp";
  23.         Emp emp = DBHepler.queryOne(Emp.class, sql);
  24.         System.out.println(emp);
  25.     }
  27.     @Test
  28.     public void test02() {
  29.         String sql = "select id,name,dept_id deptId from emp";
  30.         List<Emp> emps = DBHepler.queryAll(Emp.class, sql);
  31.         emps.forEach(System.out::println);
  32.     }
  33. }

工具类小结

✨解释一下关于别名的问题

  1. ……
  2. rs = ps.executeQuery();// 获取了 ResultSet 对象
  3. ResultSetMetaData metaData = ps.getMetaData();// 获取了 ResultSetMetaData 对象
  4. if (rs.next()) {
  5.     // 通过反射获取对象
  6.     // getConstructor() 获取构造方法  newInstance() 实例化改对象[该类必须已经加载过]
  7.     t = clzz.getConstructor().newInstance(); // 最终获得的是 Emp 对象
  8.     int columCount = metaData.getColumnCount(); // 获取列数
  9.     for (int i = 1; i <= columCount; i++) {
  10.         // 通过下标获取列的别名
  11.         // 此处是为了保证后面通过反射获取属性能获取成功,即保证 获取到的别名和Emp对象中对应的属性名相同
  12.         String columnLabel = metaData.getColumnLabel(i);
  13.         Object columValue = rs.getObject(columnLabel); // 通过别名获取对应的值 [通过下标也可以]
  14.         //                    Object columValue = rs.getObject(i);
  16.         // 通过反射获取属性
  17.         // 如果传入的别名与Emp中对应的属性名不同,该处就会获取不到属性
  18.         Field field = clzz.getDeclaredField(columnLabel);
  19.         field.setAccessible(true); // 解除属性私有性的影响
  20.         field.set(t, columValue); // 将对应的值传入Emp对象中
  21.     }
  22. }
  23. ……

5.JDBC API小结

两种思想：

  • 面向接口编程的思想
  • ORM 思想(object relational mapping)

ORM思想:

这就是为什么要查询语句中字段对应的别名要与其对应的对象的属性一样

一个数据表对应一个 java 类

表中的一条记录对应 java 类的一个对象

表中的一个字段对应 java 类的一个属性

注意:sql 是需要结合列名和表的属性名来写。注意起别名。

两种技术

JDBC 结果集的元数据：ResultSetMetaData

DatabaseMetaData 类中提供了许多方法用于获得数据源的各种信息，通过这些方法可以非常详细的了解数据库的信息

获取列数：getColumnCount()

获取列的别名：getColumnLabel()

通过反射，创建指定类的对象，获取指定的属性并赋值

6.DAO

DAO：Data Access Object 访问数据信息的类和接口，包括了对数据的 CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。作用：为了实现功能的模块化，更有利于代码的维护和升级。

首先看一下项目结构

  1. 📒dao
  2.     📒impl
  3.         [接口实现类]
  4.         BaseDaoImpl.java
  5.         DeptDaoImpl.java
  6.         EmpDaoImpl.java
  7.     [接口]
  8.     BaseDao.java
  9.     DeptDao.java
  10.     EmpDao.java
  11. 📒daoTest
  12.     dao测试类
  13. 📒entity
  14.     [实体类]
  15.     Dept.java
  16.     Emp.java

JDBC - 图1

1.📒entity

📒entity
[实体类]
Dept.java
Emp.java

JDBC - 图2

2.📒dao

📒dao
📒impl
[接口实现类]
BaseDaoImpl.java
DeptDaoImpl.java
EmpDaoImpl.java
[接口]
BaseDao.java
DeptDao.java
EmpDao.java

2.1接口

JDBC - 图3

BaseDao.java

  1. package com.dao;
  3. import java.util.List;
  5. public interface BaseDao<T> {
  6.     /**
  7.      * 增删改操作
  8.      * @param sql
  9.      * @param args
  10.      * @return
  11.      */
  12.     int update(String sql, Object... args);
  14.     /**
  15.      * 封装查询一个对象
  16.      *
  17.      * @param sql  查询SQL
  18.      * @param args 问号的参数
  19.      * @return 一个clzz对应的对象T
  20.      */
  21.     T queryOne(String sql, Object... args);
  23.     /***
  24.      *     封装查询所有对象的结果集,返回的泛型对象的List
  25.      * @param sql 查询SQL
  26.      * @param args 问号的参数
  27.      * @return 泛型对象的List, 表示符合条件的所有数据库记录(对象)
  28.      */
  29.     List<T> queryAll(String sql, Object... args);
  31. }

2.2接口实现类

2.2.1 BaseDaoImpl.java
  1. package com.dao.Impl;
  3. import com.dao.BaseDao;
  4. import com.study002.DbUtil;
  6. import java.lang.reflect.Field;
  7. import java.lang.reflect.InvocationTargetException;
  8. import java.lang.reflect.ParameterizedType;
  9. import java.lang.reflect.Type;
  10. import java.sql.*;
  11. import java.util.ArrayList;
  12. import java.util.List;
  14. @SuppressWarnings("unchecked")
  15. public class BaseDaoImpl<T> implements BaseDao<T> {
  17.     // 定义一个变量来接收泛型的类型
  18.     private Class<T> clzz;
  20.     {
  21.         //获取当前BaseDAO的子类继承的父类中的泛型
  22.         Type genericSuperclass = this.getClass().getGenericSuperclass();
  23.         ParameterizedType paramType = (ParameterizedType) genericSuperclass;
  24.         //获取了父类的泛型参数
  25.         Type[] typeArguments = paramType.getActualTypeArguments();
  26.         //泛型的第一个参数
  27.         clzz = (Class<T>) typeArguments[0];
  28.     }
  30.     @Override
  31.     public int update(String sql, Object... args) {
  32.         Connection connection = null;
  33.         PreparedStatement ps = null;
  34.         try {
  35.             connection = DbUtil.getConnectionByJdbc();
  36.             ps = connection.prepareStatement(sql);
  37.             for (int i = 0; i < args.length; i++) {
  38.                 ps.setObject(i + 1, args[i]);
  39.             }
  40.             int count = ps.executeUpdate();
  41.             return count;
  42.         } catch (SQLException e) {
  43.             e.printStackTrace();
  44.         } finally {
  45.             closeResource(connection, ps, null);
  46.         }
  47.         return 0;
  48.     }
  50.     @Override
  51.     /**
  52.      *     封装查询一个对象
  53.      * @param <T> 对象类型
  54.      * @param clzz 对象的字节码文件
  55.      * @param sql 查询SQL
  56.      * @param args 问号的参数
  57.      * @return 一个clzz对应的对象T
  58.      */
  59.     public T queryOne(String sql, Object...args) {
  60.         Connection connection = null;
  61.         PreparedStatement ps = null;
  62.         ResultSet rs = null;
  63.         T t = null;
  64.         try {
  65.             connection = DbUtil.getConnectionByJdbc();
  66.             ps = connection.prepareStatement(sql);
  67.             // 为?赋值
  68.             for (int i = 0; i < args.length; i++) {
  69.                 ps.setObject(i + 1, args[i]);
  70.             }
  71.             rs = ps.executeQuery();
  72.             ResultSetMetaData metaData = ps.getMetaData();
  73.             if (rs.next()) {
  74.                 // 通过反射获取对象
  75.                 t = (T) clzz.getConstructor().newInstance();
  76.                 int columnCount = metaData.getColumnCount();
  77.                 for (int i = 1; i <= columnCount; i++) {
  78.                     // 通过下标获取列的名称
  79.                     // String colunmName = metaData.getColumnName(i);
  80.                     // 通4RFC 4RC过下标获取列的别名(就是对象的属性的名称)
  81.                     String columnLabel = metaData.getColumnLabel(i);
  82.                     Object columnValue = rs.getObject(columnLabel);
  84.                     // 通过反射获取属性
  85.                     Field field = clzz.getDeclaredField(columnLabel);
  86.                     field.setAccessible(true);
  87.                     field.set(t, columnValue);
  88.                 }
  89.             }
  91.         } catch (SQLException e) {
  92.             e.printStackTrace();
  93.         } catch (NoSuchFieldException e) {
  94.             e.printStackTrace();
  95.         } catch (SecurityException e) {
  96.             e.printStackTrace();
  97.         } catch (IllegalArgumentException e) {
  98.             e.printStackTrace();
  99.         } catch (IllegalAccessException e) {
  100.             e.printStackTrace();
  101.         } catch (InstantiationException e) {
  102.             e.printStackTrace();
  103.         } catch (InvocationTargetException e) {
  104.             e.printStackTrace();
  105.         } catch (NoSuchMethodException e) {
  106.             e.printStackTrace();
  107.         } finally {
  108.             closeResource(connection, ps, rs);
  109.         }
  110.         return t;
  111.     }
  113.     @Override
  114.     /***
  115.      *     封装查询所有对象的结果集,返回的泛型对象的List
  116.      * @param <T> 对象类型
  117.      * @param clzz 对象的字节码文件
  118.      * @param sql 查询SQL
  119.      * @param args 问号的参数
  120.      * @return 泛型对象的List,表示符合条件的所有数据库记录(对象)
  121.      */
  122.     public List<T> queryAll(String sql, Object...args) {
  123.         Connection connection = null;
  124.         PreparedStatement ps = null;
  125.         ResultSet rs = null;
  126.         List<T> list = new ArrayList<>();
  127.         T t = null;
  128.         try {
  129.             connection = DbUtil.getConnectionByJdbc();
  130.             ps = connection.prepareStatement(sql);
  132.             for (int i = 0; i < args.length; i++) {
  133.                 ps.setObject(i + 1, args[i]);
  134.             }
  136.             rs = ps.executeQuery();
  137.             ResultSetMetaData metaData = ps.getMetaData();
  139.             while (rs.next()) {
  140.                 t = clzz.getConstructor().newInstance();
  141.                 int columnCount = metaData.getColumnCount();
  142.                 for (int i = 1; i <= columnCount; i++) {
  143.                     // 通过下标获取列的名称
  144.                     // String colunmName = metaData.getColumnName(i);
  145.                     // 通过下标获取列的别名(就是对象的属性的名称)
  146.                     String columnLabel = metaData.getColumnLabel(i);
  147.                     Object columnValue = rs.getObject(columnLabel);
  148.                     Field field = clzz.getDeclaredField(columnLabel);
  150.                     // 通过反射获取属性
  151.                     field.setAccessible(true);
  152.                     field.set(t, columnValue);
  153.                 }
  154.                 list.add(t);
  155.             }
  156.         } catch (SQLException e) {
  157.             e.printStackTrace();
  158.         } catch (NoSuchFieldException e) {
  159.             e.printStackTrace();
  160.         } catch (SecurityException e) {
  161.             e.printStackTrace();
  162.         } catch (IllegalArgumentException e) {
  163.             e.printStackTrace();
  164.         } catch (IllegalAccessException e) {
  165.             e.printStackTrace();
  166.         } catch (InstantiationException e) {
  167.             e.printStackTrace();
  168.         } catch (InvocationTargetException e) {
  169.             e.printStackTrace();
  170.         } catch (NoSuchMethodException e) {
  171.             e.printStackTrace();
  172.         } finally {
  173.             closeResource(connection, ps, rs);
  174.         }
  175.         return list;
  176.     }
  178.     // 做一个公共的关闭资源的工具
  179.     public void closeResource(Connection connection, PreparedStatement ps, ResultSet resultSet) {
  180.         if (resultSet != null) {
  181.             try {
  182.                 resultSet.close();
  183.             } catch (SQLException e) {
  184.                 e.printStackTrace();
  185.             }
  186.         }
  187.         if (ps != null) {
  188.             try {
  189.                 ps.close();
  190.             } catch (SQLException e) {
  191.                 e.printStackTrace();
  192.             }
  193.         }
  194.         if (connection != null) {
  195.             try {
  196.                 connection.close();
  197.             } catch (SQLException e) {
  198.                 e.printStackTrace();
  199.             }
  200.         }
  201.     }
  202. }

2.2.2 DeptDaoImpl.java
  1. package com.dao.Impl;
  3. import com.dao.DeptDao;
  4. import com.entity.Dept;
  6. import java.util.List;
  8. public class DeptDaoImpl extends BaseDaoImpl<Dept> implements DeptDao {
  9.     @Override
  10.     public void update(Dept dept) {
  11.         super.update("update dept set name=?,intro=? where id = ? ",dept.getName(),dept.getName(),dept.getInfo());
  12.     }
  14.     @Override
  15.     public void delete(int id) {
  16.         super.update("delete from dept where id = ? ",id);
  17.     }
  19.     @Override
  20.     public void delete(Dept dept) {
  21.         // 必须要所有属性全对上才能删除
  22.         super.update("delete from dept  where  id = ? and name = ? and intro = ?",dept.getId(),dept.getName(),dept.getInfo());
  23.     }
  25.     @Override
  26.     public void add(Dept dept) {
  27.         super.update("insert into dept(id,name,intro) values(?,?,?)",dept.getId(),dept.getName(),dept.getInfo());
  28.     }
  30.     @Override
  31.     public Dept findById(int id) {
  32.         Dept dept = super.queryOne("select id,name,intro from dept where id = ?", id);
  33.         return dept;
  34.     }
  36.     @Override
  37.     public List<Dept> findAll() {
  38.         List<Dept> depts = super.queryAll("select id,name,intro from dept ");
  39.         return depts;
  40.     }
  41. }

2.2.3 EmpDaoImpl.java
  1. package com.dao.Impl;
  3. import com.dao.EmpDao;
  4. import com.entity.Emp;
  6. import java.util.List;
  8. public class EmpDaoImpl extends BaseDaoImpl<Emp> implements EmpDao {
  9.     @Override
  10.     public void update(Emp emp) {
  11.         super.update("update emp set name=?,dept_id=? where id = ? ",emp.getName(),emp.getDeptId(),emp.getId());
  12.     }
  14.     @Override
  15.     public void delete(int id) {
  16.         super.update("delete from emp  where id = ? ",id);
  17.     }
  19.     @Override
  20.     public void delete(Emp emp) {
  21.         // 必须要所有属性全对上才能删除
  22.         super.update("delete from emp  where  id = ? and name = ? and dept_id = ?",emp.getId(),emp.getName(),emp.getDeptId());
  23.     }
  25.     @Override
  26.     public void add(Emp emp) {
  27.         super.update("insert into emp(id,name,dept_id) values(?,?,?)",emp.getId(),emp.getName(),emp.getDeptId());
  28.     }
  30.     @Override
  31.     public Emp findById(int id) {
  32.         Emp emp = super.queryOne("select id,name,dept_id deptId from emp where id = ?", id);
  33.         return emp;
  34.     }
  36.     @Override
  37.     public List<Emp> findAll() {
  38. //        List<Emp> emps = super.queryAll("select id,name,dept_id from emp");
  39.         List<Emp> emps = super.queryAll("select id,name,dept_id deptId from emp where dept_id = ?",2);
  40.         return emps;
  41.     }
  42. }

2.2测试类

  1. package com.daoTest;
  3. import com.dao.Impl.EmpDaoImpl;
  4. import com.entity.Emp;
  5. import org.junit.Test;
  7. import java.util.List;
  9. public class DaoTest {
  10.     @Test
  11.     public void test01() {
  12.         // 测试插入
  13.         Emp e1 = new Emp(8, "小周", 3);
  14. //        Emp e2 = new Emp(9, "小黄", 4);
  16.         EmpDaoImpl daoEmp = new EmpDaoImpl();
  17.         daoEmp.add(e1);
  18. //        daoEmp.add(e2);
  19.     }
  21.     @Test
  22.     public void test02() {
  23.         // 测试更新
  24. //        Emp e = new Emp(8, "小周", 3);
  25.         Emp e = new Emp(8, "小周来啦", 2);
  27.         EmpDaoImpl daoEmp = new EmpDaoImpl();
  28.         daoEmp.update(e);
  29.     }
  31.     @Test
  32.     public void test03() {
  33.         // 测试删除
  34.         Emp e = new Emp(8, "小周", 3);
  36.         EmpDaoImpl daoEmp = new EmpDaoImpl();
  37.         daoEmp.delete(e);
  38. //        daoEmp.delete(1);
  39.     }
  41.     @Test
  42.     public void test04() {
  43.         // 测试查询
  44.         Emp e = new Emp(8, "小周", 3);
  47.         EmpDaoImpl daoEmp = new EmpDaoImpl();
  48. //        Emp byId = daoEmp.findById(e.getId());
  49. //        System.out.println(byId);
  51.         List<Emp> emps = daoEmp.findAll();
  52.         emps.forEach(System.out::println);
  53.     }
  55.     public static void main(String[] args) {
  56.         // 测试查询
  57.         Emp e = new Emp(8, "小周", 3);
  60.         EmpDaoImpl daoEmp = new EmpDaoImpl();
  61. //        Emp byId = daoEmp.findById(e.getId());
  62. //        System.out.println(byId);
  64.         List<Emp> emps = daoEmp.findAll();
  65.         emps.forEach(System.out::println);
  66.     }
  67. }

[

](https://github.com/sanshisi/JDBC_Study.git)