JVM笔记（二）类加载系统、运行时数据区、执行引擎详解

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();
            try {
                    // 如果存在父类加载器，交给父类加载器加载class
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    // 没有父类加载器，则调用顶层bootstrapclassLoader加载，native方法
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }
            // 如果父类没加载到class
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                // 调用本类的加载方法加载class
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }

        return c;
    }

protected Class<?> findClass(final String name)
    throws ClassNotFoundException
{
    final Class<?> result;
    try {
        result = AccessController.doPrivileged(
            new PrivilegedExceptionAction<Class<?>>() {
                public Class<?> run() throws ClassNotFoundException {
                    // 从完整包路径，加载文件，在调用defineClass将二进制字节码文件解析为class对象
                    String path = name.replace('.', '/').concat(".class");
                    Resource res = ucp.getResource(path, false);
                    if (res != null) {
                        try {
                            return defineClass(name, res);
                        } catch (IOException e) {
                            throw new ClassNotFoundException(name, e);
                        }
                    } else {
                        return null;
                    }
                }
            }, acc);
    } catch (java.security.PrivilegedActionException pae) {
        throw (ClassNotFoundException) pae.getException();
    }
    if (result == null) {
        throw new ClassNotFoundException(name);
    }
    return result;
}

一个类被加载到JVM中，用其类加载器和全限定名作为这个类在jvm中的唯一标识，不同的加载器实例加载的相同class文件，互不兼容（cast强转报错），下节代码示例。

1.3.2 自定义类加载器

测试不同的加载器加载的类与原类不兼容

public class TestClassLoader extends ClassLoader{
    String classpath = "D:/00000000000000/target/test-classes/";
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            name = name.replace(".", "//");
            String path = classpath + name + ".class";
            File file = new File(path);
            FileInputStream is = new FileInputStream(file);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int b = 0;
            while ((b = is.read()) != -1) {
                baos.write(b);
            }
            is.close();
            byte[] bytes = baos.toByteArray();
            return this.defineClass(name, bytes, 0, bytes.length);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

public class TestObject {
    public void testPrint() {
        System.out.println("ddd");
    }

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {

        System.out.println("默认加载器：" + TestObject.class.getClassLoader().toString());

        TestClassLoader loader = new TestClassLoader();
        Class<?> testObject = loader.findClass("TestObject");
        Object o1 = testObject.newInstance();

        System.out.println("自定义加载器加载的对象：" + o1.getClass().toString());
        System.out.println("自定义加载器加载的对象classLoader：" + o1.getClass().getClassLoader().toString());

        // 强转报错，因为加载器不同，两个Class也是不同的，不能强转
        TestObject cast = (TestObject) o1;
        cast.testPrint();
    }
}