简单的JVM类加载机制,双亲委派机制修改

类加载机制


类加载过程

双亲委派机制

package com.liu.jvm;

import java.io.FileInputStream;
import java.lang.reflect.Method;

/***
 * JAVA加载器分为三类
 * 1，引导类加载器：负责支撑JVM运行的位于jre lib 下的核心类库，如rt.jar,charset.jar
 * 2，扩展类加载器:负责加载jre下ext扩展库下的jar包
 * 3，应用加载器：负责加载class path下的类
 * 4，可自定义加载器：负责加载用户自定义下的类文件
 * 加载器默认使用双亲委派原理：即默认为AppClassLoader,如果没有找扩展,>引导>扩展>应用>自定义
 * 1,沙箱安全机制：自己写的Char.java不会被加载，防止核心代码被篡改
 * 2，避免类重复加载，当父类已经加载该类，子类无需记载
 */
public class MyClassLoader extends ClassLoader {
   private String classPath;
    public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }
    /**
     * 自定义加载加载loadBytes数组方法，获取class bytes文件
     * @param className
     * @return
     * @throws Exception
     */
    private byte[] loadBytes(String className) throws Exception{
        className=className.replaceAll("\\.","/");
        FileInputStream fis=new FileInputStream(classPath+"/"+className+".class");
        int len=fis.available();
        byte[] data=new byte[len];
        fis.read(data);
        fis.close();
        return data;
    }

    /***
     *父类findClass方法，重构，自定义加载方式
     * */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {

            byte[] classFile=loadBytes(name);
            return  defineClass(name,classFile,0,classFile.length);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return super.findClass(name);
    }

    public static void main(String[] args) throws Exception {
        MyClassLoader myClassLoader=new MyClassLoader("C:/Users/Administrator/Desktop/test");
        Class cla=myClassLoader.loadClass("com.liu.jvm.Test");
        Object obj=cla.newInstance();
        Method method=cla.getDeclaredMethod("toString");
        method.invoke(obj);
        System.out.println(cla.getClassLoader().getClass().getName());
    }

    @Override
    public String toString() {
        System.out.println("执行MyClassLoader toString 方法");
        return super.toString();
    }

    /**
     * 重写双亲委派，即重写类加载方法
     * @param name
     * @param resolve
     * @return
     * @throws ClassNotFoundException
     */
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
//                重写类加载方法，实现自己的加载逻辑，即自定义的文件由自己加载，其他的由默认加载
                //核心包和扩展包，不允许加载，触发安全机制
                if (name.startsWith("com.liu.jvm.Test")){
                    c = findClass(name);
                }else {
                    c = this.getParent().loadClass(name);
                }
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t0);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
}

tomcat的几个主要类加载器：
commonLoader：Tomcat最基本的类加载器，加载路径中的class可以被 Tomcat容 器本身以及各个Webapp访问；
catalinaLoader：Tomcat容器私有的类加载器，加载路径中的class对于Webapp不 可见；
sharedLoader：各个Webapp共享的类加载器，加载路径中的class对于所有 Webapp可见，但是对于Tomcat容器不可见；
WebappClassLoader：各个Webapp私有的类加载器，加载路径中的class只对当前 Webapp可见，比如加载war包里相关的类，每个war包应用都有自己的
WebappClassLoader，实现相互隔离，比如不同war包应用引入了不同的spring版本， 这样实现就能加载各自的spring版本；