1.类加载全过程

• 为什么研究类加载全过程

  • 有助于了解JVM运行过程

  • 更深入了解java动态性(热部署,动态加载),提高程序的灵活性

• 类加载机制

  • JVM把class文件加载到内存,并对数据进行校验,解析和初始化,最终形成JVM可以直接使用的java类型的全过程

    加载-->链接(验证,准备,解析)-->初始化-->使用-->卸载

  • 加载

    将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区中运行时结构,在堆中生产一个代表这个类的java.lang.Class对象,作为方法区类数据的访问入口,这个过程需要类加载器参与

    字节码可以是本地的也可以是从网络获取的,数据库获取的,等等

  • 链接

    • 验证

      确保加载的类信息符合JVM规范,没有安全方面的问题

    • 准备

      正式为类变量(static变量)分配内存并设置类变量初始化的阶段,这些内存都将在方法区中进行分配(赋的是默认值,真正赋你定义的值在初始化阶段)

    • 解析

      虚拟机常量池内的符号引用替换为直接引用的过程(比如类名,方法名,变量名,类的代码,字符串常量等)

  • 初始化

    初始化阶段是执行类构造器\<clinit>()方法的过程,类构造器\<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生的

    当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先初始化其父类

    虚拟机会保证一个类的\<clinit>()方法在多线程环境中被正确加锁和同步

    当访问一个java类的静态域(变量)的时候,只有真正声明这个域的类才会被初始化

• 类的主动引用(一定会发生类的初始化)

  • new一个类的对象

  • 调用类的静态成员(除了final常量)和静态方法

  • 使用java.lang.reflect包的方法对类进行反射调用

  • 当虚拟机启动,一定会初始化main方法所在的类

  • 当初始化一个类,如果其父类没有被初始化,则会先初始化它的父类

• 类的被动引用(不会发生类的初始化)

  • 当访问一个静态域时,只有真正声明这个域的类才会被初始化

  • 通过子类引用父类的静变量,不会导致子类初始化

  • 通过数组定义类引用,不会触发此类的初始化

  • 引用常量不会触发此类的初始化(常量在编译阶段存入调用类的常量池中了)

Demo:

public class Demo01{

    public static void main(String[] args)throws Exception{
        //主动引用
        A a = new A();
        System.out.println(A.width);
        Class.forName("A");
        //被动调用
        System.out.println(A.MAX);
        A[] as = new A[10];
        System.out.println(B.width)
    }
}

class B extends A{
    static{
        System.out.println("静态初始化B类");
    }
}

class A extends A_Father{
    public static int width = 100;
    public static final int MAX = 100;

    static{
        System.out.println("静态初始化A类");
        width = 300;
    }

    public A(){
        System.out.println("创建A类的对象");
    }

}

class A_Father{
    static{
        System.out.println("静态初始化A_Father");
    }
}

2.类加载器作用

• 类加载器的作用

  将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区中的运行时数据结构,在堆中生成一个代表这个类的java.lang.Class对象,作为方法区类数据的访问入口

• 类缓存

  标准的Java SE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间.不过JVM垃圾收集器可以回收这些Class对象

3.java.classClassLoader类介绍

• 作用

  java.class.ClassLoader类的基本职责就是根据一个指定的类的名称,找到或者生产其对应的字节代码,然后从这些字节代码中定义出一个Java类,即java.lang.Class类的一个实例

  除此之外ClassLoader还负责加载Java应用所需的资源,如图像文件和配置文件等

• 相关方法

  getParent() 返回该类加载器的父类加载器

  loadClass(String name) 加载名称为name的类,返回结果是java.lang.Class类的实例

  findClass(String name) 查找名称为name的类,没找到则加载,返回的结果是java.lang.Class类的实例

  findLoadedClass(String name) 查找名称为name已经被加载的类,返回的结果是java.lang.Class类的实例

  defineClass(String name,byte[] b,int off,int len) 把字节数组b中的内容转换成Java类,返回的结果是java.lang.Class类的实例,这个方法被声明为final的

  resolveClass(Class<?> c) 链接指定的Java类

  对于以上给出的方法,表示类名的name参数的值是类的二进制名称.需要注意的是内部类的表示

4.类加载器的层次结构(树状结构)

• 引导类加载器(bootstart class loader)

  它用来加载Java的核心库(JAVA_HOME/jre/lib/rt.jar或sun.boot.class.path路径内容),是用原生代码(C++)来实现的,并不继承自java.lang.ClassLoader

  加载扩展类和应用程序类加载器.并指定他们的父类加载器

• 扩展类加载器(extensions class loader)

  用来加载Java的扩展库(JAVA_HOME/jre/ext/*.jar或java.ext.dirs路径下的内容)Java虚拟机的实现会提供一个扩展库目录.该类加载器在此目录里面查找并加载Java类

  由sun.misc.Launcher$ExtClassLoader实现

• 应用程序类加载器(application class loader)

  它根据Java应用的类路径(classpath,java.class.path路径)一般来说Java应用的类都是由它来完成加载的

  由sun.misc.Launcher$APPClassLoader实现

• 自定义类加载器

  开发人员可以通过继承java.lang.ClassLoader类的方式实现自己的类加载器,以满足一些特殊的需求

5.类加载器的代理模式

• 代理模式

  交给其他加载器来加载指定的类

• 双亲委托机制

  某个特定的类加载器在接到类的请求时,首先将加载任务委托给父类加载器,依次追溯,直到最高的爷爷辈的,如果父类加载器可以完成类加载任务,就返回成功.只有父类加载器无法完成此加载任务时,自己才去加载

  双亲委托机制是为了保证Java核心库的类型安全,这种机制是为了保证不会出现用户自己能定义java.lang.Object类的情况

  类加载器除了用于加载类,也是安全的最基本的屏障

  双亲委托机制是代理模式的一种,并不是所有的类加载器都采用双亲委托机制,tomcat服务器类加载器也使用代理模式,所不同的是它首先尝试去加载某个类,如果找不到再代理给父类加载器.这与一般类加载器的顺序是相反的

6.自定义类加载器

继承java.lang.ClassLoader

检查请求的类型是否已经被这个类装载器装载到命名空间中了,如果已经装载,直接返回

委派类加载请求给父类加载器,如果父类加载器能够完成,则返回父类加载器加载的Class实例

调用本类加载器的findClass()方法,试图获取对应得字节码,如果获取到,则调用defineClass()导入类型到方法区;如果获取不到对应的字节码或者其他原因失败,返回异常给loadClass(),loadClass()抛出异常,终止加载过程

注意:被两个类加载器加载的同一个类,JVM不认为是相同的类

文件类加载器

网络类加载器

加密解密类加载器(取反操作,DES对称加密解密)

Demo:

本地类存放在D:/TEST/com/lorinda/matrix42/Helloworld.class

package com.lorinda.matrix42;
public class Helloworld{
    public static void main(String[] args){
        System.out.println("aaa");
    }
}

文件类加载器:

package com.lorinda.jvm;

import java.io.InputStream;
import java.io.FileInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class FileSystemClassLoader extends ClassLoader{

    private String rootDir;

    public FileSystemClassLoader(String rootDir){
        this.rootDir = rootDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException{

        Class<?> c = findLoadedClass(name);

        //应该先查询有没有加载过这个类,如果已经加载,则直接返回加载好的类,如果没有,则加载新的类
        if(c!=null){
            return c;
        }else{
            ClassLoader parent = this.getParent();
            try{
                c = parent.loadClass(name);
            }catch(ClassNotFoundException e){

            }
            if(c!=null){
                return c;
            }else{
                byte[] classDate = getClassData(name);
                if(classDate==null){
                    throw new ClassNotFoundException();
                }else{
                    c = defineClass(name,classDate,0,classDate.length);
                }
            }
        }

        return c;

    }

    private byte[] getClassData(String classname){
        String path = rootDir+"/"+classname.replace('.','/')+".class";
        //System.out.println(path);
        //IOUtils 可以使用它将流中的数据转换成字节数组
        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try{
            is = new FileInputStream(path);

            byte[] buffer = new byte[1024];
            int temp = 0;
            while((temp=is.read(buffer))!=-1){
                baos.write(buffer,0,temp);
            }

            return baos.toByteArray();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(is!=null){
                    is.close();
                }
            }catch(IOException e){
                    e.printStackTrace();
                }

            try{
                if(baos!=null){
                    baos.close();
                }
            }catch(IOException e){
                    e.printStackTrace();
                }

        }
        return null;
    }

}

main:

package com.lorinda.jvm;

public class Demo{
    public static void main(String[] args) throws ClassNotFoundException{

        FileSystemClassLoader loader = new FileSystemClassLoader("D:/TEST");
        FileSystemClassLoader loader2 = new FileSystemClassLoader("D:/TEST");

        Class<?> c = loader.loadClass("com.lorinda.matrix42.Helloworld");
        Class<?> c2 = loader.loadClass("com.lorinda.matrix42.Helloworld");
        Class<?> c3 = loader2.loadClass("com.lorinda.matrix42.Helloworld");
        Class<?> c4 = loader2.loadClass("java.lang.String");
        Class<?> c5 = loader2.loadClass("com.lorinda.jvm.Demo");

        System.out.println(c.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());    //加载器不一样,JVM认为是不同的类
        System.out.println(c3.getClassLoader());
        System.out.println(c4.getClassLoader());  //null 引导类加载器
        System.out.println(c5.getClassLoader());

        /*
           1808253012
           1808253012
           589431969
           com.lorinda.jvm.FileSystemClassLoader@42a57993
           null
           sun.misc.Launcher$AppClassLoader@73d16e93
        */

    }
}

网络类加载器

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

public class NetClassLoader extends ClassLoader{

    private String rootUrl;

    public NetClassLoader(String rootUrl){
        this.rootUrl = rootUrl;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException{

        Class<?> c = findLoadedClass(name);

        //应该先查询有没有加载过这个类,如果已经加载,则直接返回加载好的类,如果没有,则加载新的类
        if(c!=null){
            return c;
        }else{
            ClassLoader parent = this.getParent();
            try{
                c = parent.loadClass(name);
            }catch(ClassNotFoundException e){

            }
            if(c!=null){
                return c;
            }else{
                byte[] classDate = getClassData(name);
                if(classDate==null){
                    throw new ClassNotFoundException();
                }else{
                    c = defineClass(name,classDate,0,classDate.length);
                }
            }
        }

        return c;

    }

    private byte[] getClassData(String classname){
        String path = rootUrl+"/"+classname.replace('.','/')+".class";
        //System.out.println(path);
        //IOUtils 可以使用它将流中的数据转换成字节数组
        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try{
            URL url = new URL(path);
            is = url.openStream();

            byte[] buffer = new byte[1024];
            int temp = 0;
            while((temp=is.read(buffer))!=-1){
                baos.write(buffer,0,temp);
            }

            return baos.toByteArray();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(is!=null){
                    is.close();
                }
            }catch(IOException e){
                    e.printStackTrace();
                }

            try{
                if(baos!=null){
                    baos.close();
                }
            }catch(IOException e){
                    e.printStackTrace();
                }

        }
        return null;
    }

}

加密解密类加载器(取反操作,DES对称加密解密)

/**
 * 测试简单加密解密(取反)操作
 * @author Matrix42
 *
 */
public class Demo03 {

    public static void main(String[] args) throws ClassNotFoundException {
        //测试取反操作
       // int a = 3;  //00000011
       // System.out.println(Integer.toBinaryString(a^0xff));

        //加密后的class文件,正常的类加载器无法加载,报classFormatError
       // FileSystemClassLoader loader = new FileSystemClassLoader("D:/TEST/com/lorinda/matrix42/tmp"); 
        //Class<?> c = loader.loadClass("Helloworld");    
        //System.out.println(c);

        DecriptClassLoader loader = new DecriptClassLoader("D:/TEST/");

        Class<?> c = loader.loadClass("com.lorinda.matrix42.Helloworld");

        System.out.println(c);

    }

}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class EncrptUtil {

    public static void main(String[] args) {
        encrpt("D:/TEST/com/lorinda/matrix42/Helloworld.class", "D:/TEST/com/lorinda/matrix42/tmp/Helloworld.class");
    }

    public static void encrpt(String src,String dest){
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dest);

            int temp = -1;
            while((temp=fis.read())!=-1){
                fos.write(temp^0xff);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{

            try {
                if (fis!=null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fos!=null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 加载文件系统中加密后的class字节码的类加载器
 * @author Matrix42
 *
 */
public class DecriptClassLoader extends ClassLoader{

    private String rootDir;

    public DecriptClassLoader(String rootDir){
        this.rootDir = rootDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException{

        Class<?> c = findLoadedClass(name);

        //应该先查询有没有加载过这个类,如果已经加载,则直接返回加载好的类,如果没有,则加载新的类
        if(c!=null){
            return c;
        }else{
            ClassLoader parent = this.getParent();
            try{
                c = parent.loadClass(name);
            }catch(ClassNotFoundException e){

            }
            if(c!=null){
                return c;
            }else{
                byte[] classDate = getClassData(name);
                if(classDate==null){
                    throw new ClassNotFoundException();
                }else{
                    c = defineClass(name,classDate,0,classDate.length);
                }
            }
        }

        return c;

    }

    private byte[] getClassData(String classname){
        String path = rootDir+"/"+classname.replace('.','/')+".class";
        //System.out.println(path);
        //IOUtils 可以使用它将流中的数据转换成字节数组
        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try{
            is = new FileInputStream(path);

            //相当于解密
            int temp = -1;
            while((temp=is.read())!=-1){
                baos.write(temp^0xff);
            }

            return baos.toByteArray();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            try{
                if(is!=null){
                    is.close();
                }
            }catch(IOException e){
                    e.printStackTrace();
                }

            try{
                if(baos!=null){
                    baos.close();
                }
            }catch(IOException e){
                    e.printStackTrace();
                }

        }
        return null;
    }
}