首页 > 其他分享> > JDBC【2】-- JDBC工作原理以及简单封装

JDBC【2】-- JDBC工作原理以及简单封装

2021-03-16 11:01:50 作者：互联网

[TOC]

1. 工作原理

一般我们主要的JDBC处理流程如下：

graph TD
A[注册一个Driver] -->B(建立数据库连接)
B --> C(创建一个Statement)
C-->D(执行SQL语句,获取结果)
D-->F(关闭JDBC对象)

1.1 加载驱动

首先声明：这个阶段在1.6之后就不需要手动执行了，也就是这个代码不需要了！！！分析它有利于理解流程。

Class.forName("com.mysql.jdbc.Driver")

上面代码发生在注册Driver阶段，指的是让JVN将com.mysql.jdbc.Driver这个类加载入内存中，最重要的是将mysql驱动注册到DriverManager中去。

此处加载Driver的时候，加载的是java.mysql.jdbc包下的，这其实是一种向后兼容的做法，实际上代码都是写在了com.mysql.cj.jdbc下，所以，mysql的连接包使用了继承的方式，com.mysql.jdbc.Driver只是对外的一个兼容类，其父类是com.mysql.cj.jdbc.Driver，真正的的mysql Driver驱动。

加载Driver的目的就是加载它的父类:

public class Driver extends com.mysql.cj.jdbc.Driver {
    public Driver() throws SQLException {
        super();
    }
}

我们打开com.mysql.cj.jdbc.Driver,可以发现，里面有一个构造空方法，这也是调用Class.forName().newInstance()所需要的，这个类继承了NonRegisteringDriver，实现了java.mysql.Driver。
里面有一个空无参构造方法，为反射调用newInstance()准备的，另外就是静态代码块，静态代码块主要的功能是通过DriverManager注册自己（Driver，也就是驱动），这里很重要的一点，就是Driver是java.sql.Driver(这是jdk的包！！！)的实现。

我们引入的驱动本质上是JDK中的Driver的实现类，为啥？这就是标准，约束，不这样干，不合规矩。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    static {
        try {
            // 调用DriverManager 注册自己（Driver）
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    public Driver() throws SQLException {
        // Class.forName().newInstance() 所需要的
    }
}

DriverManager里面基本全是static方法，也就是专门管理各种驱动的，registerDriver()方法如同其名字，就是为了注册驱动，注册到哪里呢？
看下面的代码，可以知道，driverInfo（驱动相关信息）会被添加到registeredDrivers里面去。registeredDrivers是DriverManager的static属性，里面存放着注册的驱动信息。如果这个驱动已经被注册，那么就不会再注册。

    public static synchronized void registerDriver(java.sql.Driver driver)
        throws SQLException {
        registerDriver(driver, null);
    }
    public static synchronized void registerDriver(java.sql.Driver driver,
            DriverAction da)
        throws SQLException {

        /* Register the driver if it has not already been added to our list */
        if(driver != null) {
            // 将驱动相关信息加到registeredDrivers
            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
        } else {
            // This is for compatibility with the original DriverManager
            throw new NullPointerException();
        }

        println("registerDriver: " + driver);

    }

到这里其实Class.forName(“com.mysql.jdbc.Driver”)这句代码分析就结束了。

1.1.1 类加载相关知识

类加载，是将类的.class文件（二进制数据）翻译读进内存中，放在虚拟机的运行时数据区里面的方法区内。对应的在堆里面创建一个java.lang.Class对象，java里面万物皆对象，类本质也是对象，这个创建的对象就是封装了类本身在方法区的数据结构，这才是类加载的目的。
再简单一点，就是将类的信息，弄成一个Class对象，放到堆上面，其数据结构在方法区，堆上面的对象是一种封装。

类加载有三种方式，后面两种是反射的时候使用居多。

程序启动的时候JVM自动初始化加载
调用Class.forName()手动加载
调用ClassLoader.loadClass()手动加载

为什么使用Class.forName()而不是ClassLoader.loadClass(),一定要这样做么？两者有什么区别？（先埋一个坑)先简单解释一下：

Class.forName()除了将类的.Class文件加载到JVM中之外，还会对类进行解释，执行类的static代码块，也就是默认会初始化类的一些数据（可以设置为不执行）。但是classLoader是没有的，classLoader只有在newInstance()的时候才会执行static块。
而我们上面看到的com.mysql.cj.jdbc.Driver这个类就是使用static的方式将自己注册到DriverManager中，所以需要使用Class.forName()。

Class.forName(xxx.xx.xx).newInstance()可不可以，可以，但是没有必要。这样相当于顺带创建出了实例。我们只是需要满足在JDBC规范中明确要求这个Driver类必须向DriverManager注冊自己这个条件，而触发其中的静态代码块即可。

we just want to load the driver to jvm only, but not need to user the instance of driver,
so call Class.forName(xxx.xx.xx) is enough, if you call Class.forName(xxx.xx.xx).newInstance(),
the result will same as calling Class.forName(xxx.xx.xx),
because Class.forName(xxx.xx.xx).newInstance() will load driver first,
and then create instance, but the instacne you will never use in usual,
so you need not to create it.

1.1.2 为什么JDK 1.6之后不需要显示加载了？

Class.forName()代码如下，可以看到的是，调用forName(String name, boolean initialize,ClassLoader loader, Class<?> caller),传入的是一个true，也就是会初始化。

    @CallerSensitive
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

我们将Class.forName()注释掉，我的mysql-connector版本是8.0以上，JDK是1.8，还是可以运行的如下：
JDBC【2】-- JDBC工作原理以及简单封装
这是什么原因呢？？？

仔细一点就会发现，在我们引入的mysql包中，有一个配置文件，java.sql.Driver，里面配置了
JDBC【2】-- JDBC工作原理以及简单封装

这里使用了SPI的技术，也就是Service provider Interface机制，JDK 允许第三方产商或者插件，对JDK的规范做不一样的定制或者拓展。JVM在启动的时候可以检测到接口的实现，如果配置了的驱动就会自动由DriverManager加载注册。这就是为什么不需要显式调用的原因。

也就是JDK定义好接口和规范，引入的包去实现它，并且把实现的全限定类名配置在指定的地方（META-INF文件目录中），表明需要加载这个接口，那么JVM就会一起加载它。具体的源码是ServiceLoader下面的load()方法。

    public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }

1.2 驱动加载完成了，然后呢？

加载完成了驱动，我们需要获取和数据库的连接，连接数据库我们都知道是需要数据库地址，用户名，和密码。

connection=DriverManager.getConnection(URL,USER,PASSWROD);

二话不说，看内部实现。里面其实是用用户和密码构造了一个Properties对象，然后传到另一个方法中进行调用。

    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);
        }

        return (getConnection(url, info, Reflection.getCallerClass()));
    }

真正获取链接的代码如下，获取真正的类加载器，和当前driver的加载器对比，

    private static Connection getConnection(
        String url, java.util.Properties info, Class<?> caller) throws SQLException {
        /*
         * When callerCl is null, we should check the application's
         * (which is invoking this class indirectly)
         * classloader, so that the JDBC driver class outside rt.jar
         * can be loaded from here.
         */
        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
        synchronized(DriverManager.class) {
            // synchronize loading of the correct classloader.
            if (callerCL == null) {
                callerCL = Thread.currentThread().getContextClassLoader();
            }
        }

        if(url == null) {
            throw new SQLException("The url cannot be null", "08001");
        }

        println("DriverManager.getConnection(\"" + url + "\")");

        // Walk through the loaded registeredDrivers attempting to make a connection.
        // Remember the first exception that gets raised so we can reraise it.
        SQLException reason = null;

        for(DriverInfo aDriver : registeredDrivers) {
            // If the caller does not have permission to load the driver then
            // skip it.
            if(isDriverAllowed(aDriver.driver, callerCL)) {
                try {
                    println("    trying " + aDriver.driver.getClass().getName());
                    Connection con = aDriver.driver.connect(url, info);
                    if (con != null) {
                        // Success!
                        println("getConnection returning " + aDriver.driver.getClass().getName());
                        return (con);
                    }
                } catch (SQLException ex) {
                    if (reason == null) {
                        reason = ex;
                    }
                }
            } else {
                println("    skipping: " + aDriver.getClass().getName());
            }
        }

        if (reason != null)    {
            println("getConnection failed: " + reason);
            throw reason;
        }

        println("getConnection: no suitable driver found for "+ url);
        throw new SQLException("No suitable driver found for "+ url, "08001");
    }

为什么要这样设计？
Reflection.getCallerClass()是反射中的方法，他的作用是获取它的调用类，也就是哪一个类调用了这个方法，以前这个方法是Reflection.getCallerClass(int n),也就是支持传入一个n，返回调用栈的第n帧的类，比如A调用了B，B调用Reflection.getCallerClass(2)，当前的Reflection类位于调用栈的第0帧，B位于第1帧，A就是第二帧。

改成无参数的Reflection.getCallerClass()方法之后，Reflection.getCallerClass()方法调用所在的方法必须用@CallerSensitive进行注解，g该方法获取class时会跳过调用链路上所有的有@CallerSensitive注解的方法的类，直到遇到第一个未使用该注解的类,返回。我们可以知道，源码中的所有的getConnection（）都是有注解的，证明会返回我们真正的调用的类。

2. 简单封装

说起 JDBC的时候，我们自定义一下的数据库连接工具：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DBUtil {
    private static String URL="jdbc:mysql://127.0.0.1:3306/test";
    private static String USER="root";
    private static String PASSWROD ="123456";
    private static Connection connection=null;
    static{
        try {
            Class.forName("com.mysql.jdbc.Driver");
            // 获取数据库连接
            connection=DriverManager.getConnection(URL,USER,PASSWROD);
            System.out.println("连接成功");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    // 返回数据库连接
    public static Connection getConnection(){
        return connection;
    }
}

上面的做法，是一直使用同一个connection,这样在并发的时候还是很有缺陷的，所以我们需要多个线程同时操作不同的connection,但是一直创建connection是需要较大的开销的，那这样应该怎么做呢？这就不得不说到连接池技术了。
数据库连接池，就是负责分配，管理和释放数据库连接，使用完之后的连接，放回到数据库连接池中，可以重复利用。

此文章仅代表自己（本菜鸟）学习积累记录，或者学习笔记，如有侵权，请联系作者删除。人无完人，文章也一样，文笔稚嫩，在下不才，勿喷，如果有错误之处，还望指出，感激不尽~

技术之路不在一时，山高水长，纵使缓慢，驰而不息。
公众号：秦怀杂货店

标签：JDBC,封装,--,driver,Driver,forName,static,mysql,Class
来源： https://blog.51cto.com/13604316/2661235