浅谈Java反射机制（类加载器）

目录

一、Class对象

1.加载

class文件

类加载器

类加载过程

---

学习java的都应该知道java有个高级特性，反射（reflection）。如果去读Spring框架源码，你会发现它的应用真的是无处不在。因为Spring核心功能IOC(控制翻转)就是用反射来实现的，不然我们不new，你以为对象是哪里来的。

1. 有这么一个场景：在程序运行时，你首先根据某个Class对象里的构造方法或者一般方法，然后考虑要实例化这个对象来用。
2. 另一个场景是：我们需要对某个Class对象里面的方法，变量进行自检。

那么我们就使用反射机制来实现。但反射机制是如何实现的呢？我有点好奇。百度一下Java反射机制，结果发现很多文章都是列出一堆方法，解释一下哪个是怎么用的。这就完了?这似乎一点都无法满足我的好奇心，再深挖一下就到了JVM了，原来如此，世界就是这么小。

一、Class对象

1.加载

加载什么？怎么加载？加载到哪儿?

这有点像经典的灵魂三问，带着问题去理解应该就容易一点。

class文件

首先，加载的肯定是我们的.class 文件。javac这个命令相信都知道做什么的，我们会吧程序用这个命令，编译成.class的字节码文件。加载，就是加载我们创建的字节码文件。网上很多都写加载方式是这个.class文件从哪儿来，我就纳闷，从哪儿来它不都是.class 文件嘛。

.class 文件它并不是Java的专利，而是属于一系列JVM语言的，比如Clojure、Groovy、JRuby、Jython、Scala。它就是一个以8位字节为单位的二进制流 byte[]。大概长这亚子：

类加载器

是的它来了，它来了，它带着“老大难”走来了。关于这个ClassLoader，我只想说，网上的资料五花八门，说什么的都有，很多文章都是胡说八道，都是坑。你抄我的坑，我抄你的坑，到处都是坑。不知道毒害了多少初学者，肯定很多。然后我想自己把它搞清楚。

读取class文件byte[]

上图的Class就是我们说的Class对象，它是被类加载子系统加载到JVM的方法区中的，也就是说Class对象是放在内存上的。当然这个过程肯定没有这么简单。我们先把ClassLoader给敲碎了：

Bootstrp ClassLoader：祖师爷（Bootstrp ClassLoader）

负责加载 JVM 运行时核心类，这些类位于 JAVA_HOME/lib/rt.jar 文件中，我们常用内置库 java.xxx.* 都在里面，比如 java.util.*、java.io.*、java.nio.*、java.lang.* 等等。它是由C++来实现的，所以它跟基类ClassLoader没关系，也没有对应的java对象所以一般它都是null来表示。

ExtClassLoader ： 大师兄（ExtClassLoader）

祖师爷先教（load）大师兄（sun.misc.Launcher$ExtClassLoader）,并且将ExtClassLoader的上级加载器设置为Bootstrp Loader。

师门规矩，长幼有序，有活儿先长辈来做，长辈做不了的按辈分依次往下分配。并要求严格遵守，避免重复干活，以至于到时候客人来验收，不知道找谁。

ExtClassLoader是用Java写的，ExtClassLoader主要加载%JAVA_HOME%/jre/lib/ext，此路径下的所有classes目录以及java.ext.dirs系统变量指定的路径中类库。

App ClassLoader：二师兄（sun.misc.Launcher$AppClassLoader）

祖师教完大师兄，就来教（load）二师兄，并且将二师兄的上级ClassLoader指定为大师兄ExtClassLoader （师门规矩要牢记）

二师兄也称为System ClassLoaer主要加载%CLASSPATH%路径的类库，默认情况下，它是用来加载我们写的代码即classPath下的.class。如果我们没有自定义ClassLoader的话，它就是默认的加载器。通常是自定义ClassLoader的上级ClassLoader 

由下面code可以看出，App ClassLoader加载了我写的TestClassLoader 类，并且它的上级加载器是ExtClassLoader

public class TestClassLoader {
    public static void main(String[] args) {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        System.out.println("current loader:" + classLoader);
        System.out.println("parent loader:" + classLoader.getParent());
        System.out.println("grandparent loader:" + classLoader.getParent().getParent());
    }
//    output:
//    current loader:sun.misc.Launcher$AppClassLoader@18b4aac2
//    parent loader:sun.misc.Launcher$ExtClassLoader@19469ea2
//    grandparent loader:null
}

   自定义类加载器

上面提过GroovyClassLoader就是一个定制化的ClassLoader。Groovy可以通过该ClassLoader加载后再通过反射机制获得实例对象，就完成了Script的动态加载，像这样：

            GroovyClassLoader loader= new GroovyClassLoader();
            Class groovyClass =loader.parseClass(new File("C:\\Desktop\\3011_TDT.groovy"));
            GroovyObject object =(GroovyObject) groovyClass.newInstance();

我们看一眼ClassLoader中的核心方法：

/**
     * Loads the class with the specified <a href="#name">binary name</a>.  The
     * default implementation of this method searches for classes in the
     * following order:
     *
     * <ol>
     *
     *   <li><p> Invoke {@link #findLoadedClass(String)} to check if the class
     *   has already been loaded.  </p></li>
     *
     *   <li><p> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method
     *   on the parent class loader.  If the parent is <tt>null</tt> the class
     *   loader built-in to the virtual machine is used, instead.  </p></li>
     *
     *   <li><p> Invoke the {@link #findClass(String)} method to find the
     *   class.  </p></li>
     *
     * </ol>
     *
     * <p> If the class was found using the above steps, and the
     * <tt>resolve</tt> flag is true, this method will then invoke the {@link
     * #resolveClass(Class)} method on the resulting <tt>Class</tt> object.
     *
     * <p> Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link
     * #findClass(String)}, rather than this method.  </p>
     *
     * <p> Unless overridden, this method synchronizes on the result of
     * {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method
     * during the entire class loading process.
     *
     * @param  name
     *         The <a href="#name">binary name</a> of the class
     *
     * @param  resolve
     *         If <tt>true</tt> then resolve the class
     *
     * @return  The resulting <tt>Class</tt> object
     *
     * @throws  ClassNotFoundException
     *          If the class could not be found
     */
    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 {
                    // 如果尚未加载，则遵循上级优先的等级加载机制（所谓双亲委派机制）
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // 模板方法模式：如果还是没有加载成功，调用findClass()
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    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(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }

核心方法中大致是三个步骤：

1. 检查是否已经加载，有就直接返回，避免重复加载
2. 当前缓存中确实没有该类，那么遵循上级加载器优先加载机制（所谓的双亲委派模型），加载.class文件
3. 上面两步都失败了，调用findClass()方法加载

值得注意的是，ClassLoader本身是个抽象类，所以无法new它后同对象来调用它的findClass()方法，所以它直接抛了个ClassNotFoundException出来。正确的做法是在它的子类里面去实现这个方法。那么我们看具体实现：

    /**
     * Finds and loads the class with the specified name from the URL search
     * path. Any URLs referring to JAR files are loaded and opened as needed
     * until the class is found.
     *
     * @param name the name of the class
     * @return the resulting class
     * @exception ClassNotFoundException if the class could not be found,
     *            or if the loader is closed.
     * @exception NullPointerException if {@code name} is {@code null}.
     */
    protected Class<?> findClass(final String name)
        throws ClassNotFoundException
    {
        final Class<?> result;
        try {
            result = AccessController.doPrivileged(
                new PrivilegedExceptionAction<Class<?>>() {
                    public Class<?> run() throws ClassNotFoundException {
                        String path = name.replace('.', '/').concat(".class");
                        Resource res = ucp.getResource(path, false);
                        if (res != null) {
                            try {
                                //调用类加载器本身的defineClass()方法，由字节码得到Class对象
                                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;
    }





/*
     * Defines a Class using the class bytes obtained from the specified
     * Resource. The resulting Class must be resolved before it can be
     * used.
     */
    private Class<?> defineClass(String name, Resource res) throws IOException {
        long t0 = System.nanoTime();
        int i = name.lastIndexOf('.');
        URL url = res.getCodeSourceURL();
        if (i != -1) {
            String pkgname = name.substring(0, i);
            // Check if package already loaded.
            Manifest man = res.getManifest();
            definePackageInternal(pkgname, man, url);
        }
        // Now read the class bytes and define the class
        java.nio.ByteBuffer bb = res.getByteBuffer();
        if (bb != null) {
            // Use (direct) ByteBuffer:
            CodeSigner[] signers = res.getCodeSigners();
            CodeSource cs = new CodeSource(url, signers);
            sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
            return defineClass(name, bb, cs);
        } else {
            byte[] b = res.getBytes();
            // must read certificates AFTER reading bytes.
            CodeSigner[] signers = res.getCodeSigners();
            CodeSource cs = new CodeSource(url, signers);
            sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);
            return defineClass(name, b, 0, b.length, cs);
        }
    }

总结一下

看网上很多文章博客都写， ExtClassLoader 是App ClassLoader 的父加载器。这里一定要搞明白，父加载器不是父类加载器，这很容易让人误解。这样的坑还有是所谓的“双亲委派模型”，我不知道哪个同仁翻译的，不知是英语不好还是Java不好。不然你告诉我The parent-delegation model里面哪个单词是说的双亲？parent在表示父母的时候也是以parents复数形式用的，parent指的是父亲（或者母亲），这么看怎么也是单亲啊。

还有人翻译成父委托模型，java中的父一般都指的是继承关系的父类。这样翻译一样会引歧义，因为类加载器除了Bootstrp ClassLoader外都是有父类的，但很显然此父非彼父。

而且，我觉得这是一个有回溯的过程，上级加载器加载不了，他们会一级一级的再向下送，直到找到能加载的类加载器为止，并不是单向的，所以说父委托模型也不合理。我这里就钻个牛角尖，直到整明白为止。所以每次看到这类翻译词就感觉别扭，但没办法，已经成了行业标准了。

类加载过程

上面提到过Class对象，在理解反射机制原理之前，我觉得必须先要了解Class对象是什么。要理解Class对象是什么，必须先清楚JVM类加载过程。看吧，JVM到哪里都躲不过。这也是痛苦的根源，但是不怕，砸碎它，消化它。

看到这个图好迷糊，都是些空洞苍白的词，看了等于没看。下篇再去敲碎这个加载过程试试。