踩坑集锦之你真的明白Java类路径的含义吗？

    private static Object compileJava2Class(String filePath, String proxyClassName) throws Exception {
        // 编译 Java 文件
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        Iterable<? extends JavaFileObject> compilationUnits =
                fileManager.getJavaFileObjects(new File(filePath + File.separator + proxyClassName + ".java"));
        JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, compilationUnits);
        task.call();
        fileManager.close();
        // 加载 class 文件
        URL[] urls = new URL[]{new URL("file:" + filePath)};
        URLClassLoader urlClassLoader = new URLClassLoader(urls);
        Class<?> clazz = urlClassLoader.loadClass(CustomInvokerProxyUtils.WRAPPER_PACKAGE_NAME + "." + proxyClassName);
        // 反射创建对象，并且实例化对象
        Constructor<?> constructor = clazz.getConstructor();
        return constructor.newInstance();
    }

int JNICALL
JavaMain(void * _args)
{
   ...
    mainClass = LoadMainClass(env, mode, what);
   ...
}


static jclass
LoadMainClass(JNIEnv *env, int mode, char *name)
{
	jclass cls = GetLauncherHelperClass(env);
		...
    NULL_CHECK0(mid = (*env)->GetStaticMethodID(env, cls,
                "checkAndLoadMain",
                "(ZILjava/lang/String;)Ljava/lang/Class;"));
    ...
}

jclass
GetLauncherHelperClass(JNIEnv *env)
{
    if (helperClass == NULL) {
        NULL_CHECK0(helperClass = FindBootStrapClass(env,
                "sun/launcher/LauncherHelper"));
    }
    return helperClass;
}

    public static Class<?> checkAndLoadMain(boolean printToStderr,
                                            int mode,
                                            String what) {
        //根据参数决定将ostream初始化为标准输出流还是标准错误流,从而保证程序的正常输出。                                    
        initOutput(printToStderr);
        // mode 变量是一个枚举类型，表示不同的启动模式
        // what参数指定要运行的主类名或要运行的JAR文件路径。根据mode参数的不同，what的含义也有所不同。
        String cn = null;
        switch (mode) {
             //当mode为LM_CLASS时，what为要运行的主类名
            case LM_CLASS:
                cn = what;
                break;
            //当mode为LM_JAR时，what为要运行的JAR文件路径。    
            case LM_JAR:
                cn = getMainClassFromJar(what);
                break;
            default:
                // should never happen
                throw new InternalError("" + mode + ": Unknown launch mode");
        }
        //将路径符替换为包分割符号
        cn = cn.replace('/', '.');
        Class<?> mainClass = null;
        try {
            //加载启动类
            mainClass = scloader.loadClass(cn);
        } catch (NoClassDefFoundError | ClassNotFoundException cnfe) {
            //检查操作系统是否为 OS X，如果是，则可能存在字符串规范化的问题，需要对类名进行重新规范化处理，然后再次尝试加载
            ...
        }
        // 设置启动类
        appClass = mainClass;
         // JavaFX是一组用于创建富客户端应用程序的工具和库，可以帮助开发人员轻松构建跨平台的桌面和移动应用程序。
        //在 Java 8 及之前版本中，JavaFX 应用程序和普通 Java 应用程序启动方式不同。JavaFX 应用程序需要通过特定的启动类来启动，而不是通过 main 方法。
        ...
       //校验启动类的psvm方法是否符合规范
       //1.存在方法名为main的方法
       //2.方法修饰符是否为public
       //3.方法是否为静态方法
       //4.方法是否携带一个String[]数组类型的入参
       //5.方法的返回值是否为void
        validateMainClass(mainClass);
        return mainClass;
    }

    static void validateMainClass(Class<?> mainClass) {
        Method mainMethod;
        try {
            mainMethod = mainClass.getMethod("main", String[].class);
        } catch (NoSuchMethodException nsme) {
            // invalid main or not FX application, abort with an error
            abort(null, "java.launcher.cls.error4", mainClass.getName(),
                  FXHelper.JAVAFX_APPLICATION_CLASS_NAME);
            return; // Avoid compiler issues
        }

        /*
         * getMethod (above) will choose the correct method, based
         * on its name and parameter type, however, we still have to
         * ensure that the method is static and returns a void.
         */
        int mod = mainMethod.getModifiers();
        if (!Modifier.isStatic(mod)) {
            abort(null, "java.launcher.cls.error2", "static",
                  mainMethod.getDeclaringClass().getName());
        }
        if (mainMethod.getReturnType() != java.lang.Void.TYPE) {
            abort(null, "java.launcher.cls.error3",
                  mainMethod.getDeclaringClass().getName());
        }
    }

    public static ClassLoader getSystemClassLoader() {
        //尝试初始化系统类加载器---单例初始化操作
        initSystemClassLoader();
        if (scl == null) {
            return null;
        }
        ...
        return scl;
    }

    private static synchronized void initSystemClassLoader() {
        //sclSet变量控制系统类加载器只被初始化调用一次
        if (!sclSet) {
             //scl就是系统类加载器
            if (scl != null)
                throw new IllegalStateException("recursive invocation");
            //
            sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
            if (l != null) {
                //拿到系统类加载器
                scl = l.getClassLoader();
                //SystemClassLoaderAction就比较有意思了--我们可以在此处替换系统类加载器为我们自定义的类加载器
                scl = AccessController.doPrivileged(new SystemClassLoaderAction(scl));
            }
            sclSet = true;
        }
    }

class SystemClassLoaderAction
    implements PrivilegedExceptionAction<ClassLoader> {
    private ClassLoader parent;
    //parent为系统类加载器 
    SystemClassLoaderAction(ClassLoader parent) {
        this.parent = parent;
    }

    public ClassLoader run() throws Exception {
        //我们可以在系统上下文中设置我们自定义的系统类加载器全类名
        String cls = System.getProperty("java.system.class.loader");
        if (cls == null) {
            return parent;
        }
        //此处利用系统类加载器来加载我们的自定义系统类加载器
        Constructor<?> ctor = Class.forName(cls, true, parent) 
             //需要提供一个有一个参数的构造函数,参数类型为ClassLoader
            .getDeclaredConstructor(new Class<?>[] { ClassLoader.class });
        //实例化我们的自定义系统类加载器
        ClassLoader sys = (ClassLoader) ctor.newInstance(
            new Object[] { parent });
        //设置我们的自定义的系统类加载器为线程上下文类加载器    
        Thread.currentThread().setContextClassLoader(sys);
        //返回替换默认的系统类加载器
        return sys;
    }
}

public class Launcher {
    //Launcher类进行类初始化操作时,会创建一个单例的Launcher对象--饿汉式单例
    private static Launcher launcher = new Launcher();
    //系统类加载器
    private ClassLoader loader;
    //从系统上下文中获取BootStrapClassLoader启动类加载器加载的类路径
    private static String bootClassPath = System.getProperty("sun.boot.class.path");
    //返回实例化好的单例Launcher对象 
    public static Launcher getLauncher() {
        return launcher;
    }

// java虚拟机启动的时候调用
public Launcher() {
        // Create the extension class loader
        ClassLoader extcl;
        //初始化扩展类加载器
        extcl = ExtClassLoader.getExtClassLoader();
        // 初始化线程上下文类加载器
        loader = AppClassLoader.getAppClassLoader(extcl)
        //设置线程上下文类加载器默认为appClassLoader
        //上面提到,我们可以在后续的jdk预留的口子中替换默认的系统类加载器为我们自定义的类加载器
        Thread.currentThread().setContextClassLoader(loader);
        ...
    }

//BootClassPathHolder类会在JVM启动时被类加载器初始化    
private static class BootClassPathHolder {
        static final URLClassPath bcp;
        static {
            URL[] urls;
            //从系统上下文中拿到启动类加载器加载的类路径
            if (bootClassPath != null) {
                    //对类路径按照分隔符进行分割,并封装为一组File对象返回
                    File[] classPath = getClassPath(bootClassPath);
                    int len = classPath.length;
                    //过滤掉重复的目录
                    Set<File> seenDirs = new HashSet<File>();
                    for (int i = 0; i < len; i++) {
                        File curEntry = classPath[i];
                        //这段代码的作用是为了正确地处理启动类路径中不存在的JAR文件。
                        //如果curEntry代表的是一个JAR文件，!curEntry.isDirectory()将返回true，
                        //此时代码将curEntry设置为JAR文件的父文件夹。
                        //这是因为JAR文件是一个文件而不是一个目录，如果直接将JAR文件添加到类路径中可能会导致ClassNotFoundException。
                        //因此，将JAR文件所在的文件夹添加到类路径中可以避免这个问题。
                        if (!curEntry.isDirectory()) {
                            curEntry = curEntry.getParentFile();
                        }
                       //将JAR文件中的元数据信息注册到内存中的元数据索引中，以便在需要查找该JAR文件时进行快速查找
                       //前提是jar包提供了meta-index文件
                        if (curEntry != null && seenDirs.add(curEntry)) {
                           MetaIndex.registerDirectory(curEntry);
                         }
                    } 
                  //将File转换为URL
                  urls=pathToURLs(classPath);
            } else {
                urls = new URL[0];
            }
            //初始化启动类加载器对应URLClassPath--类路径集合操作的具体表示
            bcp = new URLClassPath(urls, factory, null);
            bcp.initLookupCache(null);
        }
    }

    public static URLClassPath getBootstrapClassPath() {
        return BootClassPathHolder.bcp;
    }

        public static ExtClassLoader getExtClassLoader() throws IOException
        {
            if (instance == null) {
                synchronized(ExtClassLoader.class) {
                    if (instance == null) {
                        instance = createExtClassLoader();
                    }
                }
            }
            return instance;
        }

private static ExtClassLoader createExtClassLoader() throws IOException {
               //获取扩展类加载器负责加载的目录---也就是我们说的扩展类加载器能够加载的类路径  
               final File[] dirs = getExtDirs();
               int len = dirs.length;
                //将JAR文件中的元数据信息注册到内存中的元数据索引中，以便在需要查找该JAR文件时进行快速查找
                //前提是jar包提供了meta-index文件
                for (int i = 0; i < len; i++) {
                     MetaIndex.registerDirectory(dirs[i]);
                }
               return new ExtClassLoader(dirs);
}               

        private static File[] getExtDirs() {
            String s = System.getProperty("java.ext.dirs");
            File[] dirs;
            if (s != null) {
                StringTokenizer st =
                    new StringTokenizer(s, File.pathSeparator);
                int count = st.countTokens();
                dirs = new File[count];
                for (int i = 0; i < count; i++) {
                    dirs[i] = new File(st.nextToken());
                }
            } else {
                dirs = new File[0];
            }
            return dirs;
        }

        //URLStreamHandlerFactory是Java中用于自定义URL协议处理程序的接口
        private static URLStreamHandlerFactory factory = new Factory();
        
        public ExtClassLoader(File[] dirs) throws IOException {
            //将file包装为URL,
            super(getExtURLs(dirs), null, factory);
            ...
        }
  
        private static URL[] getExtURLs(File[] dirs) throws IOException {
            // 将扩展类加载器所能加载的两个类路径下所有文件搜寻出来
            //把每一个文件都封装为一个file:协议URL
            Vector<URL> urls = new Vector<URL>();
            for (int i = 0; i < dirs.length; i++) {
                String[] files = dirs[i].list();
                if (files != null) {
                    for (int j = 0; j < files.length; j++) {
                        if (!files[j].equals("meta-index")) {
                            File f = new File(dirs[i], files[j]);
                            urls.add(getFileURL(f));
                        }
                    }
                }
            }
            URL[] ua = new URL[urls.size()];
            urls.copyInto(ua);
            return ua;
        }        

       //传入的类加载器是上面已经实例化好的扩展类加载器,这里作为应用程序上下文类加载器的双亲类加载器
       public static ClassLoader getAppClassLoader(final ClassLoader extcl)
            throws IOException {
            //获取环境上下文中定义的类路径
            final String s = System.getProperty("java.class.path");
            //getClassPath会利用分隔符切分类路径--和扩展类路径处理一个套路
            final File[] path = (s == null) ? new File[0] : getClassPath(s);
            //将path转换为url返回
            URL[] urls = (s == null) ? new URL[0] : pathToURLs(path);
           return new AppClassLoader(urls, extcl);
        }

        final URLClassPath ucp;
        AppClassLoader(URL[] urls, ClassLoader parent) {
            //调用到父类URLClassLoader的构造函数
            super(urls, parent, factory);
            //初始化URLClassPath--单独提供的
            ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);
            ucp.initLookupCache(this);
        }

File file = new File("/root/project/resource/config.xml")

URL getResource(String name)
InputStream getResourceAsStream(String name)
Enumeration<URL> getResources(String name)
getSystemResource, getSystemResources, getSystemResourceAsStream

/**
 * 类路径资源定位测试
 */
public class ClassPathTest {
    @Test
    public void classPathTest(){
        //情况1: 资源寻找路径=加载ClassPathTest的类加载器的类路径作为basePath+ClassPathTest的包名('.'替换为'/'后的路径)+资源文件名
        URL resource0 = ClassPathTest.class.getResource("a.txt");
        URL resource1 = ClassPathTest.class.getResource("b.txt");
        //情况2: 资源寻找路径=加载ClassPathTest的类加载器的类路径作为basePath+资源文件名
        URL resource2 = ClassPathTest.class.getResource("/a.txt");
        URL resource3 = ClassPathTest.class.getResource("/test.txt");
        //情况3: 资源寻找路径=加载ClassPathTest的类加载器的类路径作为basePath+资源文件名
        URL resource4 = ClassPathTest.class.getClassLoader().getResource("a.txt");
        URL resource5 = ClassPathTest.class.getClassLoader().getResource("test.txt");
        URL resource6 = ClassPathTest.class.getClassLoader().getResource("./a.txt");
        URL resource7 = ClassPathTest.class.getClassLoader().getResource("./test.txt");
        //情况4: 获取不到，无法被解析为相对于classpath的路径
        URL resource8 = ClassPathTest.class.getClassLoader().getResource("/a.txt");
        URL resource9 = ClassPathTest.class.getClassLoader().getResource("/test.txt");

        System.out.println(resource0);
        System.out.println(resource1);
        System.out.println(resource2);
        System.out.println(resource3);
        System.out.println(resource4);
        System.out.println(resource5);
        System.out.println(resource6);
        System.out.println(resource7);
        System.out.println(resource8);
        System.out.println(resource9);
    }
}

public class URLClassLoader extends SecureClassLoader implements Closeable {
    // 用于搜索class类资源和resource资源的urls集合
    private final URLClassPath ucp;

    public URLClassLoader(URL[] urls, ClassLoader parent,
                          URLStreamHandlerFactory factory) {
        //设置双亲类加载器                   
        super(parent);
        ...
        //初始化类路径集合
        ucp = new URLClassPath(urls, factory, acc);
    }

    public URLClassLoader(URL[] urls, ClassLoader parent,
                          URLStreamHandlerFactory factory) {
        //设置双亲类加载器
        super(parent);
        ...
        //初始化类路径管理器
        ucp = new URLClassPath(urls, factory, acc);
    }

    protected Class<?> findClass(final String name)
            throws ClassNotFoundException {
        final Class<?> result;
        //将全类名的.替换为/ ,最后加上.class
        String path = name.replace('.', '/').concat(".class");
        //拿着包路径加文件名组成的相对路径,去当前类加载器管理的类路径下匹配查找
        Resource res = ucp.getResource(path, false);
        //资源存在,则执行后续类加载步骤: 装载,链接,初始化
        if (res != null) {
            result = defineClass(name, res);
        } else {
            return null;
        }
        //资源不存在
        if (result == null) {
            throw new ClassNotFoundException(name);
        }
        return result;
    }

    public java.net.URL getResource(String name) {
        //判断是否需要对资源路径进行标准化处理--什么是标准化处理，下面会讲
        name = resolveName(name);
        //获取加载当前类的类加载器
        ClassLoader cl = getClassLoader0();
        //如果为空,使用系统类加载器 --- Bootstrap ClassLoader加载的系统类,它们的类加载器都为null
        if (cl==null) {
            // A system class. ---> 加载系统资源,怎么实现的，一会看看便知
            return ClassLoader.getSystemResource(name);
        }
        //调用类加载的getResource方法获取资源
        return cl.getResource(name);
    }

     public InputStream getResourceAsStream(String name) {
        name = resolveName(name);
        ClassLoader cl = getClassLoader0();
        if (cl==null) {
            // A system class.
            return ClassLoader.getSystemResourceAsStream(name);
        }
        return cl.getResourceAsStream(name);
    }

    private String resolveName(String name) {
        if (name == null) {
            return name;
        }
        if (!name.startsWith("/")) {
            Class<?> c = this;
            while (c.isArray()) {
                c = c.getComponentType();
            }
            String baseName = c.getName();
            int index = baseName.lastIndexOf('.');
            if (index != -1) {
                name = baseName.substring(0, index).replace('.', '/')
                    +"/"+name;
            }
        } else {
            name = name.substring(1);
        }
        return name;
    }

    public URL getResource(String name) {
        URL url;
        if (parent != null) {
            url = parent.getResource(name);
        } else {
            url = getBootstrapResource(name);
        }
        if (url == null) {
            url = findResource(name);
        }
        return url;
    }
    
    //ClassLoader的findResource方法是空实现,最终会调用到子类URLClassLoader的getResource方法
    protected URL findResource(String name) {
        return null;
    }    

    public URL findResource(final String name) {
        URL url =  ucp.findResource(name, true);
        return url != null ? ucp.checkURL(url) : null;
    }

private static URL getBootstrapResource(String name) {
    URLClassPath ucp = getBootstrapClassPath();
    Resource res = ucp.getResource(name);
    return res != null ? res.getURL() : null;
}

    ArrayList<Loader> loaders = new ArrayList<Loader>();

        Resource getResource(final String name, boolean check) {
            final URL url;
            try {
                //使用当前Loader管理的类路径作为baseUrl
                URL normalizedBase = new URL(getBaseURL(), ".");
                //baseUrl拼接资源相对路径得到完整的资源路径
                url = new URL(getBaseURL(), ParseUtil.encodePath(name, false));
                //判断请求资源是否在类路径之内。
                //如果请求资源的路径中包含了 ../ 等导航符，则需要先进行归一化处理，再比较是否在类路径之内。
                //如果请求的资源不在类路径之内，则返回 null，表示未找到该资源。  
                if (url.getFile().startsWith(normalizedBase.getFile()) == false) {
                    // requested resource had ../..'s in path
                    return null;
                }
                ...
                final File file;
                //判断资源相对路径中是否包含".."符号
                if (name.indexOf("..") != -1) {
                    //如果包含,那么将FileLoader的dir路径作为basePath--这里的dir路径也就是FileLoader能够处理的类路径
                    file = (new File(dir, name.replace('/', File.separatorChar)))
                          .getCanonicalFile();
                    //判断所请求的资源是否越过了类路径的范围
                    if ( !((file.getPath()).startsWith(dir.getPath())) ) {
                        /* outside of base dir */
                        return null;
                    }
                } else {
                    //资源相对路径中没有包含".."符号
                    //正常将当前FileLoader的类路径作为basePath
                    //拼接资源相对路径得到资源完整路径
                    file = new File(dir, name.replace('/', File.separatorChar));
                }
                
                //文件存在,那么构建Resource资源对象,然后返回
                if (file.exists()) {
                    return new Resource() {
                        public String getName() { return name; };
                        public URL getURL() { return url; };
                        public URL getCodeSourceURL() { return getBaseURL(); };
                        public InputStream getInputStream() throws IOException
                            { return new FileInputStream(file); };
                        public int getContentLength() throws IOException
                            { return (int)file.length(); };
                    };
                }
            } catch (Exception e) {
                return null;
            }
            return null;
        }

public URL findResource(String name, boolean check) {
    Loader loader;
    // 遍历loaders列表中的每一个loader，看看哪个Loader能够加载当前资源,如果能够加载，就直接返回
    for (int i = 0; (loader = getLoader(i)) != null; i++) {
        URL url = loader.findResource(name, check);
        if (url != null) { return url; }
    }
    return null;
}

public Resource getResource(String name, boolean check) {
    if (DEBUG) {
        System.err.println("URLClassPath.getResource(\"" + name + "\")");
    }

    Loader loader;
    for (int i = 0; (loader = getLoader(i)) != null; i++) {
        Resource res = loader.getResource(name, check);
        if (res != null) { return res;}
    }
    return null;
}

   //遍历当前URLClassPath内部所有Loader,挨个尝试加载资源,哪个先成功，就直接返回
    public URL findResource(String name, boolean check) {
        Loader loader;
         ...
        //重点在getNextLoader第一次被调用的时,会对loaders集合进行初始化
        for (int i = 0; (loader = getNextLoader(cache, i)) != null; i++) {
            URL url = loader.findResource(name, check);
            if (url != null) {
                return url;
            }
        }
        return null;
    }

    private synchronized Loader getNextLoader(int[] cache, int index) {
        if (closed) {
            return null;
        }
        //...
        return getLoader(index);
    }

private synchronized Loader getLoader(int index) {
        if (closed) {
            return null;
        }
         //按需创建Loader
        while (loaders.size() < index + 1) {
            // Pop the next URL from the URL stack
            URL url;
            //当urls栈为空时,说明所有Loaders都完成了初始化
            //也说明此时没有Loa
            synchronized (urls) {
                if (urls.empty()) {
                    return null;
                } else {
                    url = urls.pop();
                }
            }
            //检查给定的URL是否已经被处理过，如果已经被处理过，则跳过该URL，
            //URLClassPath内部维护了一个lmap，用来保存已经处理过的URL和对应的Loader；
            //给定的URL在lmap中已经存在，则说明该URL已经被处理过，可以直接跳过； 
            //如果给定的URL在lmap中不存在，则说明该URL尚未被处理过，需要创建对应的Loader，并加入到lmap和loaders列表中。
            String urlNoFragString = URLUtil.urlNoFragString(url);
            if (lmap.containsKey(urlNoFragString)) {
                continue;
            }
            Loader loader;
            try {
                //通过给定的URL创建并返回一个新的Loader对象
                //根据URL的不同，可以创建不同类型的Loader。
                //如果URL指向一个本地文件，就会创建FileLoader；
                //URL指向一个Jar文件，就会创建JarLoader。
                loader = getLoader(url);
                // If the loader defines a local class path then add the
                // URLs to the list of URLs to be opened.
                //在对于新的URL进行处理时，会获取这个URL对应的Loader，并查看Loader是否定义了本地的类路径。
                //如果定义了本地类路径，那么就会将本地类路径中的URL加入到URL栈中，
                //这样在后续的查找资源的过程中就可以继续遍历这些URL。
                URL[] urls = loader.getClassPath();
                if (urls != null) {
                    push(urls);
                }
            } ...
            // Finally, add the Loader to the search path.
            ...
            //将新创建的Loader,加入URLClasspath的loader集合汇总
            loaders.add(loader);
            //记录已经加载的 URL 对应的 Loader 对象
            //URL 在集合中不存在时，将会创建一个新的 Loader 对象，并添加到集合中，以便进行缓存，避免重复加载相同的 URL。
           // URL 在集合中已经存在时，则跳过该 URL，不再进行加载操作。这样可以有效地避免重复加载相同的 URL，提高了加载的效率。
            lmap.put(urlNoFragString, loader);
        }
        ...
        return loaders.get(index);
    }