private ModuleReference getModuleReference(String moduleKey, URL[] urls, boolean loadFromModuleFirst) { ModuleReference mr = moduleRefs.get(moduleKey); if (mr == null) { mr = new ModuleReference(this, moduleKey, new ModuleClassLoader(moduleKey, platformClassLoader, urls, loadFromModuleFirst), false); ModuleReference prev = moduleRefs.putIfAbsent(moduleKey, mr); if (prev != null) { mr = prev; } } return mr; }
@Override public synchronized Enumeration<URL> getResources(String name) throws IOException { final List<URL> totURLs = new ArrayList<>(); // And platform class loader too addURLs(totURLs, platformClassLoader.getResources(name)); Set<ModuleClassLoader> toWalk = getModulesToWalk(); for (ModuleClassLoader cl: toWalk) { Enumeration<URL> urls = cl.findResources(name); addURLs(totURLs, urls); } return new Enumeration<URL>() { Iterator<URL> iter = totURLs.iterator(); public boolean hasMoreElements() { return iter.hasNext(); } public URL nextElement() { return iter.next(); } }; }
private void computeModules(Set<ModuleClassLoader> mods) { // We do a depth first search and refuse to go down paths we've already walked to avoid getting stuck in a loop for (ModuleReference mod: references) { if (!mods.contains(mod.mcl)) { mods.add(mod.mcl); mod.mcl.computeModules(mods); } } }
protected Class<?> doLoadClass(String name) { Class<?> c = findLoadedClass(name); if (c == null) { try { c = findClass(name); } catch (ClassNotFoundException e) { return null; } catch (LinkageError le) { c = findLoadedClass(name); if (c == null) { throw le; } } } return c; }
@Override public synchronized URL getResource(String name) { URL url = platformClassLoader.getResource(name); if (url == null) { Set<ModuleClassLoader> toWalk = getModulesToWalk(); for (ModuleClassLoader cl: toWalk) { url = cl.findResource(name); if (url != null) { return url; } } } return url; }
private Class<?> loadFromModule(String name) throws ClassNotFoundException { Class<?> c = null; Set<ModuleClassLoader> toWalk = getModulesToWalk(); for (ModuleClassLoader cl: toWalk) { c = cl.doLoadClass(name); if (c != null) { break; } } if (c == null) { throw new ClassNotFoundException(name); } return c; }
@Override protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { Class<?> c = findLoadedClass(name); if (c != null) { return c; } if (loadFromModuleFirst) { try { c = loadFromModule(name); } catch (ClassNotFoundException e) { c = platformClassLoader.loadClass(name); } } else { try { c = platformClassLoader.loadClass(name); } catch (ClassNotFoundException e) { c = loadFromModule(name); } } if (resolve) { resolveClass(c); } return c; }
new ModuleClassLoader(modID.toString(), platformClassLoader, info.cp.toArray(new URL[info.cp.size()]), fields.isLoadFromModuleFirst()), res); if (mr.mcl.addReference(includedMr)) { includedMr.incRef();
synchronized void decRef() { refCount--; if (!resident && refCount == 0) { mgr.removeModule(moduleKey); mcl.close(); if (factory != null) { factory.close(); } } }
if (mr.mcl.addReference(parentRef)) { parentRef.incRef();
boolean res = fields.isResident(); mr = new ModuleReference(this, modID.toString(), new ModuleClassLoader(modID.toString(), platformClassLoader, moduleClasspath.toArray(new URL[moduleClasspath.size()]), fields.isLoadFromModuleFirst()), res); if (mr.mcl.addReference(parentRef)) { parentRef.incRef();
private Set<ModuleClassLoader> getModuleGraph() { if (modGraph == null) { modGraph = new LinkedHashSet<>(); modGraph.add(this); computeModules(modGraph); } return modGraph; }