类加载器的父亲委托机制（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类先后加载了两次。