类加载器的父亲委托机制(Parent Delegation)
类加载器用来把类加载到java虚拟机中。从JDK1.2开始,类的加载过程采用父亲委托机制。这种机制能更好的保证java平台的安全。在此委托机制中,除了Java虚拟机自带的根类加载器以外,其余的类加载器都有且只有一个父加载器。当Java程序请求加载器loader1加载Sample类时,loader1首先委托自己的父加载器去加载Sample类,若父加载器能加载,则由父加载器完成加载任务,否则才由加载器loader1本身加载Sample类。
1、类加载器
父子加载器并非继承关系,,也就是说子加载器不一定是继承了父加载器。
除了以上虚拟机自带的加载器以外,用户还可以定制自己的类加载器(User-defined Class Loader)。Java提供了抽象类java.lang.ClassLoader,所有用户自定义的类加载器都应该继承ClassLoader类
在父亲委托机制中,各个加载器按照父子关系形成了树形结构,除了根加载器以外,其他加载器有且只有一个父加载器。
若有一个类加载器能成功加载Sample类,那么这个类加载器被称为定义类加载器,所有能成功返回Class对象的引用的类加载器(包括定义类加载器)都被称为初始类加载器。
定义类加载器:如果某个类加载器能够加载一个类,那么该类加载器就称作:定义类加载器;定义类加载器及其所有子加载器都称作:初始类加载器。
当生成一个自定义的类加载器实例时,如果没有指定它的父加载器,那么系统类加载器就将成为该类加载器的父加载器
2、命名空间
每个类加载器都有自己的命名空间,命名空间由该类加载器及所有父加载器所加载的类组成。在同一个命名空间中,不会出现类的完整名字(包括类的包名)相同的两个类;在不同的命名空间中,有可能会出现类的完整名字(包括类的包名)相同的两个类。
3、运行时包
由同一类加载器加载的属于相同包的类组成了运行时包。决定两个类是不是属于同一个运行时包,不仅要看他们的包名是否相同,还要看定义类加载器是否相同。只有属于同一运行时包的类才能互相访问包可见(即默认访问级别)的类和类成员。这样的限制能避免用户自定义的类冒充核心类库的类,去访问核心类库的包可见成员。假设用户自己定义了一个类java.lang.Spy,并由用户自定义的类加载器加载,由于java.lang.Spy和核心类库java.lang.*由不同的加载器加载,它们属于不同的运行时包,所以java.lang.Spy不能访问核心类库java.lang包中的包可见成员。
4、创建用户自定义的类加载器
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";
public MyClassLoader(String name)
{
super();
this.name = name;
}
public MyClassLoader(ClassLoader parent,String name)
{
super(parent);
this.name = name;
}
@Override
public String toString()
{
return this.name;
}
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 getFileType()
{
return fileType;
}
protected Class<?> findClass(String name) throws ClassNotFoundException
{
byte[] data = this.loadClassData(name);
return this.defineClass(name, data, 0,data.length);
}
private byte[] loadClassData(String name)
{
InputStream is = null;
byte[] data = null;
ByteArrayOutputStream baos = null;
try
{
this.name = this.name.replace(".", "\\");
is = new FileInputStream(new File(path + name + fileType));
baos = new ByteArrayOutputStream();
int ch = 0;
while(-1 !=(ch = is.read()))
{
baos.write(ch);
}
data = baos.toByteArray();
} catch (Exception e)
{
e.printStackTrace();
}finally
{
try
{
is.close();
baos.close();
}catch(Exception e)
{
e.printStackTrace();
}
}
return data;
}
public static void main(String[] args) throws Exception
{
MyClassLoader loader1 = new MyClassLoader("loader1");
loader1.setPath("d:\\myapp\\serverlib\\");
MyClassLoader loader2 = new MyClassLoader(loader1,"loader2");
loader2.setPath("d:\\myapp\\clientlib\\");
MyClassLoader loader3 = new MyClassLoader(null,"loader3");
loader3.setPath("d:\\myapp\\otherlib\\");
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 v1 = 1;
public Sample()
{
System.out.println("Sample is load by :" + this.getClass().getClassLoader());
new Dog();
}
}
public class Dog
{
public Dog()
{
System.out.println("dog is load by :"+ this.getClass().getClassLoader());
}
}
实验环境:在d盘建有一目录myapp,在其下有四个子目录:syslib、serverlib、clientlib、otherlib,将MyClassLoader.class拷贝到syslib下,将Dog.class和Sample.class两个文件同时拷贝到serverlib和otherlib目录下。
在命令窗口,进入syslib目录,执行java MyClassLoader 输出结果为:
D:\myapp\syslib>java MyClassLoader
Sample is load by :loader1
dog is load by :loader1
Sample is load by :loader3
dog is load by :loader3
分析:
在MyClassLoader中定义了三个变量:loader1、loader2、loader3,代表三个类加载器,他们的父子关系如上图。
loader1的父加载器是loader2,loader2的父加载器是系统加载器,loader3的父加载器是根加载器。
执行test(loader2)时,就是使用加载器loader2来加载Sample类,loader2先查看有无父加载器,有则使用父加载器加载,其父加载器执行相同的操作,找父加载器,在使用父加载器加载,直到没有父加载器时,就用自身加载,如果无法加载,用其子类加载,这里就是loader2调用其父类加载器loader1,loader1调用系统加载器,一直到根加载器,根加载器没有父类,就尝试自己加载,因为在其目录中(sun.boot.class.path所定义目录)没有所请求的类(Sample),就返回给其子类加载,即扩展类加载器,也没有(其目录java.ext.dirs 或jre\lib\ext目录),使用系统类加载器(其目录为环境变量classpath定义或系统属性java.class.path)这里classpath为“.”即当前目录,所以也加载失败,然后调用loader1进行加载,loader1的目录从程序中可以看到为d:\myapp\serverlib\,这里面正好有Sample类,所以加载成功,定义类加载器就为loader1,加载成功后,生成Sample对象,调用了new Dog(),属于对类的主动使用,也进行类的加载,默认使用调用者的定义类加载器即loader1,然后如上述步骤执行加载(即也执行父亲委托机制加载),最后由loader1加载成功。
test(loader3)先用根加载器加载,不成功由loader3加载,loader3的目录为d:\myapp\otherlib,其中有Sample和Dog,加载成功。
如果将serverlib中的Dog.class移至syslib目录,则结果:
D:\myapp\syslib>java MyClassLoader
Sample is load by :loader1
dog is load by :sun.misc.Launcher$AppClassLoader@42e816
Sample is load by :loader3
dog is load by :loader3
因为加载Dog时,syslib为当前目录,即“.”,是系统类加载器的路径,所以系统类加载器加载加载Dog成功。
恢复原来的文件位置,使用java -cp .;d:\myapp\serverlib MyClassLoader ,结果如下
D:\myapp\syslib>java -cp .;d:\myapp\serverlib MyClassLoader
Sample is load by :sun.misc.Launcher$AppClassLoader@addbf1
dog is load by :sun.misc.Launcher$AppClassLoader@addbf1
Sample is load by :loader3
dog is load by :loader3
java的cp选项就是设定classpath路径,这里设置为“.;d:\myapp\serverlib“,即系统类加载器的路径,所以对于loader2来说,系统类加载器先加载Sample和Dog成功
5、加载完成后的内存映像关系
同一个类被加载了两次,loader1加载一次,loader3加载一次。因为是不同的加载器,且不是父子关系,是不同的命名空间,相互不能访问。
6、不同类加载器的命名空间关系
同一个命名空间内的类是互相可见的;子加载器的命名空间包含所有父加载器的命名空间,因此由子加载器加载的类能看见父加载器加载的类,例如系统类加载器加载的类能看见根类加载器加载的类;由父加载器加载的类不能看见子加载器加载的类;如果两个加载器之间没有直接或间接的父子关系,那么他们各自加载的类相互不可见。
对MyClassLoader进行部分修改:
public static void main(String[] args) throws Exception
{
MyClassLoader loader1 = new MyClassLoader("loader1");
loader1.setPath("d:\\myapp\\serverlib\\");
MyClassLoader loader2 = new MyClassLoader(loader1,"loader2");
loader2.setPath("d:\\myapp\\clientlib\\");
// MyClassLoader loader3 = new MyClassLoader(null,"loader3");
// loader3.setPath("d:\\myapp\\otherlib\\");
// test(loader2);
// test(loader3);
Class clazz = loader1.loadClass("Sample");
Object object = clazz.newInstance(); //创建一个Sample类对象
Sample sample = (Sample)object;
System.out.println(sample.v1);
}
运行结果出异常:
D:\myapp\syslib>java MyClassLoader
Sample is load by :loader1
dog is load by :loader1
Exception in thread "main" java.lang.NoClassDefFoundError: Sample
at MyClassLoader.main(MyClassLoader.java:103)
Caused by: java.lang.ClassNotFoundException: Sample
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
... 1 more
错误103就是 Sample sample = (Sample)object;这一行;
MyClassLoader类由系统类加载器加载,而Sample类由loader1类加载器加载,因此MyClassLoader类看不见Sample类。在MyClassLoader的main方法中使用Sample类,会导致NoClassDefFoundError错误。当两个不同命名空间内的类互相不可见时,可采用java的反射机制来访问对方实例的属性和方法。如下
使用反射来访问sample对象的v1属性:
public static void main(String[] args) throws Exception
{
MyClassLoader loader1 = new MyClassLoader("loader1");
loader1.setPath("d:\\myapp\\serverlib\\");
MyClassLoader loader2 = new MyClassLoader(loader1,"loader2");
loader2.setPath("d:\\myapp\\clientlib\\");
// MyClassLoader loader3 = new MyClassLoader(null,"loader3");
// loader3.setPath("d:\\myapp\\otherlib\\");
// test(loader2);
// test(loader3);
// Class clazz = loader1.loadClass("Sample");
// Object object = clazz.newInstance(); //创建一个Sample类对象
//
// Sample sample = (Sample)object;
// System.out.println(sample.v1);
Class clazz = loader1.loadClass("Sample");
Object object = clazz.newInstance();
Field field = clazz.getField("v1");
int v1 = field.getInt(object);
System.out.println(v1);
}
7、类的卸载
当Sample类被加载、连接和初始化后,他的生命周期就开始了。当代表Sample类的Class对象不再被引用,即不可触及时,Class对象就会结束生命周期,Sample类在方法区内的数据也会被卸载,从而结束Sample类的生命周期。由此可见,一个类何时结束生命周期,取决于代表他的Class对象何时结束生命周期。
由java虚拟机自带的类加载器所加载的类,在虚拟机的生命周期中,始终不会被卸载,java虚拟机自带的类加载器包括根类加载器、扩展类加载器和系统类加载器。java虚拟机本身会始终引用这些类加载器,而这些类加载器则会始终引用它们所加载的类的Class对象,因此这些Class对象始终是可触及的。
修改MyClassLoader的main()方法:
public static void main(String[] args) throws Exception
{
MyClassLoader loader1 = new MyClassLoader("loader1");
loader1.setPath("d:\\myapp\\serverlib\\");
MyClassLoader loader2 = new MyClassLoader(loader1,"loader2");
loader2.setPath("d:\\myapp\\clientlib\\");
MyClassLoader loader3 = new MyClassLoader(null,"loader3");
loader3.setPath("d:\\myapp\\otherlib\\");
// test(loader2);
// test(loader3);
Class objClass = loader1.loadClass("Sample");
System.out.println(objClass.hashCode());
Object obj = objClass.newInstance();
loader1 = null;
objClass = null;
obj = null;
loader1 = new MyClassLoader("loader1");
loader1.setPath("d:\\myapp\\serverlib\\");
objClass = loader1.loadClass("Sample");
System.out.println(objClass.hashCode());
}
打印的结果显示两个不同的hashcode值
运行以上程序,Sample类由loader1加载。在类加载器的内部实现中,用一个java集合来存放所加载类的引用。另一方面,一个Class对象总是会引用他的类加载器,调用Class对象的getClassLoader()方法,就能获得他的类加载器。由此可见,代表Sample类的Class实例与loader1之间为双向关联关系。
一个类的实例总是引用代表这个类的Class对象。在Object类中定义了getClass()方法,这个方法返回代表对象所属类的Class对象的引用。此外,所有的Java类都有一个静态属性class,他引用代表这个类的Class对象,例如:
到第一次object生成后,引用变量与对象之间的引用关系如图:
从上图,loader1变量和obj变量间接引用代表Sample类的Class对象,而objClass变量则直接引用他。当所有变量都置为null,此时Sample对象结束生命周期,MyClassLoader对象结束生命周期,代表Sample类的Class对象也结束生命周期,Sample类在方法区内的二进制数据被卸载。当程序往下执行时,Sample类又重新被加载,在Java虚拟机的堆区会生成一个新的代表Sample类的Class实例。
程序结果两次打印的hashcode值不同,因此objClass变量两次引用不同的Class对象,可见在Java虚拟机的生命周期中,对Sample类先后加载了两次。
转载自:http://blog.csdn.net/kaoa000/article/details/8513135
参考:http://www.itjhwd.com/javaclassloaderq/