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