Java 基础加强 - 类加载器

客官°小女子只卖身不卖艺 2022-10-10 00:45 222阅读 0赞

**Java类加载器**

**一. 定义**

**定义:**类加载器是用来将Java类字节码加载到内存中的加载工具。细节描述:类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个Java.lang.class对象，用来封装类在方法区内的数据结构。

![20130918225704046][]

**二.Java虚拟机与程序的声明周期**

在如下几种情况下，Java虚拟机将结束生命周期:

1. 执行了System.exit()方法。

2. 程序正常执行结束。

3. 程序在执行过程中遇到异常或错误导致异常行终止。

4. 由于操作系统出现错误导致Java虚拟机终止。

**三. 类的加载、连接与初始化**

1. **加载:**查找并加载类的二进制数据。(从硬盘à内存)

**2. 连接:**

A. **验证:** 确保被加载的类的正确性。

B. **准备:**为类的静态变量分配内存，并将其初始化为默认值。

C. **解析:**把类中的符号引用转换为直接引用。

3. **初始化:** 为类中的静态变量赋予正确初始化。(用户赋的值)

![20130918225815578][]

**四. Java程序对类的使用方式及初始化步骤**

**1. 主动使用(6种)**

A. 创建类的实例

B. 访问某个类或接口的静态变量，或者对该静态变量赋值。

C. 调用类的静态方法。

D. 反射(如Class.forName(“com.myclass.Test”))

E. 初始化一个类的子类

F. Java虚拟机启动时候被表明为启动类的类。

**注意:**调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。

**2. 被动使用**

除了主动使用的6种情况，其他使用java类的方式都被看做是对类的被动使用，都不会导致类的初始化。

所有的Java虚拟机实现必须在每个类或接口被Java程序“首次主动使用”时才初始化他们。

**3. 类的初始化步骤**

A. 假如这个类还没有被加载和连接，那就先进行加载和连接

B. 假如这个类存在直接的父类，并且这个父类还没有被初始化，那就先初始化直接父类

C. 假如类中存在初始化语句，那就依次执行这些初始化语句

**注意:**当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用与接口，在初始化一个类时，并不会先初始化它所实现的接口;在初始化一个接口时，并不会先初始化他的接口。因此，一个接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口静态变量时候，才会导致该接口初始化。

**五. 加载.class文件的方式(类加载的方式)**

1. 从本地系统中直接加载

2. 通过网络加载.class文件

3. 从Zip,jar等归档文件中加载.class文件

4. 从专有数据库中提取.class文件

5. 将Java源文件动态编译为.calss文件

**六.两种类型的类加载器**

Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。

**1. Java虚拟机自带的加载器**

**A. 根类加载器(Bootstrap)**

该加载器没有父加载器。它负责加载虚拟机的核心类库，如java.lang.\*等。根类加载器从系统属性sun.boot.class.path所指定的目录中加载类库。根类加载器的实现依赖于底层操作系统，属于虚拟机的实现的一部分，它并没有继承java.lang.ClassLoader类，这个类加载器是使用C++编写的，我们是无法看到。

**B. 扩展类加载器(Extension Class Loader)**

它的父加载器为根类加载器。它从java.ext.dirs系统属性所指定的目录中加载类库，或者从JDK的安装目录的jre\\lib\\ext子目录(扩展目录)下载类库，如果把用户创建的JAR文件放在这个目录下，也会自动有扩展类加载器加载。扩展类加载器是纯Java语言编写的类，是java.lang.ClassLoader类的子类。

**C. 系统类加载器(AppClassLoader)**

也称为应用类加载器，它的父加载器为扩展类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中就爱在类，它是用户自定义的类加载器的默认父加载器。系统类加载器是纯Java语言编写的类，是java.lang.ClassLoader类的子类。

**2. 用户自定义的类加载器**

用户自定义的类加载器必须继承ClassLoader抽象类，继承ClassLoader类时候使用父类构造方法为自定义的这个加载器指定一个父加载器，如果不指定，**则将默认将系统类加载器作为其父加载器**。

System.out.println(ClassLoaderDemo1.class.getClassLoader().getClass()
    				.getName());
    		ClassLoader loader = ClassLoaderDemo1.class.getClassLoader();
    		while(loader != null)
    		{
    			   System.out.println(loader.getClass().getName());
    			   loader = loader.getParent(); 
    	}

打印结果:

sun.misc.Launcher$AppClassLoader

sun.misc.Launcher$ExtClassLoader

null

**七. 类加载器之间父子关系和管辖范围图**

![20130918230030437][]

**八. 类加载器的父类委托机制**

1. **定义:**在父亲委托机种中，各个加载器你找父子关系形成树形结构，除了 根类加载器以外，其余的类加载器都有且只有一个父加载器。每个ClassLoader本身只能分别加载特定位置和目录中的类，但它们可以委托其他的类加载器去加载类，这就是类加载器的委托模式。

2. **作用:** 从JDK1.2版本开始，类的加载过程采用父类委托机制，这种机制能更好的保证Java平台的安全。父亲委托机制提高软件系统的安全性，在此机制下，用户自定义的类加载器不可能加载应该由父亲加载器加载的可靠类，从而防止不可靠甚至恶意的代码代替由父类加载器加载可靠代码，例如，java.lang.Object类总是由根类加载器加载，其他任何用户自定义的类加载器都不可能加载含有恶意代码的java.lang.Object，防止了恶意代码对虚拟机的攻击。

**3. 委托方式和委托过程**

假如现在有两个自定义类加载器，loader1和loader2，loader2的父加载器为loader1，现在想要loader2 去加载一个叫Sample的类，那么首先loader2从自己的命名空间中查找Sample类是否已经被加载，如果已经加载，就直接返回代表Sample类的Class对象的引用。

如果Sample类没有被加载，loader2首先委托给父类加载器loader1，loader1再委托给系统类加载器，系统类加载器再委托给扩展类加载器，扩展类加载器又委托给根类加载器查找加载，如果根类加载器不能加载，那么就开始回退，再往下回推给每一层的子加载器加载，直到会退到请求发起者，即loader2，如果连loader2本身都不能加载，就报ClassNotFoundException异常。

**注意:**

**当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？**

A. 首先当前线程的类加载器去加载线程中的第一个类。如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。

B. 还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

**九. 自定义类加载器**

1. 自定义的类加载器必须继承抽象类ClassLoader，必须覆盖其中的findClass(String name)方法，而不用覆盖loadClass(String name)方法。

**2. 覆盖findClass(String name)方法的原因:**

A. 在类加载器内部，loadClass()首先会去委托父加载器，一层一层往上委托，当最顶级的父加载器找不到无法加载后，再逐层往下调，如果还是无法找到，最后才去调用findClass(String name)方法，也就是自己定义类加载器去查找加载。所以只要覆盖findClass(String name)即可，就能实现用自己的类加载器加载类的目的。

B. 其实findClass(String name)是一个抽象方法，它会在我们调用loaderClass(String name)方法时候回调findClass(String name)这个方法，是一个典型的模版方法设计模式，这样就保留了loaderClass(String nane)方法中的流程(这个流程就是使用递归的方式，往上逐层委托父类优先加载，找不到再往下逐层回退查找加载)，因为每一个用户自定义的类加载器findClass(String name)的细节可能都不一样，不确定，所以用模版方法最合适的。

**3. 自定义类加载器内部委托加载细节流程**

A. 调用**loadClass(String name)**à

B. **loadClass(Stringname)**内部再调用**loadClass(String name, booleanresolve)**方法à

C. **loadClass(Stringname, boolean resolve)**方法内部会调用**Classc = findLoadedClass(name)**;检查要加载的类是够已经被加载，如果已经存在就直接返回**return c**，JVM 规范规定ClassLoader可以在缓存保留它所加载的Class，如果一个Class已经被加载过，则直接从缓存中获取。如果不存在，即**c==null**，就去判断它是否有父类**(parent!= null)**，如果有就递归**loadClass(name, false);**方法一层一层往上委托父加载器去加载，如果最顶层的父加载器都不能加载，就再逐层往下回调加载，能加载的话就直接返回，如果最终还是不能，就调用**findClass(String name)**去加载à

D. **如果parent == null**的话，就直接使用根加载器去加载该类。

package cn.itheima.demo;  
    	  
    	import java.util.Date;  
    	//定义一个测试类，继承Date，便于使用时加载  
    	public class ClassLoaderAttachment extends Date{  
    	    //复写toString方法  
    	    public String toString(){  
    	        return "Hello World!";  
    	    }  
    	}  
    	  
    	import java.io.ByteArrayOutputStream;  
    	import java.io.FileInputStream;  
    	import java.io.FileOutputStream;  
    	import java.io.InputStream;  
    	import java.io.OutputStream;  
    	  
    	public class MyClassLoader extends ClassLoader{  
    	  
    	    public static void main(String[] args) throws Exception {  
    	        String srcPath=args[0];//文件源  
    	        String destDir=args[1];//文件目的  
    	        InputStream ips=new FileInputStream(srcPath);  
    	        String destFileName=srcPath.substring(srcPath.lastIndexOf("\\")+1);  
    	        String destFilePath=destDir+"\\"+destFileName;  
    	        OutputStream ops=new FileOutputStream(destFilePath);  
    	        cypher(ips,ops);//加密class字节码  
    	        ips.close();  
    	        ops.close();  
    	    }  
    	    //加密方法  
    	    private static void cypher(InputStream ips,OutputStream ops) throws Exception{  
    	        int b=-1;  
    	        while((b=ips.read())!=-1){  
    	            ops.write(b^0xff);  
    	        }  
    	    }  
    	  
    	    @Override  
    	    //覆盖ClassLoader的findClass方法  
    	    protected Class<?> findClass(String name) throws ClassNotFoundException {  
    	        name=name.substring(name.lastIndexOf(".")+1);  
    	        String classFileName=classDir+"\\"+name+".class";//获取class文件名  
    	        InputStream ips=null;  
    	        try {  
    	            ips=new FileInputStream(classFileName);  
    	            ByteArrayOutputStream bos=new ByteArrayOutputStream();//定义字节数组流  
    	            cypher(ips,bos);//解密  
    	            ips.close();  
    	            byte[] buf=bos.toByteArray();//取出字节数组流中的数据  
    	            return defineClass(null, buf,0,buf.length);//加载进内存  
    	              
    	        } catch (Exception e) {  
    	            // TODO: handle exception  
    	            e.printStackTrace();  
    	        }  
    	        return null;  
    	        //return super.findClass(name);  
    	    }  
    	      
    	    private String classDir;  
    	    public MyClassLoader(){}  
    	    //带参数的构造函数  
    	    public MyClassLoader(String classDir){  
    	        this.classDir=classDir;  
    	    }  
    	  
    	}  
    	  
    	import java.util.Date;  
    	  
    	public class ClassLoaderDemo {  
    	  
    	    public static void main(String[] args) throws Exception {  
    	        //将用自定义的类加载器加载.class文件  
    	        Class clazz=new MyClassLoader("itheimalib").loadClass("cn.itheima.demo.ClassLoaderAttachment");  
    	        Date d1 =  (Date)clazz.newInstance();//获取Class类的实例对象  
    	        System.out.println(d1);  
    	    }  
    	}

练习2

public class Dog
    {
    public Dog()
    {
    System.out.println("Dog is loaded by : " + this.getClass().getClassLoader());
    }
    }
    
    public class Sample
    {
    public int v1 = 1;
    
    public Sample()
    {
    System.out.println("Sample is loaded by: " + this.getClass().getClassLoader());
    
    new Dog();
    }
    }
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStream;
    public class MyClassLoader2 extends ClassLoader
    {
    private String name ;
    private String path= "d:\\";
    public MyClassLoader2(String name)
    {
    super(); 
    this.name = name;
    }
    public MyClassLoader2(ClassLoader parent , String name)
    {
    super(parent);
    this.name = name;
    }
    public String getName()
    {
    return name;
    }
    public String getPath()
    {
    return path;
    }
    public void setPath(String path)
    {
    this.path = path;
    }
    public String toString()
    {
    return this.name;
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException
    {
    byte[] date = this.loadClassDate(name);
    return this.defineClass(name , date , 0 ,date.length);
    }
    public byte[] loadClassDate(String name)
    {
    InputStream is = null;
    ByteArrayOutputStream baos = null;
    byte[] date = null;
    try
    {
    baos = new ByteArrayOutputStream();
    is = new FileInputStream(new File(this.path + name+ ".class"));
    int b = 0;
    while( (b = is.read()) != -1)
    {
    baos.write(b);
    }
    date = baos.toByteArray();
    } 
    catch (Exception e)
    {
    e.printStackTrace();
    }
    finally
    {
    
    try
    {
    is.close();
    baos.close();
    }
    catch(Exception e)
    {
    e.printStackTrace();
    } 
    }
    return date; 
    } 
    public static void main(String args[])throws Exception
    {
    MyClassLoader2 loader1 = new MyClassLoader2("Loader1");
    MyClassLoader2 loader2 = new MyClassLoader2(loader1,"Loader2");
    MyClassLoader2 loader3 = new MyClassLoader2(null,"Loader3");
    
    loader1.setPath("d:\\javatest\\lib1\\");
    loader2.setPath("d:\\javatest\\lib2\\");
    loader3.setPath("d:\\javatest\\lib3\\");
    test(loader1);
    test(loader2);
    test(loader3);
    }
    public static void test(ClassLoader loader) throws Exception
    {
    loader.loadClass("Sample").newInstance();
    } 
    }

**十. 面试题补充**

问: 可不可以自己写个类为：java.lang.System呢？

回答:

第一. 通常是不可以的，由于类加载器的委托机制，会先将System这个类一级级委托给最顶级的BootStrap，由于BootStrap在其指定的目录中加载的是rt.jar中的类，且其中有System这个类，那么就会直接加载自己目录中的，也就是Java已经定义好的System这个类，而不会加载自定义的这个System。

第二. 但是还是有办法加载这个自定义的System类的，此时就不能交给上级加载了，需要用自定义的类加载器加载，这就需要有特殊的写法才能去加载这个自定义的System类的。

[20130918225704046]: /images/20221005/6287f7be3bca47c996746439a8c84afc.png
[20130918225815578]: /images/20221005/4489f65056a8440d9601dcb30bc8ee3c.png
[20130918230030437]: /images/20221005/59508873eaa64745aadb3143810c8b3a.png