java jvm类加载器－父亲委托机制实例分析

类加载器的父亲委托机制（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/