JVM类加载器（五）

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.20</version>
</dependency>

package com.leolin.jvm;

import java.sql.Driver;
import java.util.Iterator;
import java.util.ServiceLoader;

public class MyTest26 {
    public static void main(String[] args) {
        ServiceLoader<Driver> loader = ServiceLoader.load(Driver.class);
        Iterator<Driver> iterator = loader.iterator();
        while (iterator.hasNext()) {
            Driver driver = iterator.next();
            System.out.println("driver:" + driver.getClass() + ", loader:" + driver.getClass().getClassLoader());
        }
        System.out.println("当前线程上下文类加载器：" + Thread.currentThread().getContextClassLoader());
        System.out.println("ServiceLoader的类加载器：" + ServiceLoader.class.getClassLoader());
    }
}

driver:class com.mysql.cj.jdbc.Driver, loader:sun.misc.Launcher$AppClassLoader@18b4aac2
当前线程上下文类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2
ServiceLoader的类加载器：null

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);
}

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();
}

public void reload() {
	providers.clear();
	lookupIterator = new LazyIterator(service, loader);
}

private class LazyIterator
	implements Iterator<S>
{

	Class<S> service;
	ClassLoader loader;
	……

	private LazyIterator(Class<S> service, ClassLoader loader) {
		this.service = service;
		this.loader = loader;
	}
	……
}

com.mysql.cj.jdbc.Driver

package com.leolin.jvm;

import java.sql.Connection;
import java.sql.DriverManager;

public class MyTest27 {
    public static void main(String[] args) throws Exception {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql//localhost:3306/mytest", "username", "password");
    }
}

public static Class<?> forName(String className)
			throws ClassNotFoundException {
	Class<?> caller = Reflection.getCallerClass();
	return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}

private static native Class<?> forName0(String name, boolean initialize,
										ClassLoader loader,
										Class<?> caller)
	throws ClassNotFoundException;

package com.mysql.jdbc;

import java.sql.SQLException;

public class Driver extends com.mysql.cj.jdbc.Driver {
    public Driver() throws SQLException {
    }

    static {
        System.err.println("Loading class `com.mysql.jdbc.Driver‘. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver‘. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.");
    }
}

package com.mysql.cj.jdbc;

import java.sql.DriverManager;
import java.sql.SQLException;

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can‘t register driver!");
        }
    }
}

	private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
	……
    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.addIfAbsent(new DriverInfo(driver, da));
        } else {
            // This is for compatibility with the original DriverManager
            throw new NullPointerException();
        }

        println("registerDriver: " + driver);

    }
	……

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()));
}

private static Connection getConnection(
	String url, java.util.Properties info, Class<?> caller) throws SQLException {
	
	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 + "\")");

	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 we got here nobody could connect.
	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");
}

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;
}