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