類的加載過程
ClassLoader的主要職責就是負責加載各種Class文件到JVM中，ClassLoader會嘗試加載並在JVM中生成這個類的各種數據結構，然後使其分佈在JVM對應的內存區域中。準確說是在類的加載階段（加載，連接，初始化的加載階段），把這個Class文件的二進制字節流對應的靜態存儲結構轉換爲方法區的運行時數據結構，並且在該過程中會在堆內存中生成一個java.lang.class對象，這個Class對象是訪問方法區數據結構的入口，Class對象包含了這個類的詳細信息，比如說可以獲取到這個類裏面的方法，類的實例也是通過Class對象生成的。
類的加載過程主要分爲三個階段，加載，連接，初始化：
加載
加載階段主要做的事是把Class文件的二進制字節流加載到內存當中，需要特別注意的點有：
1.加載Class文件的時候，JVM規範規定，類的加載必須通過類的全限定名（包名+類名）來獲取二進制數據流，但是並沒有規定必須通過某種方式去獲取，我們常見的形式是Class二進制文件的形式，其他的形式，只要是拿到了二進制字節流，也可以加載到內存當中，具體有哪些形式不做詳細討論，不是本次的重點，細節可以參考《Java高併發編程詳解》第9章類的加載過程。全限定類名區別於運行時包名，運行時包名是對應的ClassLoader+全限定類名。
2.加載階段除了要把二進制字節流讀取到內存當中，還會把二進制字節流代表的靜態存儲結構轉換爲運行時數據結構，存儲在方法區當中，並且會生成一個java.lang.Class對象。這個對象在堆內存當中，是訪問方法區數據結構的入口。
3.類的加載過程一定是按照順序按部就班進行的，加載之後才能開啓連接，連接之後才能開啓初始化，但是在加載開啓到加載結束之間，連接開啓，這樣就是交叉進行。也就是說所謂的交叉進行也是在按部就班的順序的前提下進行的。
連接
連接階段可以細分爲三個小階段：
驗證：是否是Class文件，Class的版本，低版本不能編譯高版本的問題，反之可以。
準備：爲類的靜態變量分配內存，並且爲其初始化默認值，例如Int 的初始值爲0。
解析：把類中的符號引用轉換爲直接引用。意思就是把類的全限定名，就是類的地址轉換爲在內存當中實際的存儲地址。
初始化階段
爲類的靜態變量賦予正確的初始值，代碼編寫階段給的值。JVM不是一開始就加載了所有的類，除了核心的類以外，其他的類都是在用到時候纔開始加載的。而且，同一個ClassLoader加載的全限定名一樣的類，就能加載一次，也就是說同一個類，同一個類加載器加載的只能在內存中加載一次，第二次就不加載了。JVM規範沒有明確規定類的加載時機，但是規定了類的初始化時機，因爲類的初始化一定是在類的加載之後纔開始的，所以類初始化了，那麼一定是加載了的。JVM規定了Java程序首次主動使用的時候纔會對類進行初始化，6種主動使用類的場景會導致類的初始化：
- new關鍵字
- static靜態方法，該類初始化
- static靜態變量
- 反射操作Class.forName
- 初始化子類會導致父類的初始化
- main方法
如果被final修飾則不會導致初始化，例如final static。
初始化階段做的最主要的一件事就是執行<clinit>()方法，所有的類變量都會被賦予正確的值。在編譯階段就已經生成在了Class文件中了。如果某個類中沒有靜態代碼塊，也沒有靜態變量，則沒有生成<clinit>()方法的必要了。有一個例子：
public class Singleton{
private static int x=0;
private static int y；
private static Singleton instance = new Singleton();
private Singleton(){
x++;
y++;
}
public static Singleton getInstance(){
return instance;
}
public static void main(String [] args){
Singleton singleton = Singleton.getInstance();
System.out.println(singleton.x);
System.out.println(singleton.y);
}
}
結果，x=1,y=1；
如果換成
private static Singleton instance = new Singleton();
private static int x=0;
private static int y；
結果爲 x=0 ,y=1
原因是x=1，y=1到了類初始化階段，x被程序賦值爲0，y沒有被賦值。另外，類的成員變量會初始化，臨時變量不會初始化。
pulbic class test{
int i
public static void main(String[] args){
int j
}
}
i叫類成員變量，j叫臨時變量，j在編譯會報錯提示需要初始化。
JVM類加載器
jvm內置三大類加載器：
Bootstrap ClassLoader爲根類加載器，最頂層的類加載器，沒有父類，由C++編寫，整個java.lang包都由他加載。
Extentsion ClassLoader拓展類加載器，負責加載JAVA_HOME下的jre\lb\ext子類目錄裏的類庫。
App ClassLoader系統類加載器，負責加載我們Classpath下的Class文件。
類加載器就是加載不同路徑下的文件。
自定義類加載器，加載自己指定路徑下的文件。
雙親委派的原理：
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// 首先，檢查是否已經加載過
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
//父加載器不爲空,調用父加載器的loadClass
c = parent.loadClass(name, false);
} else {
//父加載器爲空則,調用Bootstrap Classloader
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
//父加載器沒有找到，則調用findclass
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
//調用resolveClass()
resolveClass(c);
}
return c;
}
}
也就是說：我們的一個java類，加載進來，先交給App ClassLoader，然後：
1.Class是否被加載過，如果被加載過，即Class對象不爲null則返回Class對象。
2.如果沒有被加載過，那就委託他的父級加載器Ext ClassLoader加載，還是沒有繼續委託Bootstrap類加載器
3.如果所有的類加載器都說這個類沒有被加載過，這個時候已經到了最頂層的Bootstrap ClassLoader。那麼從頂層的Bootstrap開始，查找自己的加載路徑下是否有這個文件，即findClass。對於Bootstrap就是到自己指定類加載路徑下（"sun.boot.class.path"）查看是否有Test.class字節碼，有則返回，沒有通知下一層加載器ExtClassLoader到自己指定的類加載路徑下（java.ext.dirs）查看。最後回到App ClassLoader或者是我們自定義的類加載器。如果還是沒有則拋出異常ClassNotFoundException。
理解了loadClass,findClass,findLoadedClass，是理解雙親委派和破壞雙親委派的關鍵。
自定義類加載器是重寫了findClass方法，也就是說定義了自己的類加載器的加載路徑，加載哪個路徑下的文件。自定義類加載器只是到findClass方法爲止。
loadClass是把Class文件加載到內存中去，雙親委派是在loadClass裏面體現的，也就是說如果要破壞這種雙親委派，只需要把Class cl的findClass方法放到parent.loadClass之前就可以了，意思就是先查找自己路徑下的文件，而不是先委託父級類加載器去查找。findLoadedClass的意思是查找這個Class是否已經加載到內存當中了。
需要注意的是，resolve如果爲false則不進入連接階段，也就無法開始初始化。
JVM規範規定了不同的運行時包下的類彼此之間是不能夠訪問的，但我們可以用java.lang下的包。根據JVM規範規定，在類的加載過程中，所有參與的類加載器，即使沒有親自加載過該類，也會被標識爲初始類加載器，JVM會在每一個類加載器維護的列表中添加該類Class類型，test.class和String.class被同時維護，也就可以互相調用了。
線程上下文類加載器
使用線程上下文類加載器的原因是：Java核心類庫提供了很多SPI，包括JDBC等等，屬於頂層接口，但是具體的接口實現是由各大廠商實現的。由於抽象接口是Bootstrap加載器加載的，原來的雙親委派原則不適用，只能在Bootstrap加載器加載的時候委託App ClassLoader加載器加載，於是就有了線程上下文類加載器。
以MySql的JDBC爲例：主要分爲兩步
1.向DriverManager註冊實現的實例。
static {
loadInitialDrivers();
println("JDBC DriverManager initialized");
}
private static void loadInitialDrivers() {
String drivers;
try {
drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
public String run() {
return System.getProperty("jdbc.drivers");
}
});
} catch (Exception ex) {
drivers = null;
}
// If the driver is packaged as a Service Provider, load it.
// Get all the drivers through the classloader
// exposed as a java.sql.Driver.class service.
// ServiceLoader.load() replaces the sun.misc.Providers()
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
/* Load these drivers, so that they can be instantiated.
* It may be the case that the driver class may not be there
* i.e. there may be a packaged driver with the service class
* as implementation of java.sql.Driver but the actual class
* may be missing. In that case a java.util.ServiceConfigurationError
* will be thrown at runtime by the VM trying to locate
* and load the service.
*
* Adding a try catch block to catch those runtime errors
* if driver not available in classpath but it's
* packaged as service and that service is there in classpath.
*/
try{
while(driversIterator.hasNext()) {
driversIterator.next();
}
} catch(Throwable t) {
// Do nothing
}
return null;
}
});
println("DriverManager.initialize: jdbc.drivers = " + drivers);
if (drivers == null || drivers.equals("")) {
return;
}
String[] driversList = drivers.split(":");
println("number of Drivers:" + driversList.length);
for (String aDriver : driversList) {
try {
println("DriverManager.Initialize: loading " + aDriver);
Class.forName(aDriver, true,
ClassLoader.getSystemClassLoader());
} catch (Exception ex) {
println("DriverManager.Initialize: load failed: " + ex);
}
}
}
最關鍵的部分爲：
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
/* Load these drivers, so that they can be instantiated.
* It may be the case that the driver class may not be there
* i.e. there may be a packaged driver with the service class
* as implementation of java.sql.Driver but the actual class
* may be missing. In that case a java.util.ServiceConfigurationError
* will be thrown at runtime by the VM trying to locate
* and load the service.
*
* Adding a try catch block to catch those runtime errors
* if driver not available in classpath but it's
* packaged as service and that service is there in classpath.
*/
try{
while(driversIterator.hasNext()) {
driversIterator.next();
}
} catch(Throwable t) {
// Do nothing
}
ServiceLoader的實現其實就是應用了線程上下文類加載器，破壞了雙親委派原則。ServiceLoader的具體實現：
public static <S> ServiceLoader<S> load(Class<S> service) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return ServiceLoader.load(service, cl);
}
public static <S> ServiceLoader<S> load(Class<S> service,
ClassLoader loader)
{
return new ServiceLoader<>(service, loader);
}
public void reload() {
providers.clear();
lookupIterator = new LazyIterator(service, loader);
}
private ServiceLoader(Class<S> svc, ClassLoader cl) {
service = Objects.requireNonNull(svc, "Service interface cannot be null");
loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
reload();
}
private class LazyIterator
implements Iterator<S>
{
Class<S> service;
ClassLoader loader;
Enumeration<URL> configs = null;
Iterator<String> pending = null;
String nextName = null;
private LazyIterator(Class<S> service, ClassLoader loader) {
this.service = service;
this.loader = loader;
}
private boolean hasNextService() {
if (nextName != null) {
return true;
}
if (configs == null) {
try {
String fullName = PREFIX + service.getName();
if (loader == null)
configs = ClassLoader.getSystemResources(fullName);
else
configs = loader.getResources(fullName);
} catch (IOException x) {
fail(service, "Error locating configuration files", x);
}
}
while ((pending == null) || !pending.hasNext()) {
if (!configs.hasMoreElements()) {
return false;
}
pending = parse(service, configs.nextElement());
}
nextName = pending.next();
return true;
}
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
}
public boolean hasNext() {
if (acc == null) {
return hasNextService();
} else {
PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
public Boolean run() { return hasNextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}
public S next() {
if (acc == null) {
return nextService();
} else {
PrivilegedAction<S> action = new PrivilegedAction<S>() {
public S run() { return nextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}
public void remove() {
throw new UnsupportedOperationException();
}
}
public Iterator<S> iterator() {
return new Iterator<S>() {
Iterator<Map.Entry<String,S>> knownProviders
= providers.entrySet().iterator();
public boolean hasNext() {
if (knownProviders.hasNext())
return true;
return lookupIterator.hasNext();
}
public S next() {
if (knownProviders.hasNext())
return knownProviders.next().getValue();
return lookupIterator.next();
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
注意driversIterator.next()最終就是調用Class.forName(DriverName, false, loader)方法
ContextClassLoader默認存放了AppClassLoader的引用，由於它是在運行時被放在了線程中，所以不管當前程序處於何處（BootstrapClassLoader或是ExtClassLoader等），在任何需要的時候都可以用Thread.currentThread().getContextClassLoader()取出應用程序類加載器來完成需要的操作。
之所以跟線程有關係，是因爲在Tomcat部署多個服務時候的應用場景，要保證每一個執行的線程都有AppClassLoader
2.比對校驗
在getConnection的時候有這樣一段代碼：
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());
}
}
private static boolean isDriverAllowed(Driver driver, ClassLoader classLoader) {
boolean result = false;
if(driver != null) {
Class<?> aClass = null;
try {
aClass = Class.forName(driver.getClass().getName(), true, classLoader);
} catch (Exception ex) {
result = false;
}
result = ( aClass == driver.getClass() ) ? true : false;
}
return result;
}
isDriverAllowed這個方法是爲了比對：已經註冊到driverManger的實例和getConnection時候調用者加載的實例是不是一個。
ServiceLoader的使用：META-INF/services 文件名爲接口的全限定名，文件內容爲定義的具體實現類全限定名。
詳細資料：
https://blog.csdn.net/yangcheng33/article/details/52631940
https://blog.csdn.net/justloveyou_/article/details/72466105