jdbc驅動的類加載過程

這段時間跟類加載機制是干上了。

這一篇來分析一下jdbc工作過程中涉及到的類加載流程，重點是想看看在雙親委派模型不適用的時候，如何解決。

第一步，加載數據庫的驅動

Class.forName("oracle.jdbc.driver.OracleDriver")
Class.forName("com.mysql.jdbc.Driver")

Class.forName 方法會根據類的全路徑名稱去加載對應的class文件，生成類型，並初始化類型。也就是說static語句塊會執行。

下面來看看 com.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!");
        }
    }

    /**
     * Construct a new driver and register it with DriverManager
     * 
     * @throws SQLException
     *             if a database error occurs.
     */
    public Driver() throws SQLException {
        // Required for Class.forName().newInstance()
    }
}

里面的主要邏輯都在父類 NonRegisteringDriver 里實現，而static語句塊就做了一件事：生成驅動實例，並向DriverManager注冊。所謂注冊，就是將driver的信息保存起來，以便后來取用。

 

第二步，取得數據庫連接connection

 

Connection conn= DriverManager.getConnection(url, user, password);

 

這里為什么通過DriverManager來取，而不是直接通過生成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()));
    }

Reflection.getCallerClass() 是取得調用類，這個方法是native的。我這里是jdk1.8，以前的版本不是調用的這個方法，如果感興趣也可以看看。

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

這個方法一開始就要得到調用類caller的類加載器callerCL，為的是后面再去加載數據庫的driver，做一下驗證，

具體在 isDriverAllowed(aDriver.driver, callerCL) 里面的代碼里。

那問題來了，為什么就不能用加載DriverManager的類加載器呢？？？

因為DriverManager在rt.jar里面，它的類加載器上啟動類加載器。而數據庫的driver（com.mysql.jdbc.Driver）是放在classpath里面的，啟動類加載器是不能加載的。所以，如果嚴格按照雙親委派模型，是沒辦法解決的。而這里的解決辦法是：通過調用類的類加載器去加載。而如果調用類的加載器是null，就設置為線程的上下文類加載器：

Thread.currentThread().getContextClassLoader()

好的，下面通過Thread類的源碼，分析線程的上下文類加載器。

 

    /* The context ClassLoader for this thread */
    private ClassLoader contextClassLoader;

    // 這段if---else代碼出自init方法
    if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
    else
            this.contextClassLoader = parent.contextClassLoader;


    public ClassLoader getContextClassLoader() {
        if (contextClassLoader == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader.checkClassLoaderPermission(contextClassLoader,
                                                   Reflection.getCallerClass());
        }
        return contextClassLoader;
    }


    public void setContextClassLoader(ClassLoader cl) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
        }
        contextClassLoader = cl;
    }

 

 

init方法里面代碼的邏輯是：把父線程的上下文類加載器給繼承過來。這里的父子關系是指誰啟動誰的關系，比如在線程A里面啟動了線程B，那B線程的父線程就是A。

既然都是一路繼承，那第一個啟動的線程（包含main方法的那個線程）里面的contextClassLoader是誰設置的呢？？？

這就要看 sun.misc.Launcher 這個類的源碼。Launcher是JRE中用於啟動程序入口main()的類。

loader = AppClassLoader.getAppClassLoader(extcl);

Thread.currentThread().setContextClassLoader(loader);

這里截取的兩行代碼出自 Launcher 的構造方法。第一行用一個擴展類加載器extcl構造了一個系統類加載器loader，第二行把loader設置為當前線程（包含main方法）的類加載器。所以，我們啟動一個線程的時候，如果之前都沒有調用 setContextClassLoader 方法明確指定的話，默認的就是系統類加載器。

到這里，整個加載流程基本上一目了然了。

 

現在，再回到之前 DriverManager的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());
            }

        }

最后返回一個connection，但是在一個循環里面。也就是說，當我們注冊了多個數據庫驅動，mysql，oracle等；DriverManager都幫我們管理了，它會取出一個符合條件的driver，就不用我們在程序里自己去控制了。