2. 程式人生 > >類載入器--Tomcat--ParallelWebappClassLoader

類載入器--Tomcat--ParallelWebappClassLoader

阿新 • • 發佈：2018-11-28

首先是jvm自帶的三個類載入器的關係圖：
在這裡插入圖片描述
系統類載入器在載入一個類時，會先查詢已經載入的類，如果沒找到，再委託父載入器（父載入器不是父類，這是2個概念），父載入器沒找到就繼續委託父載入器，直到所有的父載入器都沒有找到，並且都載入失敗之後，就自己載入，如果自己載入也失敗了，就拋異常。

父類載入過，而且還嘗試載入失敗，那麼就自己來

    c = findClass(name);

這個方法在urlClassLoader中實現。自定義類載入器，一般覆蓋這個方法。呼叫protected final Class<?> defineClass(String name, byte[] b, int off, int len,
ProtectionDomain protectionDomain)方法即可。

protected Class<?> findClass(final String name)
        throws ClassNotFoundException
    {
        final Class<?> result;
        try {
            result = AccessController.doPrivileged(
                new PrivilegedExceptionAction<Class<?>>() {
                    public Class<?> run() throws ClassNotFoundException {
                        String path = name.replace('.', '/').concat(".class");
                        Resource res = ucp.getResource(path, false);
                        if (res != null) {
                            try {
                                return defineClass(name, res);
                            } catch (IOException e) {
                                throw new ClassNotFoundException(name, e);
                            }
                        } else {
                            return null;
                        }
                    }
                }, acc);
        } catch (java.security.PrivilegedActionException pae) {
            throw (ClassNotFoundException) pae.getException();
        }
        if (result == null) {
            throw new ClassNotFoundException(name);
        }
        return result;
    }

 
 protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                         ProtectionDomain protectionDomain)
        throws ClassFormatError
    {
        protectionDomain = preDefineClass(name, protectionDomain);
        String source = defineClassSourceLocation(protectionDomain);
        Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
        postDefineClass(c, protectionDomain);
        return c;
    }

直接繼承ClassLoader的類載入器，需要重寫findClass方法，而且這樣產生的類載入器依然是雙親委託的。

如果想破壞雙親委託機制，則還需要額外重寫loadClass方法。

tomcat 擁有不同的自定義類載入器，以實現對各種資源庫的控制。一般來說，tomcat主要用類載入器解決以下4個問題：

  1. 同一個web伺服器裡，各個web專案之間各自使用的Java類庫要相互隔離
  2. 同一個web伺服器中，各個web專案之間可以提供共享的Java類庫
  3. 為了使伺服器不受web專案的影響，應該使伺服器的類庫與應用程式的類庫相互獨立
  4. 對於jsp的web伺服器，應該支援熱插拔功能

tomcat的類載入器定義：
在這裡插入圖片描述
common類載入器負責載入%catalina_home%/lib，%catalina_base%/lib兩個目錄下的class檔案和jar檔案。
在這裡插入圖片描述在這裡插入圖片描述tomcat 7中預設左邊兩個類載入器都是common。

tomcat 7中對這些類載入器的初始化，根據catalina.properties中的server.loader和share.loader屬性來判斷要不要建立新的類載入器。
在這裡插入圖片描述
tomcat中有多少個web應用，就有多少個webappclassLader。
它使用ClassLoaderFactory 構建類載入器，common類載入器new URLClassLoader(array, parent);實際上就是urlclassloader。
父載入器是應用類載入器，tomcat會在啟動時把當前執行緒類載入器設定為common類載入器。

public static ClassLoader createClassLoader(File[] unpacked, File[] packed, final ClassLoader parent) throws Exception

public static ClassLoader createClassLoader(List<ClassLoaderFactory.Repository> repositories, final ClassLoader parent) throws Exception

public static enum RepositoryType {
        DIR,   //載入目錄下所有資源
        GLOB, //整個目錄下所有的jar包資源
        JAR, //單個jar包資源
        URL; //從url上獲取的jar包資源

        private RepositoryType() {
        }
    }

ParallelWebappClassLoader這類的主要邏輯是在父類中實現的，子類只有一個方法。用於熱部署時重新載入所有的類，重新載入其實只需要新建一個類載入器把類再載入一遍就可以了，這裡還保留了載入器之前的狀態。

public ParallelWebappClassLoader copyWithoutTransformers() {
        ParallelWebappClassLoader result = new ParallelWebappClassLoader(this.getParent());
        super.copyStateWithoutTransformers(result);

        try {
            result.start();
            return result;
        } catch (LifecycleException var3) {
            throw new IllegalStateException(var3);
        }
    }
protected void copyStateWithoutTransformers(WebappClassLoaderBase base) {
        base.resources = this.resources;
        base.delegate = this.delegate; //預設一般是false
        base.state = LifecycleState.NEW;
        base.clearReferencesStopThreads = this.clearReferencesStopThreads;
        base.clearReferencesStopTimerThreads = this.clearReferencesStopTimerThreads;
        base.clearReferencesLogFactoryRelease = this.clearReferencesLogFactoryRelease;
        base.clearReferencesHttpClientKeepAliveThread = this.clearReferencesHttpClientKeepAliveThread;
        base.jarModificationTimes.putAll(this.jarModificationTimes);
        base.permissionList.addAll(this.permissionList);
        base.loaderPC.putAll(this.loaderPC);
    }

delegate 為true時，這裡的父類載入器 不是Java語法中的父類，只是單純的父載入器。parent屬性指定的。
在這裡插入圖片描述

為false時
在這裡插入圖片描述

再看核心方法start(），很明顯，在重新建立一個新的類載入器後，會呼叫這個方法：

public void start() throws LifecycleException {
        this.state = LifecycleState.STARTING_PREP;
        WebResource classes = this.resources.getResource("/WEB-INF/classes");
        if(classes.isDirectory() && classes.canRead()) {
            this.localRepositories.add(classes.getURL());
        }

        WebResource[] jars = this.resources.listResources("/WEB-INF/lib");
        WebResource[] var3 = jars;
        int var4 = jars.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            WebResource jar = var3[var5];
            if(jar.getName().endsWith(".jar") && jar.isFile() && jar.canRead()) {
                this.localRepositories.add(jar.getURL());
                this.jarModificationTimes.put(jar.getName(), Long.valueOf(jar.getLastModified()));
            }
        }

        this.state = LifecycleState.STARTED;
    }

父類WebappClassLoaderBase的核心程式碼是下面的部分，讀取位元組碼，呼叫轉換器，載入類。這些步驟和普通載入器區別不大。

 	 byte[] binaryContent = resource.getContent();
          Manifest manifest = resource.getManifest();
        URL codeBase = resource.getCodeBase();
         Certificate[] certificates = resource.getCertificates();
          String packageName;
       if(this.transformers.size() > 0) {
                packageName = path.substring(1, path.length() - ".class".length());
                 Iterator var12 = this.transformers.iterator();

               while(var12.hasNext()) {
                          ClassFileTransformer transformer = (ClassFileTransformer)var12.next();

                           try {
                                    byte[] transformed = transformer.transform(this, packageName, (Class)null, (ProtectionDomain)null, binaryContent);
                                 if(transformed != null) {
                                     binaryContent = transformed;
                                }
                         } catch (IllegalClassFormatException var18) {
                                        log.error(sm.getString("webappClassLoader.transformError", new Object[]{name}), var18);
                                        return null;
                                    }
                                }
                            }

                            packageName = null;
                            int pos = name.lastIndexOf(46);
                            if(pos != -1) {
                                packageName = name.substring(0, pos);
                            }

                            Package pkg = null;
                            if(packageName != null) {
                                pkg = this.getPackage(packageName);
                                if(pkg == null) {
                                    try {
                                        if(manifest == null) {
                                            this.definePackage(packageName, (String)null, (String)null, (String)null, (String)null, (String)null, (String)null, (URL)null);
                                        } else {
                                            this.definePackage(packageName, manifest, codeBase);
                                        }
                                    } catch (IllegalArgumentException var17) {
                                        ;
                                    }

                                    pkg = this.getPackage(packageName);
                                }
                            }

                            if(this.securityManager != null && pkg != null) {
                                boolean sealCheck = true;
                                if(pkg.isSealed()) {
                                    sealCheck = pkg.isSealed(codeBase);
                                } else {
                                    sealCheck = manifest == null || !this.isPackageSealed(packageName, manifest);
                                }

                                if(!sealCheck) {
                                    throw new SecurityException("Sealing violation loading " + name + " : Package " + packageName + " is sealed.");
                                }
                            }

                            try {
                                clazz = this.defineClass(name, binaryContent, 0, binaryContent.length, new CodeSource(codeBase, certificates));
                            } catch (UnsupportedClassVersionError var16) {
                                throw new UnsupportedClassVersionError(var16.getLocalizedMessage() + " " + sm.getString("webappClassLoader.wrongVersion", new Object[]{name}));
                            }

                            entry.loadedClass = clazz;
                            return clazz;
                        }

相關推薦

類載入器--Tomcat--ParallelWebappClassLoader

首先是jvm自帶的三個類載入器的關係圖： 系統類載入器在載入一個類時，會先查詢已經載入的類，如果沒找到，再委託父載入器（父載入器不是父類，這是2個概念），父載入器沒找到就繼續委託父載入器，直到所有的父載入器都沒有找到，並且都載入失敗之後，就自己載入，如果自己載入也失敗了，就拋異常。 父

Java類載入器--Tomcat的類載入器架構

文章引用: 主流的Java Web伺服器（也就是Web容器），如Tomcat、Jetty、WebLogic、WebSphere或其他筆者沒有列舉的伺服器，都實現了自己定義的類載入器（一般都不止一個）。因為一個功能健全的Web容器，要解決如下幾個問題： 1

Tomcat類載入器破壞雙親委派

轉載：https://blog.csdn.net/qq_38182963/article/details/78660779 http://www.cnblogs.com/aspirant/p/8991830.html http://www.cnblogs.com/xing901022/p/4574961.

Tomcat類載入器體系結構

檔案結構： Tomcat6： Tomcat預設把/common、/server和/shared三個目錄合併成一個/lib目錄，因此Tomcat6預設可以存放java類庫以及Web應用的目錄如下： (1)./lib目錄：類庫可以

tomcat類載入器找不到jar包中的類問題分析與解決思路

我們忽略了tomcat內部自定義的類載入器只想到了JVM的那幾個載入器，tomcat有個叫webApp的載入器它是先載入WEB-INF/classes後在載入WEB-INF/lib，但它的父載入器是它的common載入器，comon的父載入器是system載入器（和JVM的應用程式載入器功能差不多，不過指定了

Tomcat 類載入器的實現

Tomcat 內部定義了多個 ClassLoader，以便應用和容器訪問不同儲存庫中的類和資源，同時達到應用間類隔離的目的。本文首發於公眾號：頓悟原始碼。 1. Java 類載入機制 類載入就是把編譯生成的 class 檔案，載入到 JVM 記憶體中（永久代/元空間）。 類載入器之所以能實現類隔離，是因為兩個

實戰分析Tomcat的類載入器結構（使用Eclipse MAT驗證）

一、前言 在各種Tomcat相關書籍，書上都提到了其類載入器結構：   在Tomcat 7或者8中，共享類和Catalina類載入器在catalina.properties中都是沒配置的，請看：   所以，catalina和shared是直接把common的類載入器賦值給

還是Tomcat，關於類載入器的趣味實驗

一、前言 類載入器，其實是很複雜一個東西，想等到我完全什麼都弄明白了再寫出來，估計不太現實。。。現在只能是知道多少寫多少吧。 首先，我提一個問題：在我們自己的servlet中（比如ssm中，controller的程式碼），可以訪問 tomcat 安裝目錄下 lib 中的類嗎？（servlet-api.ja

Tomcat原始碼分析 （五）----- Tomcat 類載入器

在研究tomcat 類載入之前，我們複習一下或者說鞏固一下java 預設的類載入器。樓主以前對類載入也是懵懵懂懂，藉此機會，也好好複習一下。 樓主翻開了神書《深入理解Java虛擬機器》第二版，p227, 關於類載入器的部分。請看： 什麼是類載入機制？ Java虛擬機器把描述類的資料從Class檔案載

類載入器在Tomcat中的應用

之前有文章已經介紹過了JVM中的類載入機制，JVM中通過類載入載入class檔案，通過雙親委派模型完成分層載入。實際上類載入機制並不僅僅是在JVM中得以運用，通過影響位元組碼生成和類載入器目前已經有了許多相關的技術誕生。特別的對於進行應用伺服器的開發過程中，類載入機制幾乎是必須掌握的。 為什麼在Tomcat中

java類載入器——ClassLoader

web rac rgb 好的 全盤負責機制 安全 trac 字節 如何 Java的設計初衷是主要面向嵌入式領域，對於自己定義的一些類，考慮使用依需求載入原則。即在程序使用到時才載入類，節省內存消耗，這時就可以通過類載入器來動態載入。 假設你平時僅僅是做web開發，那應該

Java類載入器 ClassLoader的解析

index html dir obj ble body 6.4 odin 普通 //參考 ： http://www.ibm.com/developerworks/cn/java/j-lo-classloader/ 類載入器基本概念 類載

finalkeyword對JVM類載入器的影響

public fin port args stat gpo sys tint () 眾所周知，當訪問一個類的變量或方法的時候。假設沒有初始化該類。就會先去初始化一個類 可是，當這個類的變量為final的時候，就

JAVA類載入器詳解

Java類載入器的作用就是在執行時載入類。Java類載入器基於三個機制：委託、可見性和單一性。委託機制是指將載入一個類的請求交給父類載入器，如果這個父類載入器不能夠找到或者載入這個類，那麼再載入它。可見性的原理是子類的載入器可以看見所有的父類載入器載入的類，而父類載入器看不到子類載入器載入的

1.java類載入器？

Java類載入器ClassLoader總結 JAVA類裝載方式，有兩種: 1.隱式裝載， 程式在執行過程中當碰到通過new 等方式生成物件時，隱式呼叫類裝載器載入對應的類到jvm中。 2.顯式裝載， 通過class.forname()等方法，顯式載入需要的類 類載

sprinbboot 熱部署 造成類載入器 不一致問題

這裡只說devtools的方式，注意以下的熱部署方式在IDEA是預設沒有開啟自動編譯的，手動編譯需要快捷鍵（Ctrl+Shift+F9）， 自動編譯的修改配置如下：(注意重新整理不要太快，會有1-2秒延遲) File-Settings-Compiler-Build Project automatic

Java類載入器(死磕5)

Java類載入器(  CLassLoader )  死磕5:  自定義一個檔案系統classLoader 本小節目錄 5.1. 自定義類載入器的基本流程 5.2. 入門案例：自定義檔案系統類載入器 5.3. 案例的環境配置 5.4 FileClassLoader

Java類載入器( 死磕9)

【正文】Java類載入器(  CLassLoader ) 死磕9:  上下文載入器原理和案例 本小節目錄 9.1. 父載入器不能訪問子載入器的類 9.2. 一個寵物工廠介面 9.3. 一個寵物工廠管理類 9.4 APPClassLoader不能訪問子載入器中的類 9.5. 執行緒上下文

Java類載入器( 死磕7)

【正文】Java類載入器(  CLassLoader )死磕7:  基於加密的自定義網路載入器 本小節目錄 7.1. 加密傳輸Server端的原始碼 7.2. 加密傳輸Client端的原始碼 7.3. 使用亦或實現簡單加密和解密演算法 7. 網路加密SafeClassLoader的原始

Java類載入器( 死磕 4)

【正文】Java類載入器(  CLassLoader ) 死磕 之4:  神祕的雙親委託機制 本小節目錄 4.1. 每個類載入器都有一個parent父載入器 4.2. 類載入器之間的層次關係 4.3. 類的載入次序 4.4 雙親委託機制原理與沙箱機制 4.5. forName