【MySQL数据库】JDBC总结

JDBC全称Java Database Connectivity，意为Java数据库连接，它是Java提供的一组独立于任何数据库管理系统的API。Java提供接口规范，由各个数据库厂商提供接口的实现，厂商提供的实现类封装成jar文件，也就是我们俗称的数据库驱动jar包。学习JDBC，充分体现了面向接口编程的好处，程序员只关心标准和规范，而无需关注实现过程。JDBC的核心组成如下：

**接口规范：**为了项目代码的可移植性，可维护性，SUN公司从最初就制定了Java程序连接各种数据库的统一接口规范。这样的话，不管是连接哪一种DBMS软件，Java代码可以保持一致性。接口存储在java.sql和javax.sql包下。
**实现规范：**因为各个数据库厂商的DBMS软件各有不同，那么各自的内部如何通过SQL实现增、删、改、查等操作管理数据，只有这个数据库厂商自己更清楚，因此把接口规范的实现交给各个数据库厂商自己实现。厂商将实现内容和过程封装成jar文件，我们程序员只需要将jar文件引入到项目中集成即可，就可以开发调用实现过程操作数据库了。

二、使用示例

这里我是在Maven工程中引入的相关驱动，如下所示：

XML 复制代码

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.33</version>
      <scope>runtime</scope>
    </dependency>

新建一个类，在类中编写如下代码：

java 复制代码

public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        try(
            // 获取连接对象
            Connection connection = DriverManager.getConnection(url, user, password);
            // 执行SQL并获取结果集
            ResultSet resultSet = connection.prepareStatement("SELECT * FROM t_emp").executeQuery();
        ) {
            // 打印结果
            while (resultSet.next()) {
                System.out.print(resultSet.getString(1) + " ");
                System.out.print(resultSet.getString(2) + " ");
                System.out.println(resultSet.getString(3));
            }
        }
    }

这里的url，user和password根据实际情况自行替换，这里我运行的结果如下图所示：

三、核心API

1. 注册驱动

java 复制代码

// 注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");

在 Java 中，当使用 JDBC（Java Database Connectivity）连接数据库时，需要加载数据库特定的驱动程序，以便与数据库进行通信。加载驱动程序的目的是为了注册驱动程序，使得 JDBC API 能够识别并与特定的数据库进行交互。

从JDK6开始，不再需要显式地调用 Class.forName() 来加载 JDBC 驱动程序，只要在类路径中集成了对应的jar文件，会自动在初始化时注册驱动程序。如下图所示，这个文件中指定了驱动程序，因此不需要我们再显示地手动引入。

2. Connection

Connection接口是JDBC API的重要接口，用于建立与数据库的通信通道。换而言之，Connection对象不为空，则代表一次数据库连接。在建立连接时，需要指定数据库URL、用户名、密码参数。

Connection接口还负责管理事务，Connection接口提供了commit和rollback方法，用于提交事务和回滚事务。可以创建Statement对象，用于执行 SQL 语句并与数据库进行交互。在使用JDBC技术时，必须要先获取Connection对象，在使用完毕后，要释放资源，避免资源占用浪费及泄漏。

3. Statement

Statement 接口用于执行 SQL 语句并与数据库进行交互。它是 JDBC API 中的一个重要接口。通过 Statement 对象，可以向数据库发送 SQL 语句并获取执行结果。其结果可以是一个或多个结果：

增删改：受影响行数单个结果。
查询：单行单列、多行多列、单行多列等结果。

但是Statement 接口在执行SQL语句时，会产生SQL注入攻击问题：当使用 Statement 执行动态构建的 SQL 查询时，往往需要将查询条件与 SQL 语句拼接在一起，直接将参数和SQL语句一并生成，让SQL的查询条件始终为true得到结果。

4. PreparedStatement

PreparedStatement是 Statement 接口的子接口，用于执行预编译的 SQL 查询，作用如下：

预编译SQL语句：在创建PreparedStatement时，就会预编译SQL语句，也就是SQL语句已经固定。
防止SQL注入：PreparedStatement 支持参数化查询，将数据作为参数传递到SQL语句中，采用?占位符的方式，将传入的参数用一对单引号包裹起来''，无论传递什么都作为值。有效防止传入关键字或值导致SQL注入问题。
性能提升：PreparedStatement是预编译SQL语句，同一SQL语句多次执行的情况下，可以复用，不必每次重新编译和解析。

**备注：**PreparedSatement会使用?来进行占位，会将用户输入的字符串替换到?当中去，并在前后都添加'，即使用户输入的字符串中会有'，程序也会在其前面添加转义字符\来进行区分，防止SQL注入问题。

5. ResultSet

ResultSet是 JDBC API 中的一个接口，用于表示从数据库中执行查询语句所返回的结果集。它提供了一种用于遍历和访问查询结果的方式。

遍历结果：ResultSet可以使用 next() 方法将游标移动到结果集的下一行，逐行遍历数据库查询的结果，返回值为boolean类型，true代表有下一行结果，false则代表没有。
获取单列结果：可以通过getXxx的方法获取单列的数据，该方法为重载方法，支持索引和列名进行获取。

四、JDBC扩展

1. ORM封装

在使用JDBC操作数据库时，我们会发现数据都是零散的，明明在数据库中是一行完整的数据，到了Java中变成了一个一个的变量，不利于维护和管理。而我们Java是面向对象的，一个表对应的是一个类，一行数据就对应的是Java中的一个对象，一个列对应的是对象的属性，所以我们要把数据存储在一个载体里，这个载体就是实体类！

ORM（Object Relational Mapping）思想，对象到关系数据库的映射，作用是在编程中，把面向对象的概念跟数据库中表的概念对应起来，以面向对象的角度操作数据库中的数据，即一张表对应一个类，一行数据对应一个对象，一个列对应一个属性！下面是一个示例：

java 复制代码

    public static void main(String[] args) throws SQLException {
        try(
            // 获取连接对象
            Connection connection = DriverManager.getConnection(url, user, password);
            // 执行SQL并获取结果集
            ResultSet resultSet = connection.prepareStatement("SELECT * FROM t_emp").executeQuery();
        ) {
            // 处理结果
            Employee employee = new Employee();
            while (resultSet.next()) {
                int empId = resultSet.getInt("emp_id");
                String empName = resultSet.getString("emp_name");
                Double empSalary = Double.valueOf(resultSet.getString("emp_salary"));
                int empAge = resultSet.getInt("emp_age");
                employee.setEmpId(empId);
                employee.setEmpName(empName);
                employee.setEmpSalary(empSalary);
                employee.setEmpAge(empAge);
                System.out.println(employee);
            }
        }
    }

运行结果如下图所示：

2. 主键回显

在数据中，执行新增操作时，主键列为自动增长，可以在表中直观的看到，但是在Java程序中，我们执行完新增后，只能得到受影响行数，无法得知当前新增数据的主键值。在Java程序中获取数据库中插入新数据后的主键值，并赋值给Java对象，此操作为主键回显。下面是指定主键回显并接收主键的一对示例代码：

java 复制代码

// 创建preparedStatement对象，传入需要主键回显参数Statement.RETURN_GENERATED_KEYS
PreparedStatement preparedStatement = connection.prepareStatement("insert into t_emp (emp_name, emp_salary, emp_age)values  (?, ?,?)",Statement.RETURN_GENERATED_KEYS);

// 获取生成的主键列值，返回的是resultSet，在结果集中获取主键列值
ResultSet resultSet = preparedStatement.getGeneratedKeys();

3. 批量操作

插入多条数据时，一条一条发送给数据库执行，效率低下！通过批量操作，可以提升多次操作效率！下面是一个示例：

java 复制代码

    public static void main(String[] args) throws SQLException {
        //1.注册驱动
//        Class.forName("com.mysql.cj.jdbc.Driver");

        //2.获取连接
        Connection connection = DriverManager.getConnection(
            "jdbc:mysql://192.168.11.3:3306/test_database?rewriteBatchedStatements=true",
            "test_user", "123456");

        //3.编写SQL语句
        /*
            注意：1、必须在连接数据库的URL后面追加?rewriteBatchedStatements=true，允许批量操作
                2、新增SQL必须用values。且语句最后不要追加;结束
                3、调用addBatch()方法，将SQL语句进行批量添加操作
                4、统一执行批量操作，调用executeBatch()
         */
        String sql = "insert into t_emp (emp_name,emp_salary,emp_age) values (?,?,?)";

        //4.创建预编译的PreparedStatement，传入SQL语句
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //获取当前行代码执行的时间。毫秒值
        long start = System.currentTimeMillis();
        for(int i = 0;i<10000;i++){
            //5.为占位符赋值
            preparedStatement.setString(1, "marry"+i);
            preparedStatement.setDouble(2, 100.0+i);
            preparedStatement.setInt(3, 20+i);

            preparedStatement.addBatch();
        }

        //执行批量操作
        preparedStatement.executeBatch();

        long end = System.currentTimeMillis();

        System.out.println("消耗时间："+(end - start));

        preparedStatement.close();
        connection.close();
    }

插入一万条数据耗时几百毫秒，运行结果如下：

五、连接池

为什么我们需要连接池？在没有连接池时，我们每次操作数据库都要获取新连接，使用完毕后就close释放，频繁的创建和销毁造成资源浪费。连接的数量无法把控，对服务器来说压力巨大。

什么是连接池？连接池就是数据库连接对象的缓冲区，通过配置，由连接池负责创建连接、管理连接、释放连接等操作。预先创建数据库连接放入连接池，用户在请求时，通过池直接获取连接，使用完毕后，将连接放回池中，避免了频繁的创建和销毁，同时解决了创建的效率。当池中无连接可用，且未达到上限时，连接池会新建连接。池中连接达到上限，用户请求会等待，可以设置超时时间。

1. 常见连接池

JDBC 的数据库连接池使用 javax.sql.DataSource接口进行规范，所有的第三方连接池都实现此接口，自行添加具体实现！也就是说，所有连接池获取连接的和回收连接方法都一样，不同的只有性能和扩展功能。下面我们将简单介绍连接池的部分功能与使用。

DBCP 是Apache提供的数据库连接池，速度相对C3P0较快，但自身存在一些BUG。
C3P0 是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以。
Proxool 是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点
Druid 是阿里提供的数据库连接池，是集DBCP 、C3P0 、Proxool 优点于一身的数据库连接池，性能、扩展性、易用性都更好，功能丰富。
Hikari（ひかり[shi ga li]）取自日语，是光的意思，是SpringBoot2.x之后内置的一款连接池，基于 BoneCP （已经放弃维护，推荐该连接池）做了不少的改进和优化，口号是快速、简单、可靠。

下面是连接池的性能对比：

2. Druid连接池使用

在pom文件中引入如下依赖：

XML 复制代码

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.23</version>
    </dependency>

下面是一段示例代码：

java 复制代码

    public static void main(String[] args) throws SQLException {
        /*
            硬编码：将连接池的配置信息和Java代码耦合在一起。
            1、创建DruidDataSource连接池对象。
            2、设置连接池的配置信息【必须 | 非必须】
            3、通过连接池获取连接对象
            4、回收连接【不是释放连接，而是将连接归还给连接池，给其他线程进行复用】
         */

        //1.创建DruidDataSource连接池对象。
        DruidDataSource druidDataSource = new DruidDataSource();

        //2.设置连接池的配置信息【必须 | 非必须】
        //2.1 必须设置的配置
        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(user);
        druidDataSource.setPassword(password);

        //2.2 非必须设置的配置
        druidDataSource.setInitialSize(10);
        druidDataSource.setMaxActive(20);

        //3.通过连接池获取连接对象
        Connection connection = druidDataSource.getConnection();
        System.out.println(connection);

        //基于connection进行CRUD

        //4.回收连接
        connection.close();
    }

下面列举了一些Druid的其他配置：

配置	缺省	说明
name		配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是："DataSource-" + System.identityHashCode(this)
jdbcUrl		连接数据库的url，不同数据库不一样。例如：mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto
username		连接数据库的用户名
password		连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：https://github.com/alibaba/druid/wiki/使用ConfigFilter
driverClassName		根据url自动识别这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)
initialSize	0	初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
maxActive	8	最大连接池数量
maxIdle	8	已经不再使用，配置了也没效果
minIdle		最小连接池数量
maxWait		获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
poolPreparedStatements	false	是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
maxOpenPreparedStatements	-1	要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
validationQuery		用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
testOnBorrow	true	申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturn	false	归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testWhileIdle	false	建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
timeBetweenEvictionRunsMillis		有两个含义： 1)Destroy线程会检测连接的间隔时间2)testWhileIdle的判断依据，详细看testWhileIdle属性的说明
numTestsPerEvictionRun		不再使用，一个DruidDataSource只支持一个EvictionRun
minEvictableIdleTimeMillis
connectionInitSqls		物理连接初始化的时候执行的sql
exceptionSorter		根据dbType自动识别当数据库抛出一些不可恢复的异常时，抛弃连接
filters		属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
proxyFilters		类型是List，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系

3. HikariCP连接池使用

该连接池需要一款日志输出工具来集成，下面是在pom文件中导入的依赖：

XML 复制代码

    <dependency>
      <groupId>com.zaxxer</groupId>
      <artifactId>HikariCP</artifactId>
      <version>4.0.2</version>
    </dependency>
    <!-- slf4j依赖 -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>2.0.13</version>
    </dependency>
    <!-- logback日志实现  logback-classic已经涵盖logback-core这个依赖了 -->
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.5.6</version>
    </dependency>

示例代码如下：

java 复制代码

    public static void main(String[] args) throws SQLException {
         /*
     硬编码：将连接池的配置信息和Java代码耦合在一起。
     1、创建HikariDataSource连接池对象
     2、设置连接池的配置信息【必须 ｜ 非必须】
     3、通过连接池获取连接对象
     4、回收连接
     */
        //1.创建HikariDataSource连接池对象
        HikariDataSource hikariDataSource = new HikariDataSource();

        //2.设置连接池的配置信息【必须 ｜ 非必须】
        //2.1必须设置的配置
        hikariDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        hikariDataSource.setJdbcUrl(url);
        hikariDataSource.setUsername(user);
        hikariDataSource.setPassword(password);

        //2.2 非必须设置的配置
        hikariDataSource.setMinimumIdle(10);
        hikariDataSource.setMaximumPoolSize(20);

        //3.通过连接池获取连接对象
        Connection connection = hikariDataSource.getConnection();

        System.out.println(connection);

        //回收连接
        connection.close();
    }

下面列举了一些HikariCP的其他配置：

属性	默认值	说明
isAutoCommit	true	自动提交从池中返回的连接
connectionTimeout	30000	等待来自池的连接的最大毫秒数
maxLifetime	1800000	池中连接最长生命周期如果不等于0且小于30秒则会被重置回30分钟
minimumIdle	10	池中维护的最小空闲连接数 minIdle<0或者minIdle>maxPoolSize，则被重置为maxPoolSize
maximumPoolSize	10	池中最大连接数，包括闲置和使用中的连接
metricRegistry	null	连接池的用户定义名称，主要出现在日志记录和JMX管理控制台中以识别池和池配置
healthCheckRegistry	null	报告当前健康信息
poolName	HikariPool-1	连接池的用户定义名称，主要出现在日志记录和JMX管理控制台中以识别池和池配置
idleTimeout		是允许连接在连接池中空闲的最长时间

六、JDBC工具类封装

下面我们将连接池的部分操作封装到一个工具类当中，使整体的代码更加简洁。在这里，我们给这个工具类设立了以下几个功能目标：

创建连接池
获取连接
连接的回收

除了实现上面三点功能外，我们还需要考虑一个问题，就是在同一个用户线程中用户多次从连接池中获取连接，如果不做特殊处理的话，会获取到多个不同的连接，导致连接资源的多次获取与回收，造成资源的浪费，下面是一个连接浪费的示例：

因此，我们还需要保证**同一用户线程多次获取连接时拿到的是同一个连接对象。**为了实现这一需求，我们将引入ThreadLocal类。下面是ThreadLocal类的方法说明：

ThreadLocal对象.get: 获取ThreadLocal中当前线程共享变量的值。
ThreadLocal对象.set: 设置ThreadLocal中当前线程共享变量的值。
ThreadLocal对象.remove: 移除ThreadLocal中当前线程共享变量的值。

JDK 1.2的版本中就提供java.lang.ThreadLocal，为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。通常用来在在多线程中管理共享数据库连接、Session等。

ThreadLocal用于保存某个线程共享变量，原因是在Java中，每一个线程对象中都有一个ThreadLocalMap<ThreadLocal， Object>，其key就是一个ThreadLocal，而Object即为该线程的共享变量。而这个map是通过ThreadLocal的set和get方法操作的。对于同一个static ThreadLocal，不同线程只能从中get，set，remove自己的变量，而不会影响其他线程的变量。下面是ThreadLocal的应用场景：

在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。

线程间数据隔离。

进行事务操作，用于存储线程事务信息。

数据库连接，Session会话管理。

基于以上几点说明，我们可以封装一个如所示的工具类：

java 复制代码

/**
 *  JDBC工具类：
 *      1、维护一个连接池对象、维护了一个线程绑定变量的ThreadLocal对象
 *      2、对外提供在ThreadLocal中获取连接的方法
 *      3、对外提供回收连接的方法，回收过程中，将要回收的连接从ThreadLocal中移除！
 *  注意：工具类仅对外提供共性的功能代码，所以方法均为静态方法！
 *  注意：使用ThreadLocal就是为了一个线程在多次数据库操作过程中，使用的是同一个连接！
 */
public class JDBCUtil {
    
    // 创建连接池引用，因为要提供给当前项目的全局使用，所以创建为静态的。
    private static DataSource dataSource;
    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();

    // 在项目启动时，即创建连接池对象，赋值给dataSource
    static {
        try {
            Properties properties = new Properties();
            InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("db.properties");
            properties.load(inputStream);

            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    // 对外提供在连接池中获取连接的方法
    public static Connection getConnection(){
        try {
            // 在ThreadLocal中获取Connection、
            Connection connection = threadLocal.get();
            // threadLocal里没有存储Connection，也就是第一次获取
            if (connection == null) {
                // 在连接池中获取一个连接，存储在threadLocal里。
                connection = dataSource.getConnection();
                threadLocal.set(connection);
            }
            return connection;

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    // 对外提供回收连接的方法
    public static void release(){
        try {
            Connection connection = threadLocal.get();
            if(connection!=null){
                // 从threadLocal中移除当前已经存储的Connection对象
                threadLocal.remove();
                // 如果开启了事务的手动提交，操作完毕后，归还给连接池之前，要将事务的自动提交改为true
                connection.setAutoCommit(true);
                // 将Connection对象归还给连接池
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

}

上面工具类中的配置文件如下图所示：

七、BaseDAO类封装

DAO：Data Access Object，数据访问对象。Java是面向对象语言，数据在Java中通常以对象的形式存在。一张表对应一个实体类，一张表的操作对应一个DAO对象。在Java操作数据库时，我们会将对同一张表的增删改查操作统一维护起来，维护的这个类就是DAO层。DAO层只关注对数据库的操作，供业务层Service调用，将职责划分清楚。

基本上每一个数据表都应该有一个对应的DAO接口及其实现类，发现对所有表的操作（增、删、改、查）代码重复度很高，所以可以抽取公共代码，给这些DAO的实现类可以抽取一个公共的父类，复用增删改查的基本操作，我们称为BaseDAO。下面是使用了上面提到的JDBCUtil工具类的BaseDAO：

java 复制代码

/**
 * 将共性的数据库的操作代码封装在BaseDAO里。
 */
public class BaseDAO {

    /**
     * 通用的增删改的方法。
     * @param sql 调用者要执行的SQL语句
     * @param params SQL语句中的占位符要赋值的参数
     * @return 受影响的行数
     */
    public int executeUpdate(String sql,Object... params)throws Exception{
        //1.通过JDBCUtil获取数据库连接
        Connection connection = JDBCUtil.getConnection();

        //2.预编译SQL语句
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //4.为占位符赋值，执行SQL，接受返回结果
        if(params!=null && params.length > 0){
            for (int i = 0; i < params.length; i++) {
                //占位符是从1开始的。参数的数组是从0开始的
                preparedStatement.setObject(i+1,params[i] );
            }
        }
        int row = preparedStatement.executeUpdate();

        //5.释放资源
        preparedStatement.close();
        if(connection.getAutoCommit()){
            JDBCUtil.release();
        }

        //6.返回结果
        return row;
    }

    /**
     * 通用的查询：多行多列、单行多列、单行单列
     *      多行多列：List<Employee>
     *      单行多列：Employee
     *      单行单列：封装的是一个结果。Double、Integer、。。。。。
     *  封装过程：
     *      1、返回的类型：泛型：类型不确定，调用者知道，调用时，将此次查询的结果类型告知BaseDAO就可以了。
     *      2、返回的结果：通用，List  可以存储多个结果，也可以存储一个结果 get(0)
     *      3、结果的封装：反射，要求调用者告知BaseDAO要封装对象的类对象。 Class
     */
    public <T> List<T> executeQuery(Class<T> clazz,String sql,Object... params)throws Exception{
        //获取连接
        Connection connection = JDBCUtil.getConnection();

        //预编译SQL语句
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //设置占位符的值
        if(params!=null && params.length > 0){
            for (int i = 0; i < params.length; i++) {
                preparedStatement.setObject(i+1, params[i]);
            }
        }
        //执行SQL，并接受返回的结果集
        ResultSet resultSet = preparedStatement.executeQuery();

        //获取结果集中的元数据对象
        //包含了：列的数量、每个列的名称
        ResultSetMetaData metaData = resultSet.getMetaData();
        int columnCount = metaData.getColumnCount();

        List<T> list = new ArrayList<>();
        //处理结果
        while(resultSet.next()){
            //循环一次，代表有一行数据，通过反射创建一个对象
            T t = clazz.newInstance();
            //循环遍历当前行的列，循环几次，看有多少列
            for (int i = 1; i <=columnCount ;i++){
                //通过下表获取列的值
                Object value = resultSet.getObject(i);

                //获取到的列的value值，这个值就是t这个对象中的某一个属性
                //获取当前拿到的列的名字 = 对象的属性名
                String fieldName = metaData.getColumnLabel(i);
                //通过类对象和fieldName获取要封装的对象的属性
                Field field = clazz.getDeclaredField(fieldName);
                //突破封装的private
                field.setAccessible(true);
                field.set(t,value);
            }
            list.add(t);
        }
        resultSet.close();
        preparedStatement.close();
        if(connection.getAutoCommit()){
            JDBCUtil.release();
        }

        return list;
    }

    /**
     * 通用查询：在上面查询的集合结果中获取第一个结果。 简化了获取单行单列的获取、单行多列的获取
     */
    public <T> T executeQueryBean(Class<T> clazz,String sql,Object... params)throws Exception{
        List<T> list = this.executeQuery(clazz, sql, params);
        if(list ==null || list.isEmpty()){
            return null;
        }
        return list.get(0);
    }

}

八、事务

在JDBC中与事务有关的操作有三个：

java 复制代码

// 开启事务，当前连接的自动提交关闭。改为手动提交！
connection.setAutoCommit(false);

// 没有异常，提交事务！
connection.commit();

// 回滚事务
connection.rollback();

有关事务及MySQL基础的更多介绍，可以参考： 【MySQL数据库】基础总结-CSDN博客

总结

本篇博客介绍了JDBC的相关操作与封装，如果您觉得有用的话，可以点一个关注，让我们一起努力进步吧！！