类装载子系统
在JAVA虚拟机中，负责查找并装载类型的那部分被称为类装载子系统。
JAVA虚拟机有两种类装载器：启动类装载器和用户自定义类装载器。前者是JAVA虚拟机实现的一部分，后者则是Java程序的一部分。由不同的类装载器装载的类将被放在虚拟机内部的不同命名空间中。
类装载器子系统涉及Java虚拟机的其他几个组成部分，以及几个来自java.lang库的类。比如，用户自定义的类装载器是普通的Java对象，它的类必须派生自java.lang.ClassLoader类。ClassLoader中定义的方法为程序提供了访问类装载器机制的接口。此外，对于每一个被装载的类型，JAVA虚拟机都会为它创建一个java.lang.Class类的实例来代表该类型。和所有其他对象一样，用户自定义的类装载器以及Class类的实例都放在内存中的堆区，而装载的类型信息则都位于方法区。
类装载器子系统除了要定位和导入二进制class文件外，还必须负责验证被导入类的正确性，为类变量分配并初始化内存，以及帮助解析符号引用。这些动作必须严格按以下顺序进行：
（1）装载——查找并装载类型的二进制数据。
（2）连接——指向验证、准备、以及解析（可选）。
● 验证 确保被导入类型的正确性。
● 准备 为类变量分配内存，并将其初始化为默认值。
● 解析 把类型中的符号引用转换为直接引用。
（3）初始化——把类变量初始化为正确初始值。
每个JAVA虚拟机实现都必须有一个启动类装载器，它知道怎么装载受信任的类，每个类装载器都有自己的命名空间，其中维护着由它装载的类型，所以一个Java程序可以多次装载具有同一个全限定名的多个类型，这样一个类型的全限定名就不足以确定在一个Java虚拟机中的唯一性。因此，当多个类装载器都装载了同名的类型时，为了惟一地标识该类型，还要在类型名称前加上装载该类型（指出它所位于的命名空间）的类装载器标识。位于不同命名空间的相同类无法相互转换，下面程序演示了这一点：
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream; public class MyClass extends ClassLoader{ private String name;//类加载器的名称 private String path;//加载类的路径 private final String extendName = ".class";//文件扩展名 public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getPath() {
return path;
} public void setPath(String path) {
this.path = path;
} public String getExtendName() {
return extendName;
} public MyClass(String name){
super();
this.name = this.name;
} public MyClass(ClassLoader parent,String name){
super(parent);
this.name=name;
} @Override
public String toString() {
return this.name;
} @Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] bytes = this.loadDate(name);
return this.defineClass(name, bytes, 0, bytes.length);
} public byte[] loadDate(String name){
String filename = name.replace(".", "\\");
String filepath = this.path+filename+this.extendName;
File file = new File(filepath);
InputStream in = null;
ByteArrayOutputStream out = null;
byte[] bytes = null;
try {
in = new FileInputStream(file);
int len = 0;
out = new ByteArrayOutputStream();
while((len=in.read())!=-1){
out.write(len);
}
bytes=out.toByteArray();
return bytes;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
in.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
} public static void main(String[] args) {
MyClass loader1 = new MyClass("loader1");
loader1.setPath("E:\\test\\loader1");
MyClass loader2 = new MyClass(loader1,"loader2");
loader2.setPath("E:\\test\\loader2"); MyClass loader3 = new MyClass(null,"loader3");
loader3.setPath("E:\\test\\loader3\\");
test(loader1);
test(loader2);
test(loader3); try{
Class classzz = loader3.loadClass("Sample");
Object object = classzz.newInstance();
Sample sample = (Sample)object;
System.out.println(sample.toString());
}catch(Exception e){
e.printStackTrace();
}
} public static void test(ClassLoader loader){
try{
Class classzz = loader.loadClass("Sample");
Object object = classzz.newInstance();
}catch(Exception e){
e.printStackTrace();
}
}
}
public class Sample {
public Sample(){
System.out.println("i am Sample......,加载我的类加载器的名称是："+this.getClass().getClassLoader().toString());
new Person();
}
}
public class Person {
public Person(){
System.out.println("i am person......,加载我的类加载器的名称是："+this.getClass().getClassLoader().toString());
}
}
上面程序通过继承ClassLoader，实现自定义类加载器，在主方法中，创建三个自定义类加载器，其中loader2的父类加载器为loader1，loader3的父类加载器为根类加载器，在E盘下创建三条路径，分别为E:\\test\\loader1，E:\\test\\loader2，E:\\test\\loader3，将三段程序的.class文件分别放置在三个文件夹内，通过DOS命令切换到该目录下，首先运行命令：java MyClass，结果如下：
E:\test\loader1>java MyClass
i am sample......,加载我的类加载器的名称是：sun.misc.Launcher$AppClassLoader@39443f
i am person......,加载我的类加载器的名称是：sun.misc.Launcher$AppClassLoader@39443f
i am sample......,加载我的类加载器的名称是：sun.misc.Launcher$AppClassLoader@39443f
i am person......,加载我的类加载器的名称是：sun.misc.Launcher$AppClassLoader@39443f
i am sample......,加载我的类加载器的名称是：loader3
i am person......,加载我的类加载器的名称是：loader3
从结果可以看出，test1,test2均为系统类加载加载所需要类，对于test3,加载所需类的类加载器为自定义类加载器MyClass，可以肯出虚拟机在加载类的过程中使用父类委托机制，loader3的父类为根类加载器，在JDK中找不到自定义类Sample，所以只能靠自定义类加载器加载该类，对于该自定义类加载器加载的类则位于自己命名空间下，其他明明空间下无法调用，可以通过修改上述程序进行验证，
//package com.swust.自定义类加载器; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream; public class MyClass extends ClassLoader{ private String name;//类加载器的名称 private String path;//加载类的路径 private final String extendName = ".class";//文件扩展名 public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getPath() {
return path;
} public void setPath(String path) {
this.path = path;
} public String getExtendName() {
return extendName;
} public MyClass(String name){
super();
this.name = this.name;
} public MyClass(ClassLoader parent,String name){
super(parent);
this.name=name;
} @Override
public String toString() {
return this.name;
} @Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] bytes = this.loadDate(name);
return this.defineClass(name, bytes, 0, bytes.length);
} public byte[] loadDate(String name){
String filename = name.replace(".", "\\");
String filepath = this.path+filename+this.extendName;
File file = new File(filepath);
InputStream in = null;
ByteArrayOutputStream out = null;
byte[] bytes = null;
try {
in = new FileInputStream(file);
int len = 0;
out = new ByteArrayOutputStream();
while((len=in.read())!=-1){
out.write(len);
}
bytes=out.toByteArray();
return bytes;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
in.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
} public static void main(String[] args) {
MyClass loader1 = new MyClass("loader1");
loader1.setPath("E:\\test\\loader1\\");
MyClass loader2 = new MyClass(loader1,"loader2");
loader2.setPath("E:\\test\\loader2\\"); MyClass loader3 = new MyClass(null,"loader3");
loader3.setPath("E:\\test\\loader3\\");
// test(loader1);
// test(loader2);
// test(loader3); try{
Class classzz = loader3.loadClass("Sample");
Class classess = loader1.loadClass("Sample");
Object object = classzz.newInstance();
Object object1 = classess.newInstance();
System.out.println("由不同类加载器加载的类类型是否可以转换："+(object==object1));
// Sample sample = (Sample)object;
// System.out.println(sample.toString());
}catch(Exception e){
e.printStackTrace();
}
} public static void test(ClassLoader loader){
try{
Class classzz = loader.loadClass("Sample");
Object object = classzz.newInstance();
}catch(Exception e){
e.printStackTrace();
}
}
}
执行结果如下：
E:\test\loader1>java -cp .;E:\test\loader3 MyClass
i am sample......,加载我的类加载器的名称是：loader3
i am person......,加载我的类加载器的名称是：loader3
i am sample......,加载我的类加载器的名称是：sun.misc.Launcher$AppClassLoader@39443f
i am person......,加载我的类加载器的名称是：sun.misc.Launcher$AppClassLoader@39443f
由不同类加载器加载的类类型是否可以转换：false
从结果可以看出，由不同类加载器加载的同一类无法相互引用，虽然都是相同的类Sample，但由于他们位于不同的命名空间中，但新建实例却不是同一对象，这样做也保证了类的唯一性