java lib 哪个加载器_java类加载器

以下内容，是本人学习的笔记和工作中的总结，仅供大家参考，有误的地方还请指正

一 类加载器

JVM提供了三类加载器

根类加载器Bootstrap

使用C++编写，程序员无法在java代码中获得该类

没有父加载器

并没有继承java.lang.ClassLoader

负责加载虚拟机的核心类库，如java.lang.*等

如果一个类是用根类加载器加载的，那么通过Class对象getClassLoader()得到的值为null，比如java.lang.String类

扩展加载器(Extension)，使用java代码实现

使用java代码实现，继承java.lang.ClassLoader(java类继承关系)

父加载器是根类加载器

它从java.ext.dirs系统属性所指定的目录中加载类库，或从jdk的安装目录jre/lib/ext扩展目录中加载类库

系统加载器(应用加载器)Syetem，

使用java代码实现，继承java.lang.ClassLoader(java类继承关系)

父加载器是扩展加载器

从环境变量classpath或者系统属性java.class.path所指定的目录中加载类

通过ClassLoader.getSystemClassLoader()获取

是应用程序运行时的类加载器

用户自定义的类加载器的默认父加载器

定义类加载器概念：如果某个加载器能够加载一个类，那么该加载器称作 定义类加载器；定义类加载器及其所有子加载器都被称作 初始类加载器。

注意：扩展加载器的父加载器是根类加载器，这种父子关系不是java类继承关系。而是加载器之间的包装关系

可以从ClassLoader源码看出加载器之间的包装关系：this.parent = parent;

private ClassLoader(Void unused, ClassLoader parent) {

this.parent = parent;

if (ParallelLoaders.isRegistered(this.getClass())) {

parallelLockMap = new ConcurrentHashMap<>();

package2certs = new ConcurrentHashMap<>();

domains =Collections.synchronizedSet(new HashSet());

assertionLock = new Object();

} else {

// no finer-grained lock; lock on the classloader instance

parallelLockMap = null;

package2certs = new Hashtable<>();

domains = new HashSet<>();

assertionLock = this;

}

}

//自定义的加载器，继承ClassLoader

ClassLoader loader1 = new MyClassLoader();

//给loader2指定父加载器，参数loader1将作为loader2的父加载器

ClassLoader loader2 = new MyClassLoader(loader1);

//如果不指定父加载器，则默认父加载器是系统加载器

ClassLoader loader2 = new MyClassLoader();

二 父委托机制

父亲委托机制是为了确保java平台软件系统的安全性。

在此机制中，除了java虚拟机自带的根类加载器没有父加载器以外，其余的类加载器都有且只有一个父加载器。

当java程序请求加载器loader1加载Sample类时，loader1首先委托自己的父加载器去加载，如果父加载器还有父加载器，继续向上委托。

如果有某个父加载器能加载Sample类，则由父加载器完成，否则才由自己本身加载Sample类，加载完成会将Sample类对应的Class对象的引用返回给loader1。

如果都加载不了，最后才由loader1加载。

三 运行时包

由 同一类加载器 加载的属于 相同包 的类组成了 运行时包。

决定了两个类是不是属于同一个运行时包，不仅要看包名，还要看 定义类加载器是否相同。

只有属于 同一运行时包 的 类 才能互相访问 包可见(default) 的类和类成员。

这样做是为了避免用户自定义的类冒充核心类库的类，去访问核心类库的包可见成员。

用户自定义了一个类 java.lang.Spy, 并由用户自定义的类加载器加载，虽然java.lang.Spy类和核心类库java.lang.* 中的类包名相同，但是他们的类加载器却不同，java.lang.Spy类加载器是系统加载器，核心类库java.lang.* 的加载器是根类加载器，所以java.lang.Spy类和核心类库java.lang.* 中的类属性不同的运行时包，所以java.lang.Spy不能访问核心类库java.lang.* 中的包可见成员，保证了安全性。

四 自定义加载器

用户自定义的加载器都是java.lang.ClassLoader的子类，默认父加载器是系统加载器

继承java.lang.ClassLoader

只需要覆盖findClass(String name)方法

findClass方法会找到类的位置

findClass返回该类对应的Class对象的引用，再由loadClass方法加载类

示例1

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

public class MyClassLoader extends ClassLoader {

private String name;//类加载器的名字

private String path = "d:/"; // 加载的类的路劲

private final String fileType = ".class";//class文件的扩展名

public MyClassLoader(String name) {

super(); // 让系统类加载器成为该加载器的父加载器

this.name = name;

}

public void setPath(String path) {

this.path = path;

}

@Override

public String toString() {

return this.name;

}

public MyClassLoader(ClassLoader parent, String name) {

super(parent); // 显示指定父加载器

this.name = name;

}

@Override

public Class> findClass(String name) {

byte[] data = loadClassData(name);

if(data == null){

return null;

}

return this.defineClass(name, data, 0, data.length);

}

//java建议这样去加载class文件二进制字节码

private byte[] loadClassData(String name) {

InputStream is = null;

ByteArrayOutputStream bos = null;

byte[] data = null;

try {

name = name.substring(name.lastIndexOf(".") + 1, name.length());

is = new FileInputStream(new File(path + name + fileType));

bos = new ByteArrayOutputStream();

int ch = 0;

while (-1 != (ch = is.read())) {

bos.write(ch);

}

data = bos.toByteArray();

} catch (Exception ex) {

ex.printStackTrace();

} finally {

try {

is.close();

bos.close();

} catch (Exception ex) {

ex.printStackTrace();

}

}

return data;

}

public static void main(String[] args) throws Exception {

//不显示执行父加载器，那么loader1的父加载器是系统类加载器

MyClassLoader loader1 = new MyClassLoader("loader1");

loader1.setPath("D:\\myapp\\serverlib\\");//此目录有Smaple、Dog class文件

//loader2的父加载器是loader1

MyClassLoader loader2 = new MyClassLoader(loader1, "loader2");

loader2.setPath("D:\\myapp\\clientlib\\");//此目录无Smaple、Dog class文件

//父加载设置为null, 那么loader3父载器就是根类加载器

MyClassLoader loader3 = new MyClassLoader(null, "loader3");

loader3.setPath("D:\\myapp\\otherlib\\");//此目录有Smaple、Dog class文件

test(loader2);

test(loader3);

}

public static void test(ClassLoader loader) throws Exception {

Class> clazz = loader.loadClass("Sample");

Object object = clazz.newInstance();

}

}

public class Sample {

public int a = 1;

public Sample(){

System.out.println("Smaple is loaded by " + this.getClass().getClassLoader());

new Dog();

}

}

public class Dog {

public int b = 1;

public Dog(){

System.out.println("Dog is loaded by " + this.getClass().getClassLoader());

}

}

1.执行java -cp .;D:\myapp\serverlib\ MyClassLoader，-cp参数：增加classpath路径，输出结果：

Smaple is loaded by sun.misc.Launcher$AppClassLoader@18b4aac2 //系统加载器

Dog is loaded by sun.misc.Launcher$AppClassLoader@18b4aac2 //系统加载器

Smaple is loaded by loader3

Dog is loaded by loader3

解析：

(1)loader2向上父委托，根类加载器无法加载Smaple、Dog，扩展加载器无法加载Smaple、Dog，系统加载器是加载classpath中的类，由于java命令中将类的路径增加到了classpath中，所以由系统加载器加载Smaple、Dog

(2)系统加载器是Smaple、Dog类的定义类加载器；系统类加载器、loader1、loader2加载器都是Smaple、Dog类的初始类加载器

(3)loader3向上父委托，根类加载器无法加载Smaple、Dog，所以由loader3自己加载，loader3加载器是Smaple、Dog类的定义类加载器和初始类加载器

2.执行java MyClassLoader，输出结果：

Smaple is loaded by loader1

Dog is loaded by loader1

Smaple is loaded by loader3

Dog is loaded by loader3

解析：

(1)loader2向上父委托，根类加载器无法加载Smaple、Dog，扩展加载器无法加载Smaple、Dog，由于没有增加类路径到classpath中，所以系统加载器无法加载Smaple、Dog，而loader1加载目录中有Smaple、Dog class文件，所以loader1可以加载

(2)虽然loader2加载器加载目录中没有Smaple、Dog class文件，但是已经由loader1加载了

五 类加载器的命名空间

同一个命名空间内的类是相互可以见的

子加载器的命名空间包含所有父加载器的命名空间。因此由子加载器加载的类能看见父加载器加载的类。

例如 系统类加载器加载的类能看见根类加载器加载的类。

由父加载器加载的类不能看见子加载器加载的类。

如果两个加载器之间没有直接或间接的父子关系，那么它们各自加载的类相互不可见

当两个不同命令空间内的类互相不可见时，可采用java反射机制来访问其他命令空间中的类的实例的属性和方法

示例2

把示例1中main方法中的代码改为：

public static void main(String[] args) throws Exception {

//loader1的父加载器是系统类加载器

MyClassLoader loader1 = new MyClassLoader("loader1");

loader1.setPath("D:\\myapp\\serverlib\\");

Class> clazz = loader1.loadClass("Sample");

Object object = clazz.newInstance();

Sample Sample = (Sample) object;

System.out.println(Sample.a);

/**

* 反射

Class> clazz = loader1.loadClass("Sample");

Object object = clazz.newInstance();

Field field = clazz.getField("a");

int a = field.getInt(object);

System.out.println(a);

*/

}

执行java MyClassLoader，输出结果：

Smaple is loaded by loader1

Dog is loaded by loader1

Exception in thread "main" java.lang.NoClassDefFoundError: Sample

at MyClassLoader.main

也就是这一句出错了：Sample Sample = (Sample) object;

解析：

MyClassLoader类是由系统类加载的，而Sample类是由loader1类加载的，父加载器加载的类不能看见子加载器加载的类，因此MyClassLoader类看不见Sample类，所以在MyClassLoader类中的main方法中使用Sample类会导致上面错误。

示例3

把上面示例1中的main方法中的注释做如下更改

public static void main(String[] args) throws Exception {

//不显示执行父加载器，那么loader1的父加载器是系统类加载器

MyClassLoader loader1 = new MyClassLoader("loader1");

loader1.setPath("D:\\myapp\\serverlib\\");//此目录有Smaple class文件，没有Dog文件

//loader2的父加载器是loader1

MyClassLoader loader2 = new MyClassLoader(loader1, "loader2");

loader2.setPath("D:\\myapp\\clientlib\\");//此目录只有Dog class文件

test(loader2);

}

执行java MyClassLoader，输出结果：

Smaple is loaded by loader1

Exception in thread "main" java.lang.NoClassDefFoundError: Dog

为什么输出结果不是

Smaple is loaded by loader1

Dogis loaded by loader2

解析：

loader2父委托loader1了，loader1加载目录里面有Sample类，没有Dog类，所以loader1只加载了Sample类，loader2加载目录有Dog类，Dog类应该由loader2自己加载，为什么会报错了呢？

其实Dog类已经被loader2加载，只是没有输出Dog is loaded by loader2这一句而已。因为父加载器加载的类看不到子加载器加载的类的问题，所以在Sample的构造方法里面使用Dog类时就已经报错了，代码不会在往下执行了。

六 类的卸载

1 ClassLoader、Class对象、类的实例之间的关系

ClassLoader对象 里面的集合存放着所有它加载的 类对应的 Class对象

Class对象通过getClassLoader()可以获得 加载类 的ClassLoader对象，Class对象指向 对应的类 在方法区中的 二进制数据结构

类的实例可以通过getClass()方法获取 类对应的 Class对象

2 类的生命周期

由java虚拟机自带的类加载器加载的类，在java虚拟机的生命周期内，始终不会被卸载。

java虚拟机自带的类加载器包括 根类加载器、扩展类加载器、系统类加载器。

java虚拟机本身会始终引用这些类加载器，而这些类加载器则会始终引用他们所加载的类的Class对象，因此这些Class对象始终是被引用着的。

用户自定义的类加载器加载的类是可以被卸载的。

当Sample类被加载、连接、初始化后，它的生命周期就开始了。

当代表Sample类的Class对象不再被引用，Class对象就会结束生命周期，Sample类的方法区内的数据也会被卸载，从而结束Sample类的生命周期。

由此可见，一个类何时结束生命周期，取决于代表这个类的Class对象何时结束生命周期。

以上内容，是本人学习的笔记和工作中的总结，仅供大家参考，有误的地方还请指正