java 类的加载机制

类加载器

类的加载是由类加载器完成的,类加载器包括:启动类加载器(BootStrap)、扩展类加载器(ExtClassLoader)、应用程序类加载器(AppClassLoader)和自定义类加载器(java.lang.ClassLoader的子类)。
启动类加载器

一般用本地代码实现,负责加载JVM基础核心类库,即 JAVA_HOME\lib 目录下的类。
扩展类加载器

继承自启动类加载器,加载 \lib\ext 下的类,或者被 java.ext.dirs 系统变量指定的类。
应用程序类加载器

继承自扩展类加载器,加载 ClassPath 中的类,或者系统变量 java.class.path 所指定的目录中记载类,是用户自定义加载器的默认父加载器。
自定义类加载器

继承自 ClassLoader 类。

为什么要自定义类加载器

    一方面是由于java代码很容易被反编译,如果需要对自己的代码加密的话,可以对编译后的代码进行加密,然后再通过实现自己的自定义类加载器进行解密,最后再加载。

    另一方面也有可能从非标准的来源加载代码,比如从网络来源,那就需要自己实现一个类加载器,从指定源进行加载。

类加载机制
全盘负责

当一个类加载器负责加载某个 Class 时,该 Class 所依赖的和引用的其他 Class 也将由该类加载器负责载入,除非显式指定另外一个类加载器来载入。
双亲委派模型

如果一个类加载器收到了 Class 加载的请求,它首先不会自己去尝试加载这个 Class ,而是把请求委托给父加载器去完成,依次向上。因此,所有的类加载请求最终都应该被传递到顶层的启动类加载器中,只有当父加载器在它的搜索范围中没有找到所需的 Class 时,即无法完成该加载,子加载器才会尝试自己去加载该 Class 。


这样做的好处是:
1. 避免同一个类被多次加载
2. 安全,Java 核心 API 中定义的类不会被随意替换
3. 每个加载器只能加载自己范围内的类
缓存机制

所有加载过的 Class 都会被缓存,当程序中需要使用某个 Class 时,类加载器先从缓存区寻找该 Class ,只有当缓存区不存在时,系统才会去读取该 Class 对应的二进制数据,并将其转换成 Class 对象,存入缓存区。

这就是为什么修改了 Class 后,必须重启JVM,程序的修改才会生效。
类加载器中的四个重要方法
loadClass(String name, boolean resolve)

protected Class<?> loadClass(String name, boolean resolve)
      throws ClassNotFoundException
  {
      synchronized (getClassLoadingLock(name)) {
          // 先从缓存查找该class对象,找到就不用重新加载
          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) {
                  // 如果都没有找到,则通过自定义实现的findClass去查找并加载
                  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;
      }
  }


流程:
缓存 -> 父类加载器 -> 没有父类 -> 启动类加载器 -> 自己的 findClass() 方法
findClass(String name)

由自己负责加载类的方法。

在自定义类加载器时,需要重写该方法并编写加载规则,取得要加载类的字节码后转换成流,然后调用defineClass()方法生成类的 Class 对象。
defineClass(byte[] b, int off, int len)

将 byte 字节流解析成 JVM 能够识别的 Class 对象。
resolveClass(Class≺?≻ c)

解析 Class 对象,即将字节码文件中的符号引用转换为直接引用。

符号引用与直接引用

    符号引用:即一个字符串,但是这个字符串给出了一些能够唯一性识别一个方法,一个变量,一个类的相关信息。

    直接引用:可以理解为一个内存地址,或者一个偏移量。

    举个例子,现在调用方法 hello(),这个方法的地址是 1234567 ,那么 hello 就是符号引用,1234567 就是直接引用。

类加载过程

类加载分为三个步骤:加载,连接,初始化


加载

根据一个类的全限定名(如 java.lang.String )来读取该类的二进制字节流,解析成 JVM 能够识别的 Class 对象。
连接
验证

确保 Class 文件的字节流中包含信息符合虚拟机要求,不会危害虚拟机的安全。

主要包括四种验证:文件格式验证,元数据验证,字节码验证,符号引用验证。
准备

为类的静态变量分配内存并且设置初始值,这里的初始值指的是不同类型的默认值,如 int 默认值为0,引用的默认值为 null。

而 final 修饰的静态常量,因为 final 在编译的时候就会分配了,所以此时的值为代码中设置的值。

注意

    类的静态变量会分配在方法区中,而实例变量是随着对象一起分配到 Java 堆中。

解析

将常量池内的符号引用替换为直接引用。
初始化

将静态变量和静态方法块按顺序从上到下初始化,即为准备阶段的静态变量重新赋值,设置为代码中指定的值。

执行构造函数。

如果该类具有父类,先初始化父类。
流程图


子类继承父类时的执行顺序



---------------------
作者:路比船长
来源:CSDN
原文:https://blog.csdn.net/u013534071/article/details/80254247
版权声明:本文为博主原创文章,转载请附上博文链接!

posted @ 2019-02-27 12:01  一点点征服  阅读(271)  评论(0编辑  收藏  举报