Java ClassLoader 和热加载

最新推荐文章于 2022-09-14 14:57:52 发布

NPPPNHHH

最新推荐文章于 2022-09-14 14:57:52 发布

阅读量694

点赞数 1

分类专栏： Java

Java 专栏收录该内容

49 篇文章 0 订阅

订阅专栏

热加载：对jvm方法区中类定义进行替换，因为堆(heap)中的Class对象是对方法区对象的封装，所以可以理解为对Class对象的替换，
当一个class被替换后，系统无需重启，替换的类会立即生效。

类加载
类的加载过程
- 装载：查找并加载类的二进制数据；
- 链接：
  - 验证：确保被加载类的正确性；
    - 验证阶段是链接阶段的第一步，目的就是确保class文件的字节流中包含的信息符合虚拟机的要求，不能危害虚拟机自身安全。验证阶段主要包括四个检验过程：文件格式验证、元数据验证、字节码验证和符号引用验证。
    - 文件格式验证
      验证class文件格式规范
    - 元数据验证
      就是对字节码描述的信息进行语义分析，保证描述的信息符合java语言规范。验证点可能包括（这个类是否有父类（除Object）、这个类是否继承了不允许被继承的类（final修饰的）、如果这个类的父类是抽象类，是否实现了父类或接口中要求实现的方法）。
    - 字节码验证
      进行数据流和控制流分析，这个阶段对类的方法体进行校验，保证被校验的方法在运行时不会做出危害虚拟机的行为。
    - 符号引用验证
      符号引用中通过字符串描述的权限定名是否能找到对应的类、符号引用类中的类，字段和方法的访问性（private protected public default）是否能被当前类访问。
  - 准备：为类的静态变量分配内存，并将其初始化为默认值；
    这个阶段就是为类变量分配内存并设置类变量初始值的阶段，这些内存将在方法区中进行分配。要注意的是，进行分配内存的只是包括类变量，而不包括实例变量，实例变量是在对象实例化时随着对象一起分配在java堆中的。通常情况下，初始值为零值，假设public static int value=2;那么value在准备阶段过后的初始值为0，不为2，这时候只是开辟了内存空间，并没有运行java代码，value赋值为2的指令是程序被编译后，存放于类构造器<init>()方法之中，所以value被赋值为2是在初始化阶段才会执行。对于一些特殊情况，如果类字段属性表中存在ConstantValue属性，那在准备阶段变量value就会被初始化为ContstantValue属性所指的值，那么对于上面value,编译时javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue将value设置为2
  - 解析：解析阶段是虚拟机常量池的符号引用替换为直接引用的过程。
    - 符号引用：符号引用是一组符号来描述所引用的对象，符号可以是任何形式的字面量，只要使用时能定位到目标即可，符号引用与虚拟机实现的内存布局无关，引用的目标对象并不一定已经加载到内存中。
    - 直接引用：直接引用可以是直接指向目标对象的指针、相对偏移量或是一个能间接定位到目标的句柄（一种特殊的智能指针）。直接引用是与虚拟机内存布局实现相关，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同，如果有了直接引用，那引用的目标必定存在内存中。
    - 解析过程主要针对类或接口、字段、类方法、接口方法四类符号引用进行。
- 初始化：为类的静态变量赋予正确的初始值；
  - 类的初始化阶段是加载过程的最后一步，在准备阶段，类变量已赋过一次系统要求的初始值，而在初始化阶段，则是根据程序员通过程序制定的主观计划去初始化类变量和其他资源，或者可以从另外一个角度表达：初始化阶段是执行类构造器<init>()方法的过程。在以下四种情况下初始化过程会被触发执行：
  - 遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，如果类没有进行过初始化，则需先触发其初始化。生成这4条指令的最常见的java代码场景是：使用new关键字实例化对象、读取或设置一个类的静态字段(被final修饰、已在编译器把结果放入常量池的静态字段除外)的时候，以及调用类的静态方法的时候。
  - 使用java.lang.reflect包的方法对类进行反射调用的时候。
  - 当初始化一个类的时候，如果发现其父类还没有进行过初始化、则需要先出发其父类的初始化。
  - jvm启动时，用户指定一个执行的主类(包含main方法的那个类)，虚拟机会先初始化这个类。
  - 类构造器<init>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句快可以赋值，但是不能访问。
  - 类构造器<init>()方法与类的构造函数(实例构造函数<init>()方法)不同，它不需要显式调用父类构造，虚拟机会保证在子类<init>()方法执行之前，父类的<init>()方法已经执行完毕。因此在虚拟机中的第一个执行的<init>()方法的类肯定是java.lang.Object。
  - 由于父类的<init>()方法先执行，也就意味着父类中定义的静态语句快要优先于子类的变量赋值操作。
  - <init>()方法对于类或接口来说并不是必须的，如果一个类中没有静态语句，也没有变量赋值的操作，那么编译器可以不为这个类生成<init>()方法。
  - 接口中不能使用静态语句块，但接口与类不太能够的是，执行接口的<init>()方法不需要先执行父接口的<init>()方法。只有当父接口中定义的变量被使用时，父接口才会被初始化。另外，接口的实现类在初始化时也一样不会执行接口的<init>()方法。
  - 虚拟机会保证一个类的<init>()方法在多线程环境中被正确加锁和同步，如果多个线程同时去初始化一个类，那么只会有一个线程执行这个类的<init>()方法，其他线程都需要阻塞等待，直到活动线程执行<init>()方法完毕。如果一个类的<init>()方法中有耗时很长的操作，那就可能造成多个进程阻塞。
- 准备阶段和初始化阶段看似有点牟盾，其实是不牟盾的，
  如果类中有语句：private static int a = 10，
  它的执行过程是这样的:首先字节码文件被加载到内存后，
  先进行链接的验证这一步骤，验证通过后准备阶段，
  给a分配内存，因为变量a是static的，
  所以此时a等于int类型的默认初始值0，
  即a=0,然后到解析，到初始化这一步骤时，
  才把a的真正的值10赋给a,此时a=10。
- 加载（装载）、验证、准备、初始化和卸载这五个阶段顺序是固定的，类加载过程必须按照这种顺序开始，而解析阶段不一定，它在某些情况下可以在初始化之后再开始，这是为了运行时动态绑定特性（JIT例如接口只在调用的时候才知道具体的实现的是哪个子类）。值得注意的是：这些阶段通常都是交叉的混合式进行的，通常会在一个阶段执行的过程中调用或激活另一个阶段。
类加载器
JVM设计者把类加载阶段中的通过类全名来获取此类的二进制字节流这个动作放到java虚拟机外部去实现，以便让应用程序决定如何获取所需要的类。实现这个动作的代码模块成为“类加载器”。
类与类加载器
对于任何一个类，都需要由加载它的类加载器和这个类来确定其在JVM中的唯一性。也就是说，两个类来源于同一个Class文件，并且被同一个类加载器加载，这两个类才相等。
双亲委派模型
- 从虚拟机的角度来说，有两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader）,该加载器使用C++语言实现，属于虚拟机自身的一部分。另一部分就是所有其它的类加载器，这些类加载器是由Java语言实现，独立于JVM外部，并且全部继承抽象类java.lang.ClassLoader.
- 从java开发人员的角度看，大部分java程序会用到以下三种系统提供的类加载器：
  - 启动类加载器（Bootstrap ClassLoader）:负责加载JAVA_HOME\lib目录中并且能被虚拟机识别的类库加载到JVM内存中，如果名称不符合的类库即使在lib目录中也不会被加载。该类加载器无法被java程序直接引用。
  - 扩展类加载器(Extension ClassLoader):该加载器主要负责加载JAVA_HOME\lib\ext目录中的类库，开发者可以使用扩展加载器。
  - 应用程序类加载器（Application ClassLoader）:该列加载器也称为系统加载器，它负责加载用户类路径(Classpath)上所指定的类库，开发者可以直接使用该类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。
  - 当然除了以上三种类加载器，我们还能自己定义类加载器。这些类加载器之间的关系如下。
  - 类和类加载器
  - 上面的这种模型，就称为类加载器的双亲委派模型。该模型要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器。子类加载器不是以继承的关系来实现，而是通过组合关系来复用父加载器的代码。
  - 双亲委派模型的工作过程为：如果一个类加载器收到了类请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父加载器去完成，每一层都是如此，因此所有类加载的请求都会传到启动类加载器，只有当父加载器无法完成该请求时，子加载器才去自己加载。
    双亲委派模型的好处就是java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如：Object,无论那个类加载器去加载该类，最终都是由启动类加载器进行加载的，因此Object类在程序的各种类加载环境中都是一个类。如果不用改模型，那么java.lang.Object类存放在classpath中，那么系统中就会出现多个Object类，程序变得很混乱。
  - 一般来说，这四种类加载器会形成一种父子关系，高层为低层的父加载器。在类进行加载时，
    首先会自底向上挨个检查是否已经加载了指定类，如果已经加载，则直接返回该类的引用。
    如果到最高层也没有找到加载过指定类，那么会自顶向下挨个尝试加载，直到用户自定义类加载器，
    如果还不能成功，就会抛出异常。
    
    是否已经加载和尝试加载
  - 类加载java.lang.ClassLoader类中，有一个loadClass方法源码如下：
```
 protected synchronized Class loadClass(String name, boolean resolve)
    throws ClassNotFoundException {
// 首先检查该name指定的class是否有被加载
Class c = findLoadedClass(name);
if (c == null) {
    try {
        if (parent != null) {
            // 如果parent不为null，则调用parent的loadClass进行加载
            c = parent.loadClass(name, false);
        } else {
            // parent为null，则调用BootstrapClassLoader进行加载
            c = findBootstrapClass0(name);
        }
    } catch (ClassNotFoundException e) {
        // 如果仍然无法加载成功，则调用自身的findClass进行加载
        c = findClass(name);
    }
}
if (resolve) {
    resolveClass(c);
}
  return c;
}
```
  - 从源代码中，我们不难看出，先检查是否已经加载，如果没有，就调用父加载器的loadClass()方法，如果父加载器为空则默认使用启动类加载器作为父加载器。如果父加载器加载失败，抛出ClassNotFountException，然后再调用findClass()方法加载。

自定义类加载器

若要实现自定义类加载器，只需要继承java.lang.ClassLoader类，并且重写findClass()方法即可。 java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称，找到或者生成对应的字节码，然后从这些字节码中定义出一个Java类，即java.lang.Class类的一个实例。除此之外，ClassLoader还负责加载Java应用所需的资源，如图像文件和配置文件等，热替换也是基于该类，来绕过Java类的既定加载过程
ClassLoader中与加载类相关的方法如下：

方法                                说明

findLoadedClass()：该方法会在对应加载器的名字空间中寻找指定的类是否已存在，如果存在就返回给类的引用，
否则就返回null。每个类加载器都维护有自己的一份已加载类名字空间，其中不能出现两个同名的类。
凡是通过该类加载器加载的类，无论是直接的还是间接的，都保存在自己的名字空间中，这里的直接是指，
存在于该类加载器的加载路径上并由该加载器完成加载，间接是指，由该类加载器把类的加载工作委托给其他类加载器完成类的实际加载。

getSystemClassLoader()：该方法返回系统使用的ClassLoader。可以在
自定义的类加载器中通过该方法把一部分工作转交给系统类加载器去处理。

defineClass()：该方法接收以字节数组表示的类字节码，并把它转换成Class实例。
系统自带的ClassLoader，默认加载程序的是AppClassLoader，
ClassLoader加载一个class，最终调用的是defineClass(…)方法，
这时候就在想是否可以重复调用defineClass(…)方法加载同一个类(或者修改过)，
最后发现调用多次的话会有相关错误:
java.lang.LinkageError
attempted duplicate class definition
所以一个class被一个ClassLoader实例加载过的话，
就不能再被这个ClassLoader实例再次加载(这里的加载指的是，调用了defileClass(...)方法，
重新加载字节码、解析、验证)。而系统默认的AppClassLoader加载器，
他们内部会缓存加载过的class，重新加载的话，就直接取缓存。
所以对于热加载的话，只能重新创建一个ClassLoader，然后再去加载已经被加载过的class文件。

loadClass()：加载类的入口方法，调用该方法完成类的显式加载。通过对该方法的重写，
可以完全控制和管理类的加载过程。执行loadClass方法，只是单纯的把类加载到内存，
并不是对类的主动使用，不会引起类的初始化。
该方法转换一个类的同时，会先要求装载该类的父类以及实现的接口类。是ClassLoader的入口点。
当一个类没有指明用什么加载器加载的时候，JVM默认采用AppClassLoader加载器
加载没有加载过的class，调用的方法的入口就是loadClass(…)。
如果一个class被自定义的ClassLoader加载，
那么JVM也会调用这个自定义的ClassLoader.loadClass(…)
方法来加载class内部引用的一些别的class文件。重载这个方法，
能实现自定义加载class的方式，会抛弃双亲委托机制，但是即使不采  用双亲委托机制，
比如java.lang包中的相关类还是不能自定义一个同名的类来代替，主要因为JVM解析、
验证class的时候，会进行相关判断。


resolveClass()：链接一个指定的类。这是一个在某些情况下确保类可用的必要方法。

总结
- 要想实现同一个类的不同版本的共存，那么这些不同版本必须由不同的类加载器进行加载，因此就不能把这些类的加载工作委托给系统加载器来完成，因为它们只有一份。
- 为了做到这一点，就不能采用系统默认的类加载器委托规则，也就是说我们定制的类加载器的父加载器必须设置为null。

补充资料:关于类加载器的命名空间
- 命名空间由加载器和所有的父加载器所加载的类构成；
- 在同一个命名空间中，不可能出现类名相同的两个类；
- 在不同的命名空间中，可能出现类名相同的两个类（类名指类全称）；
- 由子加载器加载的类能看见父加载器加载的类，反之不可以；（比如java.lang.String类，我们自己写的类肯定能看见，但是父加载器肯定看不见我们自己定义的类）
- 如果两个加载器之间没有直接或者间接的父子关系，那么两个加载器加载的类是相互不可见的；

自定义ClassLoader

CustomClassLoader

  package com.coding.classloader;
  
  import org.apache.log4j.Logger;
  
  import java.io.*;
  import java.lang.reflect.Method;
  import java.net.URL;
  import java.util.HashSet;
  import java.util.Timer;
  import java.util.TimerTask;
  
  public class CustomClassLoader extends ClassLoader {
  
      private Logger logger = Logger.getLogger(CustomClassLoader.class);
      private String basedir; // 需要该类加载器直接加载的类文件的基目录
      private HashSet classNames; // 需要由该类加载器直接加载的类名
  
      public CustomClassLoader(String basedir, String[] clazzNames) throws Exception {
          super(null); // 指定父类加载器为 null
          this.basedir = basedir;
  
          classNames = new HashSet();
          for (int i = 0; i < clazzNames.length; i++) {
              String name = clazzNames[i];
  
  
              StringBuffer sb = new StringBuffer(basedir);
              String className = name.contains(".") ? name.replace('.', File.separatorChar)+ ".class" : name+ ".class";
              sb.append(className);
  
  
              logger.debug("Load Class: baseDir:" + basedir + ",ClassName:" + name + ",Class file path:" + sb.toString());
  
              File classF = new File(sb.toString());
              FileInputStream fin = new FileInputStream(classF);
              byte[] raw = new byte[(int) classF.length()];
              fin.read(raw);
              fin.close();
  
              defineClass(name, raw, 0, raw.length);
  
  
              classNames.add(clazzNames[i]);
          }
      }
  
      @Override
      protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
          Class cls = null;
          cls = findLoadedClass(name);
          if (!this.classNames.contains(name) && cls == null)
              cls = getSystemClassLoader().loadClass(name);
          if (cls == null)
              throw new ClassNotFoundException(name);
          if (resolve)
              resolveClass(cls);
          return cls;
      }
  
  
      public static void main(String[] args){
          new Timer().schedule(new TimerTask() {
  
              @Override
              public void run() {
                  try {
  
                      URL resource = CustomClassLoader.class.getResource("/");
                      String resourceFile = resource.getFile();
                      System.out.println(resourceFile);
                      // 每次都创建出一个新的类加载器
                      CustomClassLoader customClassLoader = new CustomClassLoader(
                              resourceFile, new String[] { "com.coding.classloader.Foo" });
                      Class<?> cls = customClassLoader.loadClass("com.coding.classloader.Foo");
  
  
  //                    ClassLoader classLoader1 = cls.getClassLoader();//com.coding.classloader.CustomClassLoader
  //                    Class<?> cls2 = Class.forName("com.coding.classloader.Foo");
  //                    ClassLoader classLoader = cls2.getClassLoader();//sun.misc.Launcher$AppClassLoader
  //                    System.out.println(classLoader+":"+classLoader1);
  
                      Object foo = cls.newInstance();
  
                      Method m = foo.getClass().getMethod("sayHi", new Class[] {});
                      m.invoke(foo, new Object[] {});
                  } catch (Exception ex) {
                      ex.printStackTrace();
                  }
              }
          }, 0, 1000L);
      }
  
  
  }

尝试热加载的类

package com.coding.classloader;

public class Foo  {
      public void sayHi() {
          System.out.println("hi\t v1");
      }
}

测试
- 运行main方法,此时sayHi方法打印出hi v1
- 修改sayHi方法，使之打印出hi v2，重新编译，
- 生成新class，覆盖旧的class，立马生效，打印h1 v2

NPPPNHHH

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录