org.bbottema.javareflection.util.ExternalClassLoader Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of java-reflection Show documentation
Show all versions of java-reflection Show documentation
Java Reflection provides a small package with nifty reflection features that will help with finding constructors, methods and value conversions
package org.bbottema.javareflection.util;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
/**
* A toolkit that can read and compile .java sourcefiles on the fly in runtime. This class loader caches loaded classes for
* repeated requests. Also, if a .class file already exists for a specific .java sourcefile, the classloader will compare dates and see if
* the .java needs recompiling.
*
* A basepath can be specified for the classloader to look in for sourcefiles.
*/
public final class ExternalClassLoader extends ClassLoader {
/**
* base path used to locate [packaged] classes in
*/
@Nullable
private String basepath;
/**
* List of classes. These are non-instances of a class, of which instances can be spawn.
*/
@NotNull
private final Map> classes = new HashMap<>();
/**
* The exception that was thrown when the class was actually found but some other error occurred.
*/
@Nullable
@SuppressWarnings("FieldCanBeLocal")
private CompileException exception;
/**
* Constructor which initializes all properties.
*/
public ExternalClassLoader() {
super(ExternalClassLoader.class.getClassLoader());
}
/**
* Loads a class from the classes cache if available. Delegates to {@link #findClass(String)} otherwise.
*
* @see ClassLoader#loadClass(String)
*/
@Override
@Nullable
public final Class loadClass(final String className)
throws ClassNotFoundException {
final Class c = classes.get(className);
return (c != null) ? c : findClass(className);
}
/**
* Loads a classfile from file in the following order:
*
* - looks for the java source and if available, checks whether it needs to be compiled
* - if no .java or .class file found, try to find it in the VM
*
* If the class ultimately wasn't found a ClassNotFoundException is being thrown. If class was found, but an error
* occurred, store exception for later review and return null. This is done so because the overridden method can't throw an
* exception other than ClassNotFoundException.
*
* @param className The path and name to the classfile.
* @return The requested class reference.
* @throws ClassNotFoundException Thrown by {@link #findSystemClass(String)}.
*/
@SuppressWarnings("WeakerAccess")
@Override
@Nullable
public final Class findClass(final String className)
throws ClassNotFoundException {
exception = null;
try {
// try to load, cache and return the class from compiled .class file
checkForFile(basepath, className);
// if a classfile is available then load it
final Class c = classes.get(className);
if (c != null) {
return c;
} else {
throw new ClassNotFoundException();
}
} catch (final ClassNotFoundException e) {
// - see if class can be found in the VM
// - this check must come last, else you won't detect whether a classfile has been recompiled
final Class c = findSystemClass(className);
classes.put(className, c);
return c;
} catch (final IOException e) {
exception = new CompileException(e.getMessage(), e);
return null;
} catch (final CompileException e) {
exception = e;
return null;
}
}
/**
* Reads and compiles the sourcefile from filesystem and creates the class inside the VM.
*
* @param className The path and name to the .java sourcefile.
*/
private void checkForFile(final String classPath, final String className)
throws IOException {
// figure paths...
final String resource = className.replace("..", "||").replace('.', File.separatorChar).replace("||", "..");
final File javaSource = new File(classPath + File.separatorChar + resource + ".java");
final File javaClass = new File(classPath + File.separatorChar + resource + ".class");
final String absoluteClassPath = javaClass.getAbsolutePath();
// see if there is a javafile and classfile
if (javaSource.exists()) {
// if classfile available, delete if outdated
if (javaClass.exists()) {
// determine if the java sourcefile has been modified since last compile
// else check if the .class file has already been loaded
if (javaSource.lastModified() > javaClass.lastModified()) {
if (!javaClass.delete()) {
throw new CompileException("runtime compiler: unable to removed outdated .class file");
}
classes.remove(className);
} else if (classes.get(className) == null) {
classes.put(className, loadClass(absoluteClassPath, className));
}
}
// if no classfile available or became outdated
if (!javaClass.exists()) {
final int status = 0;// Main.compile(args);
// load compiled classfile and cache it or return error that occured during compiling
switch (status) {
case 0:
classes.put(className, loadClass(absoluteClassPath, className));
break;
case 1:
throw new CompileException("runtime compiler: ERROR");
case 2:
throw new CompileException("runtime compiler: CMDERR");
case 3:
throw new CompileException("runtime compiler: SYSERR");
case 4:
throw new CompileException("runtime compiler: ABNORMAL");
default:
throw new CompileException("Compile status: Unknown exit status");
}
}
}
}
/**
* Reads the classfile from filesystem.
*
* @param classPath The path and name to the classfile.
* @param className The name of the class to use as key for the Class reference value.
*/
private Class loadClass(final String classPath, final String className)
throws IOException {
// get data from file
final File f = new File(classPath);
final int size = (int) f.length();
final byte buff[] = new byte[size];
final DataInputStream dis = new DataInputStream(new FileInputStream(f));
dis.readFully(buff);
dis.close();
// convert data into class
return defineClass(className, buff, 0, buff.length, null);
}
/**
* Parameterized exception used when Java's runtime compiler fails to compile a Java source file.
*/
public static class CompileException extends RuntimeException {
private static final long serialVersionUID = -7210219718456902667L;
/**
* @param reason The description of the cause of the exception.
*/
CompileException(final String reason) {
super(reason);
}
/**
* Used to create an exception with a copies stacktrace (using {@link #setStackTrace(StackTraceElement[])}).
*
* @param reason The description of the cause of the exception.
* @param cause A thrown exception that is the cause.
*/
CompileException(final String reason, final Throwable cause) {
super(reason + "\n " + cause.toString());
setStackTrace(cause.getStackTrace());
}
}
/**
* Sets the base path this classloader will look for classes in.
*
* @param basepath A folder path to look for classes.
*/
public void setBasepath(@Nullable final String basepath) {
this.basepath = basepath;
}
@Nullable
public String getBasepath() {
return basepath;
}
@Nullable
public CompileException getException() {
return exception;
}
}