JAVA类加载机制

Dreammmming Time

已于 2023-02-18 14:10:01 修改

阅读量235

点赞数 1

分类专栏： JAVA编程文章标签： java jvm 编程语言

于 2020-05-31 16:34:50 首次发布

本文链接：https://blog.csdn.net/u014445499/article/details/106431043

版权

JAVA编程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

JAVA虚拟机会在启动时，通过读取.class文件或.jar文件，来注册各种类及其成员方法、构造函数、成员变量等，下面就类的加载过程简单剖析一下。

一个类加载器public abstract class ClassLoader，是一个用于加载类的对象。它通过给定的二进制名字来为目标类定义尝试分配或生成数据域。一个典型类加载加载策略是，把类名转换成文件名，然后从文件系统中读取一个class文件。

每一个类对象都拥有一个生成此类的类加载器的引用，除了包含原子类型的数据类，因为它不是由ClassLoader生成的，而是由JAVA虚拟机在运行时根据需要自动创建，所以它的引用的NULL。

用户可以通过继承ClassLoader来实现自己的类加载方法，每类加载器实例都有一个父加载器的引用，以便在搜寻某个类或资源时，首先从父类加载器查找，然后是自己定义的路径。JAVA虚拟机有一个内置的类加载器，称bootstrap class loader，它没有父类加载器的引用，但可以作为所有其它类的父引用。

##类加载器的获取

调用Class.class.getClassLoader()，获取加载Class类（系统级的类）的类加载器，它就是启动类加载器；
调用classA.getClass().getClassLoader()，获取加载ClassA类（用户自定义类）的类加载器，它可以是任意的类加载器；
调用Thread.currentThread().getContextClassLoader()，默认返回的是AppClassLoader类加载器。

不同的类装载器，可能同时加载了一个类的数据，因为不同的类有不同的名称空间或路径，这就可能导致JVM中，存在多个类名相同但类路径不同的类，因此我们可以在线程中执行代码时，手动设置运行时的当前类加载器，示例代码如下：

private static Class getClass(String classname)    
                                         throws ClassNotFoundException {
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    
      if(classLoader == null) 
         classLoader = Singleton.class.getClassLoader();   
    
      return (classLoader.loadClass(classname));   
   }   
}

类加载的过程

加载、连接、初始化

类的装载

通过ClassLoader加载系统级别以及第三方的字节码文件，即二进制class文件到内存中的方法区，并创建对应的Class对象（调用defineClass(…)方法），JVM会将这个对象放到内存区中的方法区。

一个Class字节码文件就是对一个类的完整定义，包括了头信息、方法块信息、成员变量信息等。

类的连接

如果一个类能够被被虚拟机接受，需要保证读入的类信息是合法的，因此类的字节数据加载完毕后的第一步，应该是校验
验证：数据格式正确：类的头部信息的检验，如是否符合java规范、版本号是否与当前的JAVA版本兼容等；
元数据信息正确：如是否存在父类，且与父类中定义的成员变量或是方法是否冲突，是否实现了父类中的接口等；
指令合法：通过数据流和控制流分析方法，验证字节码指令是不是合法的，比如访问了未定义的对象时报错；
符号验证：实际正在发生在后面的类解析阶段。
准备：当验证过程通过后，我们可以访问类的各种声明信息了，但是一个类通常会定义一些静态变量或是常量，而这些变量可能被引用，因此在做符号引用解析之前，需要事先为这样的变量分配内存空间，以确保在解析时是这些变量是内存中是存在的，因此这个过程仅仅是将static类型的变量在方法区的静态常量池中分配原始内存空间，并设置对应类型的默认值；

解析：我们知道在JAVA代码中访问某个成员变量或方法时，可以通过使用对应的名字访问之，这种方式能够成功，是因为JAVA编译器在编译代码时，会将这些名字转换成JAVA标准的字符串符号，它们作为这个类的常量信息被保存在常量池中，如果这样的引用是正确的话，我们应该能够在常量池中找到，这就需要对这些符号进行解析，以保证代码中的每一处的引用都是正确的，同时会替换符号引用为直接引用，指向方法区中真正的地址（避免间接访问以加速对象访问），类文件中对于变量的访问都是通过方法名+符号前缀构成的。

类的初始化

在经历的类的加载和链接过程后，想要正常的使用这个类，还需要最后一个步骤，就是执行类中的静态代码块和变量赋值，以保证在构造类的对象之前，静态代码块完成。
为什么必须要在这个点完成这个动作，而不可以是lazy的方式呢？
因为在多线程的环境下，如果我们在访问这个类时才执行这些动作，必然存在并发的问题，既然无论如何都要执行一次静态代码，那么放在类的初始化过程中完成，
虽然会拖慢类的对象的创建，但可以避免复杂的运行时并发的各种问题，自然简单安全。

代码执行流程

当一个类加载器构建对象时，可能会引用到其它的类，因此为了能够定位那些被引用的类，JAVA虚拟机会从当前加载器对象开始递归调用loadClass(...)方法，通过以下的先后次序来解析：

调用findLoadedClass(String)方法，判断依赖的类是否已经当前的类加载器所记录，如果是则返回此类
调用父类的loadClass(String)方法查找
调用当前类加载器的findClass(...)方法查找，有关如何自定义此方法，请参考后面小节

public abstract class ClassLoader {
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
    
    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {...}
}

类的反射

获取类的反射对象有如下几个方法：

实例的.getClass()方法，如classA.getClass()
类的.class变量，如ClassA.class
Class类的forName()方法，如Class.forName(“ClassA”)，Class.forName(“classA”, initialize, classloader)
使用ClassLoader类对象的.loadClass(“ClassA”)

使用类加载器ClassLoader.loadClass(…)方法加载的类，不会执行类的连接过程，只是负责把类的描述数据加载到内存中，因此也不会对类进行初始化；

但使用Class.forName(“ClassA”)方法会触发类的初始化过程，因此在该类中定义的静态成员变量或方法是被正常初始化和执行的；Class.forName(name, initialize, classLoader)方法可以更加灵活，通过initialize参数，控制类的加载过程，如果initialize=true，那么会触发类加载的全过程；如果initialize=false，那么不会触发类加载中的初始化过程！！！

在访问类的final static静态变量（即常量）时，也不会触发类的初始化，因为在编译生成.class文件时，final标注的静态变量已经被确定而且不能再改变，因此优化器一般会在类的连接阶段，直接赋值实际值给这个final变量，这样就不需要再触发类的初始化过程了！！

初始化执行流程

JAVA应用启动时，默认会初始化内置的类加载器，名为Launcher，其核心的构造函数如下代码所示，主要完成了java.ext.dirs和java.class.path指定路径下的类加载的过程，并设置线程的上下文管理器为当前类Thread.currentThread().setContextClassLoader(this.loader)。

  public Launcher() {
    Launcher.ExtClassLoader var1;
    try {
      var1 = Launcher.ExtClassLoader.getExtClassLoader();
    } catch (IOException var10) {
      throw new InternalError("Could not create extension class loader", var10);
    }

    try {
      this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {
      throw new InternalError("Could not create application class loader", var9);
    }

    Thread.currentThread().setContextClassLoader(this.loader);
    String var2 = System.getProperty("java.security.manager");
    ...
    }
  }

类的并发加载

内置的抽象类ClassLoader是支持并发加载类的能力，但其子类必须显示地调用ClassLoader.registerAsParallelCapable(...)以支持迸发加载，尤其是在类加载的过程不是严格地层级结构时，如果不设置为并发加载，则很可能会在类的加载过程中出现死锁。

自定义类加载 Part1

默认下，JAVA虚拟机只会从本地的文件系统来加载类，比如在UNIX平台，从CLASSPATH环境变量设置的路径下搜寻和加载类。但用户可以通过继承ClassLoader抽象类来实现自己的加载过程。

比如有一个构成类的数据文件存放在网络服务器上，我们期望通过远程下载的方式来获取这个文件，然后加载到应用的虚拟环境中，可以参考下面的代码：

 class NetworkClassLoader extends ClassLoader {
 	String host;
 	int port;
 
	public Class findClass(String name) {
		byte[] b = loadClassData(name);
		return defineClass(name, b, 0, b.length);
	}
	
	private byte[] loadClassData(String name) {
		// load the class data from the connection
	}
}

其中defineClass(...)方法是一个ClassLoader内置的方法，它会将构成一个类的所需的数据所组成的字节数组，转换成一个JAVA类。

自定义类 Part2

/**
 * URL class loader that exposes the `addURL` method in URLClassLoader.
 */
public class MutableURLClassLoader extends URLClassLoader {

  static {
    ClassLoader.registerAsParallelCapable();
  }

  public MutableURLClassLoader(URL[] urls, ClassLoader parent) {
    super(urls, parent);
  }

  @Override
  public void addURL(URL url) {
    super.addURL(url);
  }
}

/**
 * A class loader which makes some protected methods in ClassLoader accessible.
 */
public class ParentClassLoader extends ClassLoader {

  static {
    ClassLoader.registerAsParallelCapable();
  }

  public ParentClassLoader(ClassLoader parent) {
    super(parent);
  }

  @Override
  public Class<?> findClass(String name) throws ClassNotFoundException {
    return super.findClass(name);
  }

  @Override
  public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    return super.loadClass(name, resolve);
  }
}

/**
 * A mutable class loader that gives preference to its own URLs over the parent class loader
 * when loading classes and resources.
 */
public class ChildFirstURLClassLoader extends MutableURLClassLoader {

  static {
    ClassLoader.registerAsParallelCapable();
  }

  private ParentClassLoader parent;

  public ChildFirstURLClassLoader(URL[] urls, ClassLoader parent) {
    super(urls, null);
    this.parent = new ParentClassLoader(parent);
  }

  @Override
  public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    try {
      return super.loadClass(name, resolve);
    } catch (ClassNotFoundException cnf) {
      return parent.loadClass(name, resolve);
    }
  }

  @Override
  public Enumeration<URL> getResources(String name) throws IOException {
    ArrayList<URL> urls = Collections.list(super.getResources(name));
    urls.addAll(Collections.list(parent.getResources(name)));
    return Collections.enumeration(urls);
  }

  @Override
  public URL getResource(String name) {
    URL url = super.getResource(name);
    if (url != null) {
      return url;
    } else {
      return parent.getResource(name);
    }
  }
}
/** 优先使用用户指定路径下的类来决定类的引用关系。 **/
public static int main(Strings[] args) {
	MutableURLClassLoader cfcl = new ChildFirstURLClassLoader(new Array[URL](0), Thread.currentThread.getContextClassLoader);
	// List<String> customClassPaths = ["/home/test/a.jar", "/home/testb/b.jar"]
	for (String s : customClassPaths) {
		cfcl.addURL(new File(s).toURI().toURL());
	}
	
}

Dreammmming Time

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA类加载机制

A class loader is an object that is responsible for loading classes. Theclass ClassLoader is an abstract class. Given the <ahref="#name">binary name of a class, a class loader should attempt tolocate or generate data that constitutes a definitio.
复制链接

扫一扫

专栏目录