【MySQL数据库】JDBC总结

目录

前言 

一、JDBC概述

二、使用示例

三、核心API

1. 注册驱动

2. Connection

3. Statement

4. PreparedStatement

5. ResultSet

四、JDBC扩展

1. ORM封装

2. 主键回显

3. 批量操作

五、连接池

1. 常见连接池

2. Druid连接池使用

3. HikariCP连接池使用 

六、JDBC工具类封装

七、BaseDAO类封装

八、事务

总结 

前言 

  我们在开发Java程序时，数据都是存储在内存中，属于临时存储，当程序停止或重启时，内存中的数据就丢失了！我们为了解决数据的长期存储问题，有如下解决方案：

1. 数据通过I/O流技术，存储在本地磁盘中，解决了持久化问题，但是没有结构和逻辑，不方便管理和维护。
2. 通过关系型数据库，将数据按照特定的格式交由数据库管理系统维护。关系型数据库是通过库和表分隔不同的数据，表中数据存储的方式是行和列，区分相同格式不同值的数据。

  数据存储在数据库，仅仅解决了我们数据存储的问题，但当我们程序运行时，需要读取数据，以及对数据做增删改的操作，那么我们如何通过Java程序对数据库中的数据做增删改查呢？这时候我们可以使用JDBC技术。

一、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工程中引入的相关驱动，如下所示：

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

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

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. 注册驱动

// 注册驱动
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）思想，对象到关系数据库的映射，作用是在编程中，把面向对象的概念跟数据库中表的概念对应起来，以面向对象的角度操作数据库中的数据，即一张表对应一个类，一行数据对应一个对象，一个列对应一个属性！下面是一个示例：

    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对象，此操作为主键回显。下面是指定主键回显并接收主键的一对示例代码：

// 创建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. 批量操作

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

    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文件中引入如下依赖：

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

  下面是一段示例代码： 

    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的其他配置： 

3. HikariCP连接池使用 

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

    <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>

  示例代码如下：

    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的其他配置： 

六、JDBC工具类封装

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

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

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

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

1. ThreadLocal对象.get: 获取ThreadLocal中当前线程共享变量的值。
2. ThreadLocal对象.set: 设置ThreadLocal中当前线程共享变量的值。
3. 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会话管理。

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

/**
 *  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：

/**
 * 将共性的数据库的操作代码封装在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中与事务有关的操作有三个：

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

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

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

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

总结 

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