＜java基础＞类加载器

类加载器

类加载器原理

加载器源码分析

ClassLoader是个抽象类。

private static native void registerNatives();
    static {
        registerNatives();
    }

#这段代码的作用是什么？
成员变量：每个加载器都聚合了一个父加载器，相当于链表了。

// The parent class loader for delegation
    // Note: VM hardcoded the offset of this field, thus all new fields
    // must be added *after* it.
    private final ClassLoader parent;

直接来看核心方法是如何加载类的：

   * @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);
                        //否则用BootStrap加载
                    }
                    
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // 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;
        }

两个重要加载器的实现

父类均为URLClassLoader,重写了findClass();
直接根据路径取拿到字节码，具体代码后面补充(TODO)
构造器：

public URLClassLoader(URL[] urls, ClassLoader parent,
                          URLStreamHandlerFactory factory) {
        super(parent);
        // this is to make the stack depth consistent with 1.1
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkCreateClassLoader();
        }
        acc = AccessController.getContext();
        ucp = new URLClassPath(urls, factory, acc);
    }

  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 {
                                return defineClass(name, res);//生成字节码文件，返回类对象
                            } catch (IOException e) {
                                throw new ClassNotFoundException(name, e);
                            } catch (ClassFormatError e2) {
                                if (res.getDataError() != null) {
                                    e2.addSuppressed(res.getDataError());
                                }
                                throw e2;
                            }
                        } else {
                            return null;
                        }
                    }
                }, acc);
        } catch (java.security.PrivilegedActionException pae) {
            throw (ClassNotFoundException) pae.getException();
        }
        if (result == null) {
            throw new ClassNotFoundException(name);
        }
        return result;
    }

1.扩展加载器

来看看扩展加载器的实现：

public ExtClassLoader(File[] var1) throws IOException {
            super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
            SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
        }

构造方法中父加载器为空

static class ExtClassLoader extends URLClassLoader {
        private static volatile Launcher.ExtClassLoader instance;

// 显然这是个单例模式，写死的。
public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
            if (instance == null) {
                Class var0 = Launcher.ExtClassLoader.class;
                synchronized(Launcher.ExtClassLoader.class) {
                    if (instance == null) {
                        instance = createExtClassLoader();
                    }
                }
            }

            return instance;
        }

  private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {
            try {
                return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
                    public Launcher.ExtClassLoader run() throws IOException {
                        File[] var1 = Launcher.ExtClassLoader.getExtDirs();//**java.ext.dirs**
                        int var2 = var1.length;

                        for(int var3 = 0; var3 < var2; ++var3) {
                            MetaIndex.registerDirectory(var1[var3]);
                        }//需要了解，可能是注册到到缓存表里？TODO

                        return new Launcher.ExtClassLoader(var1);//拿到对象了
                    }
                });
            } catch (PrivilegedActionException var1) {
                throw (IOException)var1.getException();
            }
        }

获取扩展目录

        private static File[] getExtDirs() {
            String var0 = System.getProperty("java.ext.dirs");
            //系统内部维护了一个property对象，底层是个hashtable
            File[] var1;
            if (var0 != null) {
                StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);//切分成token
                int var3 = var2.countTokens();
                var1 = new File[var3];

                for(int var4 = 0; var4 < var3; ++var4) {
                    var1[var4] = new File(var2.nextToken());
                }
            } else {
                var1 = new File[0];
            }

            return var1;//返回此目录下的所有文件集
        }

public class ExtFiles {
    public static void main(String[] args) {
        System.out.println("java.ext.dirs的value:"+System.getProperty("java.ext.dirs"));
    }//java.ext.dirs的value:D:\Java\jre\lib\ext;C:\Windows\Sun\Java\lib\ext
}

2.APP加载器

构造方法：

 AppClassLoader(URL[] var1, ClassLoader var2) {
            super(var1, var2, Launcher.factory);
            this.ucp.initLookupCache(this);
        }

获取loader的方式和扩展加载器不一样，具体区别先不作区分*（TODO）*

 public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
            final String var1 = System.getProperty("java.class.path");
            final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
            return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
                public Launcher.AppClassLoader run() {
                    URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
                    return new Launcher.AppClassLoader(var1x, var0);
                }
            });
        }

我们来看看这个键里存了哪些值：

localedata.jar
D:\Java\jre\lib\ext\nashorn.jar
D:\Java\jre\lib\ext\sunec.jar
D:\Java\jre\lib\ext\sunjce_provider.jar
D:\Java\jre\lib\ext\sunmscapi.jar
D:\Java\jre\lib\ext\sunpkcs11.jar
D:\Java\jre\lib\ext\zipfs.jar
D:\Java\jre\lib\javaws.jar
D:\Java\jre\lib\jce.jar
D:\Java\jre\lib\jfr.jar
D:\Java\jre\lib\jfxswt.jar
D:\Java\jre\lib\jsse.jar
D:\Java\jre\lib\management-agent.jar
D:\Java\jre\lib\plugin.jar
D:\Java\jre\lib\resources.jar
D:\Java\jre\lib\rt.jar
D:\Project\项目\Reback\JVM\target\classes

双亲委派机制及破坏

总结

至此我们知道了一个加载器是如何去加载一个类的了。但是：

谁来加载加载器

http://t.csdn.cn/gshgD
据此BootStrap加载器加载。

内建于JVM中的启动类加载器会加载java.lang.ClassLoader以及其他java平台类，当jvm启动时，一块特殊的机器码会运行，它会加载扩展类加载器与系统类加载器， 这块特殊的机器码叫做启动类加载器(Bootstarp)。启动类加载器并不是Java类，而其它加载器则都是Java类。 启动类加载器是特定于平台的机器指令，它负责开启整个加载过程。 所有类加载器(除了启动类加载器)都被实现为Java类，不过，总归要有一个组件来加载第一个Java类加载器，从而让整个加载过程能够顺利进行下去，加载第一个纯Java类加载器就是启动类加载器的职责。启动类加载器还会负责加载供JRE正常运行所需要的基本组件，这包括java.util与java.lang包中的类等等。

谁来加载类？

一般来说，类路径下的jar包以及类，都是由APP加载器来加载的，只有有具体的包信息，就可以去指定的路径去加载流；
我们知道loader可以选择性的去加载类，可是类一开始找谁加载呢；
（1）classForName（）

  @CallerSensitive
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

/** Called after security check for system loader access checks have been made. */
    private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)
        throws ClassNotFoundException;

全是本地方法，咋看…到底使用哪个加载器呢，有网友说是当前加载器.

（2）new对象的时候找哪个加载器？
（3）引入的jar包的加载器是谁？
引入的jar包或者我们在idea中字节写的类，加载器都是app类加载器；

什么时候需要实现一个加载器

如何实现一个加载器

Java类加载机制

http://t.csdn.cn/yRfKC

Tomcat和JDBC加载机制