jdbc-mysql测试例子和源码详解

简介

什么是JDBC

JDBC是一套连接和操作数据库的标准、规范。通过提供DriverManager、Connection、Statement、ResultSet等接口将开发人员与数据库提供商隔离，开发人员只需要面对JDBC接口，无需关心怎么跟数据库交互。

几个重要的类

类名	作用
DriverManager	驱动管理器，用于注册驱动，是获取 Connection对象的入口
Driver	数据库驱动，用于获取Connection对象
Connection	数据库连接，用于获取Statement对象、管理事务
Statement	sql执行器，用于执行sql
ResultSet	结果集，用于封装和操作查询结果
prepareCall	用于调用存储过程

使用中的注意事项

1. 记得释放资源。另外，ResultSet和Statement的关闭都不会导致Connection的关闭。
2. maven要引入oracle的驱动包，要把jar包安装在本地仓库或私服才行。
3. 使用PreparedStatement而不是Statement。可以避免SQL注入，并且利用预编译的特点可以提高效率。

使用例子

需求

使用JDBC对mysql数据库的用户表进行增删改查。

工程环境

JDK：1.8

maven：3.6.1

IDE：sts4

mysql driver：8.0.15

mysql：5.7

主要步骤

一个完整的JDBC保存操作主要包括以下步骤：

1. 注册驱动（JDK6后会自动注册，可忽略该步骤）;
2. 通过DriverManager获得Connection对象;
3. 开启事务;
4. 通过Connection获得PreparedStatement对象;
5. 设置PreparedStatement的参数;
6. 执行保存操作;
7. 保存成功提交事务，保存失败回滚事务;
8. 释放资源，包括Connection、PreparedStatement。

创建表

CREATE TABLE `demo_user` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `name` varchar(16) COLLATE utf8_unicode_ci NOT NULL COMMENT '用户名',
  `age` int(3) unsigned DEFAULT NULL COMMENT '用户年龄',
  `gmt_create` datetime DEFAULT NULL COMMENT '记录创建时间',
  `gmt_modified` datetime DEFAULT NULL COMMENT '记录最近修改时间',
  `deleted` bit(1) DEFAULT b'0' COMMENT '是否删除',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_name` (`name`),
  KEY `index_age` (`age`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci

创建项目

项目类型Maven Project，打包方式jar

引入依赖

<!-- junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!-- mysql驱动的jar包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>
<!-- oracle驱动的jar包 -->
<!-- <dependency>
    <groupId>com.oracle</groupId>
    <artifactId>ojdbc6</artifactId>
    <version>11.2.0.2.0</version>
</dependency> -->

注意：由于oracle商业版权问题，maven并不提供Oracle JDBC driver，需要将驱动包手动添加到本地仓库或私服。

编写jdbc.prperties

下面的url拼接了好几个参数，主要为了避免乱码和时区报错的异常。

路径：resources目录下

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/github_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=true
#这里指定了字符编码和解码格式，时区，是否加密传输
username=root
password=root
#注意，xml配置是&采用&替代

如果是oracle数据库，配置如下：

driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@//localhost:1521/xe
username=system
password=root

获得Connection对象

    private static Connection createConnection() throws Exception {
        // 导入配置文件
        Properties pro = new Properties();
        InputStream in = JDBCUtil.class.getClassLoader().getResourceAsStream( "jdbc.properties" );
        Connection conn = null;
        pro.load( in );
        // 获取配置文件的信息
        String driver = pro.getProperty( "driver" );
        String url = pro.getProperty( "url" );
        String username = pro.getProperty( "username" );
        String password = pro.getProperty( "password" );
        // 注册驱动,JDK6后不需要再手动注册，DirverManager的静态代码块会帮我们注册
        // Class.forName(driver);
        // 获得连接
        conn = DriverManager.getConnection( url, username, password );
        return conn;
    }

使用Connection对象完成保存操作

这里简单地模拟实际业务层调用持久层，并开启事务。另外，获取连接、释放资源可以通过自定义的工具类 JDBCUtil 来实现，具体见源码。

    @Test
    public void save() throws Exception {
        UserDao userDao = new UserDaoImpl();
        // 创建用户
        User user = new User("zzf002", 18, new Date(), new Date());
        try (Connection connection = JDBCUtil.getConnection()) {
            // 开启事务
            connection.setAutoCommit(false);
            // 保存用户
            userDao.insert(user);
            // 提交事务
            connection.commit();
        }
    }

接下来看看具体的保存操作，即DAO层方法。

    public void insert(User user) throws Exception {
        String sql = "insert into demo_user (name,age,gmt_create,gmt_modified) values(?,?,?,?)";
        Connection connection = JDBCUtil.getConnection();
        // 获取PreparedStatement对象
        PreparedStatement prepareStatement = connection.prepareStatement(sql);
        // 设置参数
        prepareStatement.setString(1, user.getName());
        prepareStatement.setInt(2, user.getAge());
        prepareStatement.setDate(3, new java.sql.Date(user.getGmt_create().getTime()));
        prepareStatement.setDate(4, new java.sql.Date(user.getGmt_modified().getTime()));
        // 执行保存
        prepareStatement.executeUpdate();
        // 释放资源
        JDBCUtil.release(prepareStatement, null, null);
    }

源码分析

驱动注册

DriverManager.registerDriver

DriverManager主要用于管理数据库驱动，并为我们提供了获取连接对象的接口。其中，它有一个重要的成员属性registeredDrivers，是一个CopyOnWriteArrayList集合（通过ReentrantLock实现线程安全），存放的是元素是DriverInfo对象。

    //存放数据库驱动包装类的集合（线程安全）
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    public static synchronized void registerDriver(java.sql.Driver driver)
        throws SQLException {
        //调用重载方法，传入的DriverAction对象为null
        registerDriver(driver, null);
    }
    public static synchronized void registerDriver(java.sql.Driver driver,
            DriverAction da)
        throws SQLException {
        if(driver != null) {
            //当列表中没有这个DriverInfo对象时，加入列表。
            //注意，这里判断对象是否已经存在，最终比较的是driver地址是否相等。
            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
        } else {
            throw new NullPointerException();
        }

        println("registerDriver: " + driver);

    }

为什么集合存放的是Driver的包装类DriverInfo对象，而不是Driver对象呢？

1. 通过DriverInfo的源码可知，当我们调用equals方法比较两个DriverInfo对象是否相等时，实际上比较的是Driver对象的地址，也就是说，我可以在DriverManager中注册多个MYSQL驱动。而如果直接存放的是Driver对象，就不能达到这种效果（因为没有遇到需要注册多个同类驱动的场景，所以我暂时理解不了这样做的好处）。

2. DriverInfo中还包含了另一个成员属性DriverAction，当我们注销驱动时，必须调用它的deregister方法后才能将驱动从注册列表中移除，该方法决定注销驱动时应该如何处理活动连接等（其实一般在构造DriverInfo进行注册时，传入的DriverAction对象为空，根本不会去使用到这个对象，除非一开始注册就传入非空DriverAction对象）。

综上，集合中元素不是Driver对象而DriverInfo对象，主要考虑的是扩展某些功能，虽然这些功能几乎不会用到。

注意：考虑篇幅，以下代码经过修改，仅保留所需部分。

class DriverInfo {

    final Driver driver;
    DriverAction da;
    DriverInfo(Driver driver, DriverAction action) {
        this.driver = driver;
        da = action;
    }

    @Override
    public boolean equals(Object other) {
        //这里对比的是地址
        return (other instanceof DriverInfo)
                && this.driver == ((DriverInfo) other).driver;
    }

}

为什么Class.forName(com.mysql.cj.jdbc.Driver) 可以注册驱动？

当加载com.mysql.cj.jdbc.Driver这个类时，静态代码块中会执行注册驱动的方法。

    static {
        try {
            //静态代码块中注册当前驱动
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }

为什么JDK6后不需要Class.forName也能注册驱动？

因为从JDK6开始，DriverManager增加了以下静态代码块，当类被加载时会执行static代码块的loadInitialDrivers方法。

而这个方法会通过查询系统参数（jdbc.drivers）和SPI机制两种方式去加载数据库驱动。

注意：考虑篇幅，以下代码经过修改，仅保留所需部分。

    static {
        loadInitialDrivers();
    }
    //这个方法通过两个渠道加载所有数据库驱动：
    //1. 查询系统参数jdbc.drivers获得数据驱动类名
    //2. SPI机制
    private static void loadInitialDrivers() {
        //通过系统参数jdbc.drivers读取数据库驱动的全路径名。该参数可以通过启动参数来设置，其实引入SPI机制后这一步好像没什么意义了。
        String drivers;
        try {
            drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
                public String run() {
                    return System.getProperty("jdbc.drivers");
                }
            });
        } catch (Exception ex) {
            drivers = null;
        }
        //使用SPI机制加载驱动
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                //读取META-INF/services/java.sql.Driver文件的类全路径名。
                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                //加载并初始化类
                try{
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                // Do nothing
                }
                return null;
            }
        });

        if (drivers == null || drivers.equals("")) {
            return;
        }
        //加载jdbc.drivers参数配置的实现类
        String[] driversList = drivers.split(":");
        for (String aDriver : driversList) {
            try {
                Class.forName(aDriver, true,
                        ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
                println("DriverManager.Initialize: load failed: " + ex);
            }
        }
    }

补充：SPI机制本质上提供了一种服务发现机制，通过配置文件的方式，实现服务的自动装载，有利于解耦和面向接口编程。具体实现过程为：在项目的META-INF/services文件夹下放入以接口全路径名命名的文件，并在文件中加入实现类的全限定名，接着就可以通过ServiceLoder动态地加载实现类。

打开mysql的驱动包就可以看到一个java.sql.Driver文件，里面就是mysql驱动的全路径名。

获得连接对象

DriverManager.getConnection

获取连接对象的入口是DriverManager.getConnection，调用时需要传入url、username和password。

获取连接对象需要调用java.sql.Driver实现类（即数据库驱动）的方法，而具体调用哪个实现类呢？

正如前面讲到的，注册的数据库驱动被存放在registeredDrivers中，所以只有从这个集合中获取就可以了。

注意：考虑篇幅，以下代码经过修改，仅保留所需部分。

    public static Connection getConnection(String url, String user, String password) throws SQLException {
        java.util.Properties info = new java.util.Properties();

        if (user != null) {
            info.put("user", user);
        }
        if (password != null) {
            info.put("password", password);
        }
        //传入url、包含username和password的信息类、当前调用类
        return (getConnection(url, info, Reflection.getCallerClass()));
    }
    private static Connection getConnection(String url, java.util.Properties info, Class<?> caller) throws SQLException {
        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
        //遍历所有注册的数据库驱动
        for(DriverInfo aDriver : registeredDrivers) {
            //先检查这当前类加载器是否有权限加载这个驱动，如果是才进入
            if(isDriverAllowed(aDriver.driver, callerCL)) {
                //这一步是关键，会去调用Driver的connect方法
                Connection con = aDriver.driver.connect(url, info);
                if (con != null) {
                    return con;
                }
            } else {
                println("    skipping: " + aDriver.getClass().getName());
            }
        }
    }

com.mysql.cj.jdbc.Driver.connection

由于使用的是mysql的数据驱动，这里实际调用的是com.mysql.cj.jdbc.Driver的方法。

从以下代码可以看出，mysql支持支持多节点部署的策略，本文仅对单机版进行扩展。

注意：考虑篇幅，以下代码经过修改，仅保留所需部分。

    //mysql支持多节点部署的策略，根据架构不同，url格式也有所区别。
    private static final String REPLICATION_URL_PREFIX = "jdbc:mysql:replication://";
    private static final String URL_PREFIX = "jdbc:mysql://";
    private static final String MXJ_URL_PREFIX = "jdbc:mysql:mxj://";
    public static final String LOADBALANCE_URL_PREFIX = "jdbc:mysql:loadbalance://";
    public java.sql.Connection connect(String url, Properties info) throws SQLException {
        //根据url的类型来返回不同的连接对象，这里仅考虑单机版
        ConnectionUrl conStr = ConnectionUrl.getConnectionUrlInstance(url, info);
        switch (conStr.getType()) {
            case SINGLE_CONNECTION:
                //调用ConnectionImpl.getInstance获取连接对象
                return com.mysql.cj.jdbc.ConnectionImpl.getInstance(conStr.getMainHost());

            case LOADBALANCE_CONNECTION:
                return LoadBalancedConnectionProxy.createProxyInstance((LoadbalanceConnectionUrl) conStr);

            case FAILOVER_CONNECTION:
                return FailoverConnectionProxy.createProxyInstance(conStr);

            case REPLICATION_CONNECTION:
                return ReplicationConnectionProxy.createProxyInstance((ReplicationConnectionUrl) conStr);

            default:
                return null;
        }
    }

ConnectionImpl.getInstance

这个类有个比较重要的字段session，可以把它看成一个会话，和我们平时浏览器访问服务器的会话差不多，后续我们进行数据库操作就是基于这个会话来实现的。

注意：考虑篇幅，以下代码经过修改，仅保留所需部分。

    private NativeSession session = null;
    public static JdbcConnection getInstance(HostInfo hostInfo) throws SQLException {
        //调用构造
        return new ConnectionImpl(hostInfo);
    }
    public ConnectionImpl(HostInfo hostInfo) throws SQLException {
        //先根据hostInfo初始化成员属性，包括数据库主机名、端口、用户名、密码、数据库及其他参数设置等等，这里省略不放入。
        //最主要看下这句代码
        createNewIO(false);
    }
    public void createNewIO(boolean isForReconnect) {
        if (!this.autoReconnect.getValue()) {
            //这里只看不重试的方法
            connectOneTryOnly(isForReconnect);
            return;
        }

        connectWithRetries(isForReconnect);
    }
    private void connectOneTryOnly(boolean isForReconnect) throws SQLException {

        JdbcConnection c = getProxy();
        //调用NativeSession对象的connect方法建立和数据库的连接
        this.session.connect(this.origHostInfo, this.user, this.password, this.database, DriverManager.getLoginTimeout() * 1000, c);
        return;
    }

NativeSession.connect

接下来的代码主要是建立会话的过程，首先时建立物理连接，然后根据协议建立会话。

注意：考虑篇幅，以下代码经过修改，仅保留所需部分。

    public void connect(HostInfo hi, String user, String password, String database, int loginTimeout, TransactionEventHandler transactionManager)
            throws IOException {
        //首先获得TCP/IP连接
        SocketConnection socketConnection = new NativeSocketConnection();
        socketConnection.connect(this.hostInfo.getHost(), this.hostInfo.getPort(), this.propertySet, getExceptionInterceptor(), this.log, loginTimeout);

        // 对TCP/IP连接进行协议包装
        if (this.protocol == null) {
            this.protocol = NativeProtocol.getInstance(this, socketConnection, this.propertySet, this.log, transactionManager);
        } else {
            this.protocol.init(this, socketConnection, this.propertySet, transactionManager);
        }

        // 通过用户名和密码连接指定数据库，并创建会话
        this.protocol.connect(user, password, database);
    }

针对数据库的连接，暂时点到为止，另外还有涉及数据库操作的源码分析，后续再完善补充。

相关源码请移步：https://github.com/ZhangZiSheng001/jdbc-demo

本文为原创文章，转载请附上原文出处链接：https://www.cnblogs.com/ZhangZiSheng001/p/11917307.html