雙親委派模型與Tomcat類加載架構

時間 2019-12-04

原文原文鏈接

雙親委派模型

類加載器的劃分

啓動類加載器(Bootstrap ClassLoader)
擴展類加載器(Extension ClassLoader)
應用程序類加載器(Application Classloader)

啓動類加載器負責將存放在<JAVA_HOME>\lib目錄中的，或者被-Xbootclasspath參數所指定的路徑中的，而且是虛擬機識別的類庫加載到虛擬機內存中。啓動類加載器沒法被Java程序直接引用。
擴展類加載器由sun.misc.Launcher$ExtClassLoader實現，它負責加載<JAVA_HOME>\lib\ext目錄中，或者被java.ext.dirs系統變量所指定的路徑中的全部類庫，開發者能夠直接使用擴展類加載器。
應用程序類加載器由sun.misc.Launcher$App-ClassLoader實現。應用程序類加載器也稱之爲系統類加載器。它負責加載用戶類路徑(ClassPath)上所指定的類庫。應用程序中若是沒有自定義類加載器，那通常狀況下應用程序類加載器就是程序中默認的類加載器。html

雙親委派模型的工做過程

雙親委派模型要求除了頂層的啓動類加載器外，其他的父類加載器都應當有本身的父類加載器。這裏的父類加載器以前的父子關係通常不會以繼承的關係來實現，而都使用組合關係來複用父加載器的代碼。
若是一個類加載器收到了類加載的請求，它首先不會本身去嘗試加載這個類，而是把這個請求委派給父類加載器去完成，每個層次的類加載器都是如此，所以全部的加載請求最終都應該傳送到頂層的啓動類加載器中，只有父加載器反饋本身沒法完成這個加載請求(它的搜索範圍中沒有找到所需的類)時，子加載器纔會嘗試本身去加載。
雙親委派模型的代碼都集中在java.lang.ClassLoader的loadClass()方法中：先檢查是否已經被加載過，若沒有加載則調用父加載器的loadClass()方法，若父加載器爲空則默認使用啓動類加載器做爲父加載器。若是父加載器加載失敗,拋出ClassNotFoundException異常後，再調用本身的findClass()方法進行加載。

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    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();
                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(c);
        }
        return c;
    }
}
複製代碼

雙親委派模型的做用

Java類隨着它的類加載器一塊兒具有了一種帶有優先級的層次關係。例如類java.lang.Object，它存放在rt.jar之中，不管哪個類加載器要加載這個類，最終都是委派給處於模型最頂端的啓動類加載器進行加載，所以Object類在程序在程序的各類類加載器環境中都是同一個類。java

破壞雙親委派模型

Java有許多核心庫提供的SPI接口，容許第三方爲這些接口提供實現，常見的有JDBC、JNDI等。問題是SPI接口是核心庫的一部分,是由啓動類加載器來加載的，而SPI接口的實現類是由應用程序類加載器來加載的。根據雙親委派模型，Bootstrap ClassLoader沒法委派Application Classloader來加載類(有關Java的SPI能夠參考Dubbo SPI中2.1節的Java SPI例子)。爲了解決這個問題，咱們引入一個線程上下文類加載器(Thread Context ClassLoader)。這個類加載器能夠經過java.lang.Thread類的setContextClassLoader()方法進行設置，若是建立線程時還未設置，它將會從父線程中繼承一個，若是在應用程序的全局範圍內都沒有設置過的話，那這個類加載器默認就是應用程序類加載器。
咱們來看下JDBC的驅動管理類DriverManager的代碼：
初始化jdbc驅動類web

/** * 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");
}
複製代碼

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的load方法，這裏就用到了線程上下文類加載器。sql

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

Tomcat的類加載架構

Tomcat做爲一個web容器須要解決下面幾個問題：apache

部署在同一服務器上的兩個Web應用程序所使用的Java類庫能夠實現相互隔離，由於兩個不一樣的應用程序可能會依賴同一個第三方類庫的不一樣版本，不能要求一個類庫在一個服務器中只有一份，服務器應當保證兩個應用程序的類庫能夠互相獨立使用。
部署在同一服務上的兩個Web應用程序所使用的Java類庫能夠互相共享。
服務器須要儘量地保證自身的安全不受部署的Web應用程序影響。通常來講，服務器所使用的類庫應該與應用程序的類庫互相獨立。
支持JSP應用的Web服務器，大多數須要支持Hotswap功能。

Tomcat類加載架構以下圖： bootstrap

CommonClassLoader、CatalinaClassLoader、SharedClassLoader和WebappClassLoader分別加載/common/*、/server/*、/shared/*(Tomcat6已經合併到根目錄下的lib目錄下)和/WebApp/WEB-INF/*中的Java類庫。其中WebApp類加載器和JSP類加載器一般會存在多個實例，每一個Web應用程序對應一個WebApp類加載器，每個JSP文件對應一個JSP類加載器。

CommonClassLoader加載路徑中的class能夠被Tomcat和全部的Web應用程序共同使用
CatalinaClassLoader加載路徑中的class可被Tomcat使用，對全部的Web應用程序都不可見
SharedClassLoader加載路徑中的Class可被全部的Web應用程序共同使用，但對Tomcat本身不可見
WebappClassLoader加載路徑中的Class只對當前webapp可見，對Tomcat和其餘Web應用程序不可見

從委派關係能夠看出:tomcat

各個WebappClassLoader實例之間相互隔離
CommonClassLoader和SharedClassLoader實現了公有類庫的共用
CatalinaClassLoader和SharedClassLoader本身能加載的類與對方相互隔離
JasperLoader的加載範圍僅僅是這個JSP文件所編譯出來的那一個Class

先從Tomcat的啓動方法bootstrap.main方法入手安全

/** * Main method and entry point when starting Tomcat via the provided * scripts. * * @param args Command line arguments to be processed */
public static void main(String args[]) {

    synchronized (daemonLock) {
        if (daemon == null) {
            // Don't set daemon until init() has completed
            Bootstrap bootstrap = new Bootstrap();
            try {
                bootstrap.init();
            } catch (Throwable t) {
                handleThrowable(t);
                t.printStackTrace();
                return;
            }
            daemon = bootstrap;
        } else {
            // When running as a service the call to stop will be on a new
            // thread so make sure the correct class loader is used to
            // prevent a range of class not found exceptions.
            Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
        }
    }

    try {
        String command = "start";
        if (args.length > 0) {
            command = args[args.length - 1];
        }

        if (command.equals("startd")) {
            args[args.length - 1] = "start";
            daemon.load(args);
            daemon.start();
        } else if (command.equals("stopd")) {
            args[args.length - 1] = "stop";
            daemon.stop();
        } else if (command.equals("start")) {
            daemon.setAwait(true);
            daemon.load(args);
            daemon.start();
            if (null == daemon.getServer()) {
                System.exit(1);
            }
        } else if (command.equals("stop")) {
            daemon.stopServer(args);
        } else if (command.equals("configtest")) {
            daemon.load(args);
            if (null == daemon.getServer()) {
                System.exit(1);
            }
            System.exit(0);
        } else {
            log.warn("Bootstrap: command \"" + command + "\" does not exist.");
        }
    } catch (Throwable t) {
        // Unwrap the Exception for clearer error reporting
        if (t instanceof InvocationTargetException &&
                t.getCause() != null) {
            t = t.getCause();
        }
        handleThrowable(t);
        t.printStackTrace();
        System.exit(1);
    }

}
複製代碼

看下init方法，init方法中執行Thread.currentThread().setContextClassLoader方法，將當前線程上下文類加載器設爲catalinaLoader。bash

/** * Initialize daemon. * @throws Exception Fatal initialization error */
public void init() throws Exception {

    initClassLoaders();

    Thread.currentThread().setContextClassLoader(catalinaLoader);

    SecurityClassLoad.securityClassLoad(catalinaLoader);

    // Load our startup class and call its process() method
    if (log.isDebugEnabled())
        log.debug("Loading startup class");
    Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
    Object startupInstance = startupClass.getConstructor().newInstance();

    // Set the shared extensions class loader
    if (log.isDebugEnabled())
        log.debug("Setting startup class properties");
    String methodName = "setParentClassLoader";
    Class<?> paramTypes[] = new Class[1];
    paramTypes[0] = Class.forName("java.lang.ClassLoader");
    Object paramValues[] = new Object[1];
    paramValues[0] = sharedLoader;
    Method method =
        startupInstance.getClass().getMethod(methodName, paramTypes);
    method.invoke(startupInstance, paramValues);

    catalinaDaemon = startupInstance;

}
複製代碼

看下initClassLoaders方法。服務器

private void initClassLoaders() {
    try {
        commonLoader = createClassLoader("common", null);
        if( commonLoader == null ) {
            // no config file, default to this loader - we might be in a 'single' env.
            commonLoader=this.getClass().getClassLoader();
        }
        catalinaLoader = createClassLoader("server", commonLoader);
        sharedLoader = createClassLoader("shared", commonLoader);
    } catch (Throwable t) {
        handleThrowable(t);
        log.error("Class loader creation threw exception", t);
        System.exit(1);
    }
}
複製代碼

能夠看到commonLoader、catalinaLoader、sharedLoader都是在initClassLoaders方法中初始化的。對於Tomcat6.x版本，只有指定了tomcat/conf/catalina.properties配置文件的server.loader和shared.loader項後纔會真正創建CatalinaClassLoader和SharedClassLoader的實例，不然會用到這兩個類加載器的地方都會用CommonClassLoader的實例代替，而默認的配置文件沒有設置這兩個loader項，因此Tomcat6.x把/common、/server和/shared三個目錄默認合併到一塊兒變成一個/lib目錄，這個目錄裏的類庫至關於之前/common目錄中類庫的做用。

common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"
server.loader=
shared.loader=
複製代碼

private ClassLoader createClassLoader(String name, ClassLoader parent) throws Exception {

    String value = CatalinaProperties.getProperty(name + ".loader");
    if ((value == null) || (value.equals("")))
        return parent;

    value = replace(value);

    List<Repository> repositories = new ArrayList<>();

    String[] repositoryPaths = getPaths(value);

    for (String repository : repositoryPaths) {
        // Check for a JAR URL repository
        try {
            @SuppressWarnings("unused")
            URL url = new URL(repository);
            repositories.add(new Repository(repository, RepositoryType.URL));
            continue;
        } catch (MalformedURLException e) {
            // Ignore
        }

        // Local repository
        if (repository.endsWith("*.jar")) {
            repository = repository.substring
                (0, repository.length() - "*.jar".length());
            repositories.add(new Repository(repository, RepositoryType.GLOB));
        } else if (repository.endsWith(".jar")) {
            repositories.add(new Repository(repository, RepositoryType.JAR));
        } else {
            repositories.add(new Repository(repository, RepositoryType.DIR));
        }
    }

    return ClassLoaderFactory.createClassLoader(repositories, parent);
}
複製代碼