Java 数据持久化系列之JDBC

时间 2019-11-26

标签 java 数据持久系列 jdbc 栏目 Java 繁體版

原文原文链接

前段时间小冰在工做中遇到了一系列关于数据持久化的问题，在排查问题时发现本身对 Java 后端的数据持久化框架的原理都不太了解，只有不断试错，所以走了不少弯路。因而下定决心，集中精力学习了持久化相关框架的原理和实现，总结出这个系列。java

上图是我根据相关源码和网上资料总结的有关 Java 数据持久化的架构图(只表明本人想法，若有问题，欢迎留言指出)。最下层就是今天要讲的 JDBC，上一层是数据库链接池层，包括 HikariCP 和 Druid等；再上一层是分库分表中间件，好比说 ShardingJDBC；再向上是对象关系映射层，也就是 ORM，包括 Mybatis 和 JPA；最上边是 Spring 的事务管理。mysql

本系列的文章会依次讲解图中各个开源框架的基础使用，而后描述其原理和代码实现，最后会着重分析它们之间是如何相互集成和配合的。sql

废话很少说，咱们先来看 JDBC。数据库

JDBC 定义

JDBC是Java Database Connectivity的简称，它定义了一套访问数据库的规范和接口。但它自身不参与数据库访问的实现。所以对于目前存在的数据库（譬如Mysql、Oracle）来讲，要么数据库制造商自己提供这些规范与接口的实现，要么社区提供这些实现。后端

如上图所示，Java 程序只依赖于 JDBC API，经过 DriverManager 来获取驱动，而且针对不一样的数据库可使用不一样的驱动。这是典型的桥接的设计模式，把抽象 Abstraction 与行为实现Implementation 分离开来，从而能够保持各部分的独立性以及应对他们的功能扩展。设计模式

JDBC 基础代码示例

单纯使用 JDBC 的代码逻辑十分简单，咱们就以最为经常使用的MySQL 为例，展现一下使用 JDBC 来创建数据库链接、执行查询语句和遍历结果的过程。网络

public static void connectionTest(){

    Connection connection = null;
    Statement statement = null;
    ResultSet resultSet = null;

    try {
        // 1. 加载并注册 MySQL 的驱动
        Class.forName("com.mysql.cj.jdbc.Driver").newInstance();

        // 2. 根据特定的数据库链接URL，返回与此URL的所匹配的数据库驱动对象
        Driver driver = DriverManager.getDriver(URL);
        // 3. 传入参数，好比说用户名和密码
        Properties props = new Properties();
        props.put("user", USER_NAME);
        props.put("password", PASSWORD);

        // 4. 使用数据库驱动建立数据库链接 Connection
        connection = driver.connect(URL, props);

        // 5. 从数据库链接 connection 中得到 Statement 对象
        statement = connection.createStatement();
        // 6. 执行 sql 语句，返回结果
        resultSet = statement.executeQuery("select * from activity");
        // 7. 处理结果，取出数据
        while(resultSet.next())
        {
            System.out.println(resultSet.getString(2));
        }

        .....
    }finally{
        // 8.关闭连接，释放资源  按照JDBC的规范，使用完成后管理连接，
        // 释放资源，释放顺序应该是： ResultSet ->Statement ->Connection
        resultSet.close();
        statement.close();
        connection.close();
    }
}

代码中有详细的注释描述每一步的过程，相信你们也都对这段代码十分熟悉。架构

惟一要提醒的是使用完以后的资源释放顺序。按照 JDBC 规范，应该依次释放 ResultSet，Statement 和 Connection。固然这只是规范，不少开源框架都没有严格的执行，可是 HikariCP却严格准守了，它能够带来不少优点，这些会在以后的文章中讲解。框架

上图是 JDBC 中核心的 5 个类或者接口的关系，它们分别是 DriverManager、Driver、Connection、Statement 和 ResultSet。函数

DriverManager 负责管理数据库驱动程序，根据 URL 获取与之匹配的 Driver 具体实现。Driver 则负责处理与具体数据库的通讯细节，根据 URL 建立数据库链接 Connection。

Connection 表示与数据库的一个链接会话，能够和数据库进行数据交互。Statement 是须要执行的 SQL 语句或者存储过程语句对应的实体，能够执行对应的 SQL 语句。ResultSet 则是 Statement 执行后得到的结果集对象，可使用迭代器从中遍历数据。

不一样数据库的驱动都会实现各自的 Driver、Connection、Statement 和 ResultSet。而更为重要的是，众多数据库链接池和分库分表框架也都是实现了本身的 Connection、Statement 和 ResultSet，好比说 HikariCP、Druid 和 ShardingJDBC。咱们接下来会常常看到它们的身影。

接下来，咱们依次看一下这几个类及其涉及的操做的原理和源码实现。

载入 Driver 实现

能够直接使用 Class#forName的方式来载入驱动实现，或者在 JDBC 4.0 后则基于 SPI 机制来导入驱动实现，经过在 META-INF/services/java.sql.Driver 文件中指定实现类的方式来导入驱动实现，下面咱们就来看一下两种方式的实现原理。

Class#forName 做用是要求 JVM 查找并加载指定的类，若是在类中有静态初始化器的话，JVM 会执行该类的静态代码段。加载具体 Driver 实现时，就会执行 Driver 中的静态代码段，将该 Driver 实现注册到 DriverManager 中。咱们来看一下 MySQL 对应 Driver 的具体代码。它就是直接调用了 DriverManager的 registerDriver 方法将本身注册到其维护的驱动列表中。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        // 直接调用 DriverManager的 registerDriver 将本身注册到其中
        DriverManager.registerDriver(new Driver());
    }
}

SPI 机制使用 ServiceLoader 类来提供服务发现机制，动态地为某个接口寻找服务实现。当服务的提供者提供了服务接口的一种实现以后，必须根据 SPI 约定在 META-INF/services 目录下建立一个以服务接口命名的文件，在该文件中写入实现该服务接口的具体实现类。当服务调用 ServiceLoader 的 load 方法的时候，ServiceLoader 可以经过约定的目录找到指定的文件，并装载实例化，完成服务的发现。

DriverManager 中的 loadInitialDrivers 方法会使用 ServiceLoader 的 load 方法加载目前项目路径下的全部 Driver 实现。

public class DriverManager {
    // 程序中已经注册的Driver具体实现信息列表。registerDriver类就是将Driver加入到这个列表
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    // 使用ServiceLoader 加载具体的jdbc driver实现
    static {
        loadInitialDrivers();
    }
    private static void loadInitialDrivers() {
        // 省略了异常处理
        // 得到系统属性 jdbc.drivers 配置的值
        String drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
            public String run() {
                return System.getProperty("jdbc.drivers");
            }
        });

        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {

                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                // 经过 ServiceLoader 获取到Driver的具体实现类，而后加载这些类，会调用其静态代码块
                while(driversIterator.hasNext()) {
                    driversIterator.next();
                }
                return null;
            }
        });

        String[] driversList = drivers.split(":");
        // for 循环加载系统属性中的Driver类。
        for (String aDriver : driversList) {
            println("DriverManager.Initialize: loading " + aDriver);
            Class.forName(aDriver, true,
                    ClassLoader.getSystemClassLoader());
        }
    }
}

好比说，项目引用了 MySQL 的 jar包 mysql-connector-java，在这个 jar 包的 META-INF/services 文件夹下有一个叫 java.sql.Driver 的文件，文件的内容为 com.mysql.cj.jdbc.Driver。而 ServiceLoader 的 load 方法找到这个文件夹下的文件，读取文件的内容，而后加载出文件内容所指定的 Driver 实现。而正如以前所分析的，这个 Driver 类被加载时，会调用 DriverManager 的 registerDriver 方法，从而完成了驱动的加载。

Connection、Statement 和 ResultSet

当程序加载完具体驱动实现后，接下来就是创建与数据库的链接，执行 SQL 语句而且处理返回结果了，其过程以下图所示。

创建 Connection

建立 Connection 链接对象，可使用 Driver 的 connect 方法，也可使用 DriverManager 提供的 getConnection 方法，此方法经过 url 自动匹配对应的驱动 Driver 实例，而后仍是调用对应的 connect 方法返回 Connection 对象实例。

创建 Connection 会涉及到与数据库进行网络请求等大量费时的操做，为了提高性能，每每都会引入数据库链接池，也就是说复用 Connection，免去每次都建立 Connection 所消耗的时间和系统资源。

Connection 默认状况下，对于建立的 Statement 执行的 SQL 语句都是自动提交事务的，即在 Statement 语句执行完后，自动执行 commit 操做，将事务提交，结果影响到物理数据库。为了知足更好地事务控制需求，咱们也能够手动地控制事务，手动地在Statement 的 SQL 语句执行后进行 commit 或者rollback。

connection = driver.connect(URL, props);
// 将自动提交关闭
connection.setAutoCommit(false);

statement = connection.createStatement();
statement.execute("INSERT INTO activity (activity_id, activity_name, product_id, start_time, end_time, total, status, sec_speed, buy_limit, buy_rate) VALUES (1, '香蕉大甩卖', 1, 530871061, 530872061, 20, 0, 1, 1, 0.20);");
// 执行后手动 commit
statement.getConnection().commit();

Statement

Statement 的功能在于根据传入的 SQL 语句，将传入 SQL 通过整理组合成数据库可以识别的执行语句(对于静态的 SQL 语句，不须要整理组合；而对于预编译SQL 语句和批量语句，则须要整理)，而后传递 SQL 请求，以后会获得返回的结果。对于查询 SQL，结果会以 ResultSet 的形式返回。

当你建立了一个 Statement 对象以后，你能够用它的三个执行方法的任一方法来执行 SQL 语句。

boolean execute(String SQL) : 若是 ResultSet 对象能够被检索，则返回的布尔值为 true ，不然返回 false 。当你须要使用真正的动态 SQL 时，可使用这个方法来执行 SQL DDL 语句。
int executeUpdate(String SQL) : 返回执行 SQL 语句影响的行的数目。使用该方法来执行 SQL 语句，是但愿获得一些受影响的行的数目，例如，INSERT，UPDATE 或 DELETE 语句。
ResultSet executeQuery(String SQL) : 返回一个 ResultSet 对象。当你但愿获得一个结果集时使用该方法，就像你使用一个 SELECT 语句。

对于不一样类型的 SQL 语句，Statement 有不一样的接口与其对应。

接口 | 介绍
-|-| Statement | 适合运行静态 SQL 语句，不接受动态参数 PreparedStatement | 计划屡次使用而且预先编译的 SQL 语句，接口须要传入额外的参数 CallableStatement | 用于访问数据库存储过程

Statement 主要用于执行静态SQL语句，即内容固定不变的SQL语句。Statement每执行一次都要对传入的SQL语句编译一次，效率较差。而 PreparedStatement则解决了这个问题，它会对 SQL 进行预编译，提升了执行效率。

PreparedStatement pstmt = null;
    try {
        String SQL = "Update activity SET activity_name = ? WHERE activity_id = ?";
        pstmt = connection.prepareStatement(SQL);
        pstmt.setString(1, "测试");
        pstmt.setInt(2, 1);
        pstmt.executeUpdate();
    }
    catch (SQLException e) {
    }
    finally {
        pstmt.close();
    }
}

除此以外， PreparedStatement 还能够预防 SQL 注入，由于 PreparedStatement 不容许在插入参数时改变 SQL 语句的逻辑结构。

PreparedStatement 传入任何数据不会和原 SQL 语句发生匹配关系，无需对输入的数据作过滤。若是用户将”or 1 = 1”传入赋值给占位符，下述SQL 语句将没法执行：select * from t where username = ? and password = ?。

ResultSet

当 Statement 查询 SQL 执行后，会获得 ResultSet 对象，ResultSet 对象是 SQL语句查询的结果集合。ResultSet 对从数据库返回的结果进行了封装，使用迭代器的模式能够逐条取出结果集中的记录。

while(resultSet.next()) {
    System.out.println(resultSet.getString(2));
}

ResultSet 通常也建议使用完毕直接 close 掉，可是须要注意的是关闭 ResultSet 对象不关闭其持有的 Blob、Clob 或 NClob 对象。 Blob、Clob 或 NClob 对象在它们被建立的的事务期间会一直持有效，除非其 free 函数被调用。

我的博客，欢迎来玩

参考

https://blog.csdn.net/wl044090432/article/details/60768342
https://blog.csdn.net/luanlouis/article/details/29850811