[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，还是能够运行的如下：
这是什么起因呢？？？
认真一点就会发现，在咱们引入的 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 是须要较大的开销的，那这样应该怎么做呢？这就不得不说到连接池技术了。
数据库连接池，就是负责调配，治理和开释数据库连贯，应用完之后的连贯，放回到数据库连接池中，能够反复利用。
此文章仅代表本人（本菜鸟）学习积攒记录，或者学习笔记，如有侵权，请分割作者删除。人无完人，文章也一样，文笔稚嫩，在下不才，勿喷，如果有谬误之处，还望指出，感激不尽~
技术之路不在一时，山高水长，纵使迟缓，驰而不息。
公众号：秦怀杂货店