聊聊 ClassLoader 是如何查找资源的

ClassLoader作用

classloader这个写业务代码的童鞋们，应该很少用到，但是写框架的应该很熟悉。这个类负责Java底层的类的加载和查找，简单滴说Java 的所有类都是由它负责将class文件加载到JVM

这篇文章主要是讲解，ClassLoader是如何查找和加载类的

常用的ClassLoader

   ①：BootStrapClassloader  负责加载jre下面的核心类

②：ExtClassLoader      负责加载jre/ext下面的类

③：AppClassloader      负责加载classpath下面的类或者jar，这个classpath很广，包括(我们平常能接触到也就是这个AppClassload)

①：jre/lib下面的部分包

②：web项目的classpath路径下的所有的类和资源

③：web项目依赖的第三方jar包

④：自定义classloader

   如果有兴趣的话，你们可以分别打印出每个classloader管理的资源，代码如下

　public static  void print(){
    　　URL[] bootStrapUrls = Launcher.getBootstrapClassPath().getURLs();
    　　System.out.println("-----------boot-----------------");
    　　for(URL url : bootStrapUrls)
        　　System.out.println(url);
   　　 System.out.println("-----------boot-----------------");

 　　  URLClassLoader extClassLoader = (URLClassLoader)Thread.currentThread().getContextClassLoader().getParent();
   　　 URL[] extUrls  = extClassLoader.getURLs();
    　　System.out.println("-----------ext-----------------");
    　　for(URL url : extUrls)
        　　System.out.println(url);
   　　 System.out.println("-----------ext-----------------");

    　　URLClassLoader appClassLoad = (URLClassLoader)Thread.currentThread().getContextClassLoader();
    　　URL[] appClassLoadUrls  = appClassLoad.getURLs();
    　　System.out.println("-----------appClassloader-----------------");
    　　for(URL url : appClassLoadUrls)
        System.out.println(url);
    　　System.out.println("-----------appClassloader-----------------");

    　　String var1 = System.getProperty("java.class.path");
    　　System.out.println("classpath:"+var1);
　　}

ClassLoader如何发现资源   

①：A.class.getResourceAsStream(resource)
②：A.class.getClassLoader().getResourceAsStream("")
③：Class.forName("").newInstance();

      上面的代码大家熟悉不，我相信很多人都用过，但是用的时候都很迷茫，每次用的时候一旦出错，都不知道为啥出错，怎么修改(内心都是why? why? why?)到底是为啥呀 ？？？下面我们就聊聊这个Classloader的原理

这段是基础介绍，如果大家知道可以跳过

 一，各个Classloader的关系直接上图(双亲委托机制)

            

            查找一个.class文件时，从上图可以看到，

①：查找资源的时候appClassloader会将查找任务先委托给自己的上级ExtClassloader

②：ExtClassloader会将查找任务先委托给上级BootStrapClassloader

③：只有在上级查找不到情况下，自己再负责查找资源并加载

经典加载代码 Thread.currentThread().getContextClassLoader().loadClass("");

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) {
                // 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;
    }
}

这段是基础介绍，如果大家知道可以跳过

问题
    问题1：每个classloader 管理的资源存储在什么地方
    问题2：项目依赖的jar包本身还要依赖第三jar包，此时classloader又该如何处理
示例

 main方法执行后，JVM是如何加载main方法所在的类
       首先大家要知道JVM是不会傻傻的在启动时候，直接将程序中所有的类和资源都加载进内存，JVM秉承的设计原则就是，用时再加载，不用的时候，你就歇着吧（JVM作为BOSS 很抠的哈），那么JVM是怎么加载main方法所在的类尼
       ①：程序启动的时候，JVM负责先装载所有的classLoader(这一部分，大家不用深究，具体JVM怎么下指令的，这个东西是底层做的，我们也看不懂)，我们只需要知道JVM帮忙实例化了sun.misc.Launcher这个类,在这个构造函数中
，装载所有的Classloader(主意：BootstrapClassloader不归它管，你可以理解BootstrapClassloader为JVM直辖（就像直辖市一样）)

public Launcher() {
    Launcher.ExtClassLoader var1;
    try {
        //加载ExtClassload
        var1 = Launcher.ExtClassLoader.getExtClassLoader();
    } catch (IOException var10) {
        throw new InternalError("Could not create extension class loader", var10);
    }

    try {
        //加载AppClassLoad
        this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {
        throw new InternalError("Could not create application class loader", var9);
    }

    Thread.currentThread().setContextClassLoader(this.loader);
    String var2 = System.getProperty("java.security.manager");
    if(var2 != null) {
        SecurityManager var3 = null;
        if(!"".equals(var2) && !"default".equals(var2)) {
            try {
                var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
            } catch (IllegalAccessException var5) {
                ;
            } catch (InstantiationException var6) {
                ;
            } catch (ClassNotFoundException var7) {
                ;
            } catch (ClassCastException var8) {
                ;
            }
        } else {
            var3 = new SecurityManager();
        }

        if(var3 == null) {
            throw new InternalError("Could not create SecurityManager: " + var2);
        }

        System.setSecurityManager(var3);
    }

}   

     ②：加载main方法所在的类如：A，调用的部分流程如下：最终调用Classloader.loadClass这个方法加载A类，这个类（典型的双亲委托模式实例）

③：带着问题分析一下ClassLoader.loadClass 这个类

从上文得知findClass() 这个方法是具体负责加载资源,但是你点击进去会发现这是一个为空实现，看看这个类的继承关系，AppClassLoader父类为URLClassLoader,我们到URLclassLoader上看看

其实到这里，我们已经可以看到，其实是类查找和加载UCP 这个对象操作，UCP（是URLClasspath这个类的实例）

     ps:这里的涉及到缓存的代码，暂时不要看（如：getLookUpCache()）,基本上都无法名中（反正我debug的时候，没啥用）

 

重点来啦，要看懂上述这段代码，就不的不提一下上面讲的那个类URLClassPath 和URLClassPath.loader这个内部类

path：初始化类加载器的时候，设置类记载器管理的默认资源列表（比如appclassLoader 这个类加载器，这个path中主要存储的是项目依赖的jar包路径（不包括此ar包依赖的第三方jar），jre/lib下的部分jar）

urls：其实初始化完成以后应该和path一样，区别在于urls还会解决这个问题（问题2：项目依赖的jar包本身还要依赖第三jar包，此时classloader又该如何处理），

也就是说，urls初始化完成以后，还会去加载jar包依赖的第三方jar包，怎么加载的(下面分析)（这是一个栈的数据结构，先进后出）

loaders：这个属性有点强啦，是资源抽象（URLClassPath.loader）的列表，提供一个非常关键的方法  Resource getResource(String var1, boolean var2) ，负责匹配资源（或者说在这个资源中能不能找到这个要加载的类）

URLClassPath.loader  有2个具体的实现类，每个都重写了getResource这个方法

lamp 这个其实作用不是很大，做一个缓存的作用，如果URLClassPath.loader实例化过啦，直接从缓存中取出，不用重新实例化啦

那么我们现在再来分析一下，getLoader这个方法

private synchronized URLClassPath.Loader getLoader(int var1) {
    if(this.closed) {
        return null;
    } else {
         //这里不用if用while，原因是loader存在重复加载，此时缓存已经有啦（证明这个loader是无法找到这个资源），
         //直接获取下一个loader即可（项目依赖的jar包很多，存在多个jar包在依赖其他的同一个jar包很正常,
       //如：每个jar包都需要日志相关的jar）
        while(this.loaders.size() < var1 + 1) {
            Stack var3 = this.urls;
            URL var2;
            synchronized(this.urls) {
                 //urls都空即当前这个classloader无法加载这个类
                if(this.urls.empty()) {
                    return null;
                }

                var2 = (URL)this.urls.pop();
            }

            String var9 = URLUtil.urlNoFragString(var2);
            if(!this.lmap.containsKey(var9)) {
                URLClassPath.Loader var4;
                try {
                    var4 = this.getLoader(var2);
                    //这个地方主要是解决问题2（有兴趣可以看看它的实现类，JarLoader,简单滴讲就是读取MANIFEST.MF中的classpath这个字段），问题2：项目依赖的jar包本身还要依赖第三jar包，此时classloader又该如何处理
                    URL[] var5 = var4.getClassPath();
                    if(var5 != null) {
                        this.push(var5);
                    }
                } catch (IOException var6) {
                    continue;
                } catch (SecurityException var7) {
                    if(DEBUG) {
                        System.err.println("Failed to access " + var2 + ", " + var7);
                    }
                    continue;
                }

                this.validateLookupCache(this.loaders.size(), var9);
                this.loaders.add(var4);
                this.lmap.put(var9, var4);
            }
        }

        if(DEBUG_LOOKUP_CACHE) {
            System.out.println("NOCACHE: Loading from : " + var1);
        }
        return (URLClassPath.Loader)this.loaders.get(var1);
    }
}

给大家画了一张简单时序图

简单总结
      整个classloader加载思想就是：将classloader能够管理的资源交给URLClasspath,将查找这个脏活交给这个loader内部类，通过调用getResource（）来确定是否有能力加载