JavaEE学习之类加载器

类装载子系统

　　在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:	estloader1>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:	estloader1>java -cp .;E:	estloader3 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，但由于他们位于不同的命名空间中，但新建实例却不是同一对象，这样做也保证了类的唯一性