compileSourceFile) {
super(parentClassLoader);
this.parentClassLoader = parentClassLoader;
this.sourceFileClasses = sourceFileClasses;
CodeSource codeSource;
try {
codeSource = new CodeSource(programDescriptor.fileObject().getFile().toUri().toURL(), (CodeSigner[])null);
} catch (MalformedURLException e) {
codeSource = null;
}
domain = new ProtectionDomain(codeSource, null, this, null);
this.moduleDescriptor = moduleDescriptor;
this.programDescriptor = programDescriptor;
this.compileSourceFile = compileSourceFile;
}
/**
* Override loadClass to check for classes defined in the source file
* before checking for classes in the parent class loader,
* including those on the classpath.
*
* {@code loadClass(String name)} calls this method, and so will have the same behavior.
*
* @param name the name of the class to load
* @param resolve whether to resolve the class
* @return the class
* @throws ClassNotFoundException if the class is not found
*/
@Override
protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class c = findLoadedClass(name);
if (c == null) {
c = findOrCompileClass(name);
if (c == null) {
c = parentClassLoader.loadClass(name);
}
if (resolve) {
resolveClass(c);
}
}
return c;
}
}
/**
* Override getResource to check for resources (i.e. class files) defined in the
* source file before checking resources in the parent class loader,
* including those on the class path.
*
* {@code getResourceAsStream(String name)} calls this method,
* and so will have the same behavior.
*
* @param name the name of the resource
* @return a URL for the resource, or null if not found
*/
@Override
public URL getResource(String name) {
if (sourceFileClasses.containsKey(toBinaryName(name))) {
return findResource(name);
}
URL resource = toResourceInRootPath(name);
if (resource != null) {
return resource;
}
return parentClassLoader.getResource(name);
}
/**
* Override getResources to check for resources (i.e. class files) defined in the
* source file before checking resources in the parent class loader,
* including those on the class path.
*
* @param name the name of the resource
* @return an enumeration of the resources in this loader and in the application class loader
*/
@Override
public Enumeration getResources(String name) throws IOException {
URL u = findResource(name);
Enumeration e = parentClassLoader.getResources(name);
if (u == null) {
return e;
} else {
List list = new ArrayList<>();
list.add(u);
while (e.hasMoreElements()) {
list.add(e.nextElement());
}
return Collections.enumeration(list);
}
}
@Override
protected Class findClass(String name) throws ClassNotFoundException {
var foundOrCompiledClass = findOrCompileClass(name);
if (foundOrCompiledClass == null) {
throw new ClassNotFoundException(name);
}
return foundOrCompiledClass;
}
@Override
protected Class findClass(String moduleName, String name) {
try {
if (moduleName == null) {
return findClass(name);
}
if (moduleDescriptor != null && moduleDescriptor.name().equals(moduleName)) {
return findClass(name);
}
return super.findClass(moduleName, name);
} catch (ClassNotFoundException ignore) { }
return null;
}
private Class findOrCompileClass(String name) {
byte[] bytes = sourceFileClasses.get(name);
if (bytes == null) {
bytes = compileSourceFile.apply(name);
if (bytes == null) {
return null;
}
}
return defineClass(name, bytes, 0, bytes.length, domain);
}
@Override
protected URL findResource(String moduleName, String name) throws IOException {
if (moduleName == null) {
return getResource(name);
}
if (moduleDescriptor != null && moduleDescriptor.name().equals(moduleName)) {
return getResource(name);
}
return super.findResource(moduleName, name);
}
@Override
public URL findResource(String name) {
String binaryName = toBinaryName(name);
if (binaryName == null || sourceFileClasses.get(binaryName) == null) {
return toResourceInRootPath(name);
}
URLStreamHandler handler = this.handler;
if (handler == null) {
this.handler = handler = new MemoryURLStreamHandler();
}
try {
var uri = new URI(PROTOCOL, name, null);
return URL.of(uri, handler);
} catch (URISyntaxException | MalformedURLException e) {
return null;
}
}
@Override
public Enumeration findResources(String name) {
return new Enumeration() {
private URL next = findResource(name);
@Override
public boolean hasMoreElements() {
return (next != null);
}
@Override
public URL nextElement() {
if (next == null) {
throw new NoSuchElementException();
}
URL u = next;
next = null;
return u;
}
};
}
/**
* Resolves a "resource name" (as used in the getResource* methods)
* to an existing file relative to source root path, or null otherwise.
*
* @param name the resource name
* @return the URL of the resource, or null
*/
private URL toResourceInRootPath(String name) {
try {
var path = Resources.toFilePath(programDescriptor.sourceRootPath(), name);
return path == null ? null : path.toUri().toURL();
} catch (IOException e) {
throw new UncheckedIOException(e);
} catch (IOError error) {
Throwable cause = error.getCause();
if (cause instanceof IOException e) {
throw new UncheckedIOException(e);
}
throw new RuntimeException(cause);
}
}
/**
* Converts a "resource name" (as used in the getResource* methods)
* to a binary name if the name identifies a class, or null otherwise.
*
* @param name the resource name
* @return the binary name
*/
private String toBinaryName(String name) {
if (!name.endsWith(".class")) {
return null;
}
return name.substring(0, name.length() - DOT_CLASS_LENGTH).replace('/', '.');
}
private static final int DOT_CLASS_LENGTH = ".class".length();
private final String PROTOCOL = "sourcelauncher-" + getClass().getSimpleName() + hashCode();
private URLStreamHandler handler;
/**
* A URLStreamHandler for use with URLs returned by MemoryClassLoader.getResource.
*/
private class MemoryURLStreamHandler extends URLStreamHandler {
@Override
public URLConnection openConnection(URL u) {
if (!u.getProtocol().equalsIgnoreCase(PROTOCOL)) {
throw new IllegalArgumentException(u.toString());
}
return new MemoryURLConnection(u, sourceFileClasses.get(toBinaryName(u.getPath())));
}
}
/**
* A URLConnection for use with URLs returned by MemoryClassLoader.getResource.
*/
private static class MemoryURLConnection extends URLConnection {
private final byte[] bytes;
private InputStream in;
MemoryURLConnection(URL u, byte[] bytes) {
super(u);
this.bytes = bytes;
}
@Override
public void connect() throws IOException {
if (!connected) {
if (bytes == null) {
throw new FileNotFoundException(getURL().getPath());
}
in = new ByteArrayInputStream(bytes);
connected = true;
}
}
@Override
public InputStream getInputStream() throws IOException {
connect();
return in;
}
@Override
public long getContentLengthLong() {
return bytes.length;
}
@Override
public String getContentType() {
return "application/octet-stream";
}
}
}