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

时间 2021-08-12

标签 html java mysql sql 数据库数据结构并发 app jvm ide 栏目 Java 繁體版

原文原文链接

文章目录

1. 工做原理

通常咱们主要的JDBC处理流程以下：html

1.1 加载驱动

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

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

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

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

加载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属性，里面存放着注册的驱动信息。若是这个驱动已经被注册，那么就不会再注册。app

    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”)这句代码分析就结束了。jvm

1.1.1 类加载相关知识

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

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

程序启动的时候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,传入的是一个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，仍是能够运行的以下：

这是什么缘由呢？？？

仔细一点就会发现，在咱们引入的mysql包中，有一个配置文件，java.sql.Driver，里面配置了

这里使用了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是须要较大的开销的，那这样应该怎么作呢？这就不得不说到链接池技术了。
数据库链接池，就是负责分配，管理和释放数据库链接，使用完以后的链接，放回到数据库链接池中，能够重复利用。
此文章仅表明本身（本菜鸟）学习积累记录，或者学习笔记，若有侵权，请联系做者删除。人无完人，文章也同样，文笔稚嫩，在下不才，勿喷，若是有错误之处，还望指出，感激涕零~

技术之路不在一时，山高水长，纵使缓慢，驰而不息。

公众号：秦怀杂货店