线程上下文加载器Context ClassLoader的作用

先以一段mysql 数据库连接的代码作为引子

public class MysqlDriverTest {
    public static void main(String[] args) throws Exception {
        Class.forName("com.mysql.jdbc.Driver");
        DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root");
    }
}

在学习mysql 的数据库操作时，我们经常会使用上面的代码来获取数据库连接。

大家是否想过 Class.forName("com.mysql.jdbc.Driver") 这段代码的意义在哪？我们跟进去看一下

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

    /** Called after security check for system loader access checks have been made.     */
    private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)
        throws ClassNotFoundException;

由于调用的forName0 方法中，传入的initalize 是true，因此Class.forName("com.mysql.jdbc.Driver") 实际上是加载，连接并初始化com.mysql.jdbc.Driver 。既然初始化om.mysql.jdbc.Driver 了这个类，必然会调用其静态代码块。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    //
    // Register ourselves with the DriverManager
    //
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

静态代码块中，实例化了一个com.mysql.jdbc.Driver 对象放到java.sql.DriverManager 类的类变量registeredDrivers 中。这段代码会触发java.sql.DriverManager 类的加载（如果还没有加载）和初始化。

假如我们不先执行 Class.forName("com.mysql.jdbc.Driver") 会发生什么？
我们就无法触发com.mysql.jdbc.Driver 的初始化，不会调用其静态代码块，因此也不会注册该类的实例到DriverManager 中，所以就无法获取到mysql 连接。

上面这段话，至少在jdk1.6 之前是正确的，但是在jdk1.6 之后，就错了，代码可以简化成下面：

public class MysqlDriverTest {
    public static void main(String[] args) throws Exception {
//        Class.forName("com.mysql.jdbc.Driver");
        DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root");
    }
}

我们来分析一下，先来对比下jdk.15 和 jdk1.6 中，jdk 提供的DriverManager 中代码的部分区别：

public class DriverManager {

    ....
    ....
    /**
     * Load the initial JDBC drivers by checking the System property
     * jdbc.properties and then use the {@code ServiceLoader} mechanism
     */
    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }
    ....
    ....
}

jdk1.5 是没有上面这段代码，从1.6 开始，就有了。这段代码的主要作用就是利用SPI 去加载各个厂商提供的Driver 实现类。因此我们不用显式的调用Class.forName("com.mysql.jdbc.Driver") 来加载com.mysql.jdbc.Driver，利用SPI 功能会自动去帮我们加载。

到这里，好像都跟咱们的标题：线程上下文类加载器 没有关系，接下来咱们继续往下讲。

所以当我们main 方法执行时，执行 DriverManager.getConnection(....)，DriverManager 最终会交给启动类加载器来加载，而Driver  接口实现类是由厂商实现的，其实现类放在classPath 下，由系统类加载器加载，根据双亲委托模型，父加载器的命名空间中的类是无法看到子加载器的命名空间中的类，因此DriverManager 是无法加载各个厂商提供的Driver 实现类。

但是，有了线程上下文类加载器Context ClassLoader 就不一样类，假设我们都知道（不知道可以学习下类加载器相关），我们程序运行时，线程上下文类加载器默认是系统类加载器，我们就可以在DriverManager 类里面获取当前线程的线程上下文类加载器，来加载厂商提供的实现类。这样就避免双亲委托模型的父加载器无法加载子加载器负责的类的尴尬局面，可以说是对双亲委托模型的一个补充。

我们可以看看jdk 1.6只有 DriverManager 是怎么利用上下文线程类加载器加载厂商提供的Driver 实现类。跟进去上面代码提到的静态代码块,省略不重要的代码。

    private static void loadInitialDrivers() {
        ...
        ...
        // 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;
            }
        });
        ...
        ...
    }

代码中利用了SPI 加载厂商提供的实现类 ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class)，跟进load 方法

    public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }

从这段代码，可以看出，SPI 获取了线程上下文类加载器，默认是系统类加载器，来加载厂商提供的实现类。具体我们看ServiceLoader 内部类 LazyIterator 的 nextService() 方法

    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
        }

代码中的loader 就是之前获取的线程上下文类加载器。

因此我们可以发现，SPI 的功能是利用线程上下文类加载器，使得 父类加载器 能加载 子类加载器 甚至 其他没有父子关系的类加载器 负责的类。