JVM学习（九）--不同的类加载器作用与加载动作分析

Leefs 2019-11-30 PM 5276℃ 2条

# 不同的类加载器作用与加载动作分析

### 前言

本篇讲述JVM中不同的类的加载器作用与加载动作分析，内容讲的有点抽象，小编一时也不知道笔记该怎样整理，还好在网上搜到两篇写的很不错的文章，转载一下

### 实例

![不同的类加载器作用与加载动作分析01.png][1]

类加载器的层次关系

类加载器的父亲委托机制，也叫双亲委托机制，从上到下它们之间是包含关系，也就是系统类加载器中包含用户自定义类加载器

### 代码

这段程序打印出系统类加载器到最上层的加载器的结构关系：

```java
public class MyTest13 {
    public static void main(String[] args) {
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();//获取到系统类加载器
        System.out.println(classLoader);
		//通过循环的方式将其类加载器，到其父类加载器，一直到根类加载器进行打印
        while(null != classLoader){
            classLoader = classLoader.getParent();//返回父类加载器，一些实现可能会用null来代替（为空代表执行到根类加载器或启动类 加载器）
            System.out.println(classLoader);
        }

}
}
```

> 运行结果

```java
sun.misc.Launcher$AppClassLoader@18b4aac2 【系统类加载器】
sun.misc.Launcher$ExtClassLoader@1540e19d  【扩展类加载器】
null                                       【根类加载器】
```

可以看到最后输出的是null.

这行代码： `ClassLoader classLoader = ClassLoader.getSystemClassLoader();`得到系统类加载器。

getSystemClassLoader()：是系统类加载器也是默认我们自定义类加载器的双亲，

看一下doc说明：

```java
/**
     * Returns the system class loader for delegation.  This is the default
     * delegation parent for new <tt>ClassLoader</tt> instances, and is
     * typically the class loader used to start the application.
     *返回一个针对委托的系统类加载器，并且他是默认新建类加载器实例的委托双亲（即自定义类加载器的父级，见上图），它是一个典型的启动应用的类加载器。
     * <p> This method is first invoked early in the runtime's startup
     * sequence, at which point it creates the system class loader and sets it
     * as the context class loader of the invoking <tt>Thread</tt>.
     *此方法在运行期的早期就会被调用，在这个时间点创建系统类的加载器，并且设定其为调用线程的上下文的一个类加载器。
     * <p> The default system class loader is an implementation-dependent
     * instance of this class.
     *默认的系统类加载器与这个类实现相关的实例
     * <p> If the system property "<tt>java.system.class.loader</tt>" is defined
     * when this method is first invoked then the value of that property is
     * taken to be the name of a class that will be returned as the system
     * class loader.  The class is loaded using the default system class loader
     * and must define a public constructor that takes a single parameter of
     * type <tt>ClassLoader</tt> which is used as the delegation parent.  An
     * instance is then created using this constructor with the default system
     * class loader as the parameter.  The resulting class loader is defined
     * to be the system class loader.
     * 如果设定了java.system.class.loader那么这个方法返回的就是java.system.class.loader设定的类加载器。这个类被系统类加载器加载，并且
     * 定义一个公共的构造方法，接受一个ClassLoader参数用作为委托的双亲，用默认系统类类加载器作为构造器的参数，就会创造一个实例 ，所得到的就是系统类加载器
     */
     //返回系统类加载器
@CallerSensitive
public static ClassLoader getSystemClassLoader() {
    initSystemClassLoader();
    if (scl == null) {
        return null;
    }
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkClassLoaderPermission(scl, Reflection.getCallerClass());
    }
    return scl;
}
```

> getParent方法：

```java
/**
     * Returns the parent class loader for delegation. Some implementations may
     * use <tt>null</tt> to represent the bootstrap class loader. This method
     * will return <tt>null</tt> in such implementations if this class loader's
     * parent is the bootstrap class loader.
     * 返回父加载器用于委托，有些实现返回null用来表示根类加载器，如果一个类的父加载器是根加载器，那么这个方法将会返回null
     */
public final ClassLoader getParent() {
    if (parent == null)
        return null;
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        // Check access to the parent class loader
        // If the caller's class loader is same as this class loader,
        // permission check is performed.
        checkClassLoaderPermission(parent, Reflection.getCallerClass());
    }
    return parent;
}
```

> parent 变量是ClassLoader的成员变量：

```java
// The parent class loader for delegation
// Note: VM hardcoded the offset of this field, thus all new fields
// must be added *after* it.
用于委托的双亲加载器，JVM将这个变量的偏移量进行了硬编码，，这样新的变量就要加载这个变量的后边
private final ClassLoader parent;
```

> 下一例子：

如何通过一个给定的字节码的路径来把相应的资源信息打印出来

```java
public class MyTest14 {
    public static void main(String[] args) throws IOException {
        //Thread.currentThread():或取到当前执行的线程一个引用
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();//通常用于启动应用的应用类加载器
        String resourceName = "com/twodragonlake/jvm/classloader/MyTest13.class";//包名
        /*
        Finds all the resources with the given name. A resource is some data
        (images, audio, text, etc) that can be accessed by class code in a way
        that is independent of the location of the code.
        返回给定名字所有的资源，资源可以是（图片，音频，文本，等）可以被class字节码以一种与字节码位置无关的方式去访问，
        classLoader.getResources(resourceName){....}
		*/
        Enumeration<URL> urls =  classLoader.getResources(resourceName);//找到给定名字的所有资源
        while(urls.hasMoreElements()){
            System.out.println(urls.nextElement());
        }

System.out.println("----------------");

Class<?> clazz = String.class;
        System.out.println(clazz.getClassLoader());//自定义的类有系统类加载器加载
        System.out.println("----------------");
        clazz = MyTest14.class;
        System.out.println(clazz.getClassLoader());  //由根类加载器加载 因为系统类加载器的加载目录包含rt目录

}
}
```

> 运行结果

```java
file:/E:/Study/intelIde/jvm_lecture/out/production/classes/com/twodragonlake/jvm/classloader/MyTest13.class
----------------
null
----------------
sun.misc.Launcher$AppClassLoader@18b4aac2
```

> **获取`ClassLoader`的方式**

获得当前类的`ClassLoader`：
`class.getClassLoader()`;
获取当前线程上下文的`ClassLoader`：
`Thread.currentThread().getContextClassLoader();`
获得系统的`ClassLoader`：
`ClassLoader.getSystemClassLoader()`
获得调用者的`ClassLoader`:
`DriverManager.getCallerClassLoader();`

类加载器不是用来加载对象的，是加载和对象对应的类。

class对象对应的是类本身

### 类加载器的双亲委托机制

![不同的类加载器作用与加载动作分析02.png][2]

如果感觉本篇看着还不是太懂可以看下篇博客：[不同的类加载器作用与加载动作分析](https://www.cnblogs.com/webor2006/p/9029910.html)，这篇小编就先不进行复制了。直接点击链接就可以跳到原文。

附：[参考原文1](https://ceaser.wang/2018/10/04/jvm%E5%8E%9F%E7%90%86%EF%BC%888%EF%BC%89%E4%B8%8D%E5%90%8C%E7%9A%84%E7%B1%BB%E5%8A%A0%E8%BD%BD%E5%99%A8%E4%B8%8E%E5%8A%A0%E8%BD%BD%E4%B8%8E%E5%8A%A0%E8%BD%BD%E5%8A%A8%E4%BD%9C%E5%88%86%E6%9E%90/),[参考原文2](https://www.cnblogs.com/webor2006/p/9029910.html)。

[1]: https://lilinchao.com/usr/uploads/2019/12/4152142786.png
  [2]: https://lilinchao.com/usr/uploads/2019/12/4238738204.png

标签: Java, JVM

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/236.html

上一篇持有对象--List

下一篇 JVM学习(十)--ClassLoader源码解析与实例剖析

JVM学习（九）--不同的类加载器作用与加载动作分析

评论已关闭

栏目分类

标签云

友情链接申请

JVM学习（九）--不同的类加载器作用与加载动作分析

评论已关闭

 栏目分类

标签云

友情链接申请

栏目分类

标签云

友情链接申请