一、JDBC之前加载驱动的方式
在说破坏双亲委派之前，先看下之前是怎么加载Driver的。在刚开始的时候JDBC在加载class的时候，其实是直接利用了Class.classforName
Class.forName()和ClassLoader.loadClass区别
Class.forName(className)方法，内部实际调用的方法是 Class.forName(className,true,classloader);
第2个boolean参数表示类是否需要初始化， Class.forName(className)默认是需要初始化。
一旦初始化，就会触发目标对象的 static块代码执行，static参数也也会被再次初始化。
ClassLoader.loadClass(className)方法，内部实际调用的方法是 ClassLoader.loadClass(className,false);
第2个 boolean参数，表示目标对象是否进行链接，false表示不进行链接，由上面介绍可以，
不进行链接意味着不进行包括初始化等一些列步骤，那么静态块和静态对象就不会得到执行
//加载Oracle数据库驱动
Driver driver = (Driver)Class.forName("oracle.jdbc.driver.OracleDriver");
//加载SQL Server数据库驱动
Driver driver = (Driver)Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
//加载MySQL 数据库驱动
Driver driver = (Driver)Class.forName("com.mysql.jdbc.Driver");
Class.forName()将对应的驱动类加载到内存中，然后执行内存中的static静态代码段，代码段中，会创建一个驱动Driver的实例，放入DriverManager中，供DriverManager使用。
static {
Timestamp localTimestamp = Timestamp.valueOf("2000-01-01 00:00:00.0");
try {
if (defaultDriver == null) {
//创建一个OracleDriver实例，然后注册到DriverManager中
defaultDriver = new OracleDriver();
DriverManager.registerDriver(defaultDriver);
}
} catch (RuntimeException localRuntimeException) {
} catch (SQLException localSQLException) {
}
下面是一个加载Driver、注册、注销、重新注册的代码示例：
public static void defaultDriver(){
try {
String url = "jdbc:oracle:thin:@127.0.0.1:1521:xe";
//1.将Driver加载到内存中，然后执行其static静态代码，创建一个OracleDriver实例注册到DriverManager中
Driver dd = (Driver)Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
//2.取出对应的oracle 驱动Driver
Driver driver = DriverManager.getDriver(url);
System.out.println("加载类后，获取Driver对象："+driver);
//3. 将driver从DriverManager中注销掉
DriverManager.deregisterDriver(driver);
//4.此时DriverManager中已经没有了驱动Driver实例，将创建的dd注册到DriverManager中
DriverManager.registerDriver(dd);
//5.重新通过url从DriverManager中取Driver
driver = DriverManager.getDriver(url);
System.out.println("注销掉静态创建的Driver后，重新注册的Driver: "+driver);
System.out.println("driver和dd是否是同一对象：" +(driver==dd));
} catch (Exception e) {
System.out.println("加载Oracle类失败！");
e.printStackTrace();
} finally{
}
}
以上其实就是早期我们加载JDBC时候的方式。但是这种从上面的代码上也可以看出，假如说我要加载不同的Driver，那么我要去加载不同的
url,来实例化不同的Driver,这样的话会造成代码的冗余，或者说代码之间的耦合性太强（代码要使用的Driver和和Driver的实现耦合到一起），
还有就是如上面写的类似于“oracle.jdbc.driver.OracleDriver”这样的一堆的字符串，所以，之后就出现了利用破坏双亲委派这种机制来加载Driver的方式。
二、JDBC现在加载驱动的方式
接下来看java是如何破坏双亲委派来加载 Driver的，看源码，首先要一个入口：
public static void main(String[] args) throws SQLException {
String url = "jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf-8&useSSL=false";
String username = "root";
String password = "Ys0120.";
Connection conn = null;
try {
conn = DriverManager.getConnection(url, username, password);
PreparedStatement statement = conn.prepareStatement("select * from user where id = ?");
statement.setLong(1,1);
ResultSet set = statement.executeQuery();
while(set.next()){
System.out.println(set.getString("name"));
}
conn.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
代码在执行DriverManager.getConnection(url, username, password); 首先回去实例化DriverManager，而DriverManager是整个加载的核心
DriverManager里面有一个静态的代码块,在实例化的时候会进行初始化执行。
static {
loadInitialDrivers();
println("JDBC DriverManager initialized");
}
loadInitialDrivers();整个方法里面最核心也是执行加载的核心的两行代码如下：
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
下面的load方法重点在于ClassLoader cl = Thread.currentThread().getContextClassLoader();
线程上下文件类加载器(Thread Context ClassLoader)。这个类加载器可以通过java.lang.Thread类的setContextClassLoader()方法进行设置，如果创建线程时还未设置，它将会从父线程中继承一个；如果在应用程序的全局范围内都没有设置过，那么这个类加载器默认就是应用程序类加载器。
public static <S> ServiceLoader<S> load(Class<S> service) {
//因为出入的service 是 java.sql.Driver，它是一个接口，jdk支持了 spi 这种提供接口的方式
//供调用者去实现它的接口，具体调用者去调用哪个实现，Driver不管。
//因为当前service 是一个第三方的类或者说非java自己的类，所以JVM 是无法调用自己的
//类加载器去加载这个Driver类的，所以它需要一个appClassLoader去加载，所以它用了
//TCCL去获取一个 aapClassLoader，然后去执行实例化。
// spi 指的是（service provide interface），第三方可以以jar 的形式提供一个接口类，
//调用者 可以根据自己的业务去实现。
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return ServiceLoader.load(service, cl);
}
下面是具体的实例化的代码，它的底层其实是用了Class.forName去进行实例化。至此，java在加载Driver
的时候是怎么去破坏双亲模型的给说完了，剩下的代码基本上不属于破坏双亲模型的范畴。
private S nextService() {
if (!hasNextService())
throw new NoSuchElementException();
String cn = nextName;
nextName = null;
Class<?> c = null;
try {
c = Class.forName(cn, false, loader);
} catch (ClassNotFoundException x) {
fail(service,
"Provider " + cn + " not found");
}
if (!service.isAssignableFrom(c)) {
fail(service,
"Provider " + cn + " not a subtype");
}
try {
S p = service.cast(c.newInstance());
providers.put(cn, p);
return p;
} catch (Throwable x) {
fail(service,
"Provider " + cn + " could not be instantiated",
x);
}
throw new Error(); // This cannot happen
}
