public ContextFinder(ClassLoader contextClassLoader) { super(contextClassLoader); this.parentContextClassLoader = contextClassLoader != null ? contextClassLoader : new ClassLoader(null) {/*parentless classloader*/}; }
public ContextFinder(ClassLoader contextClassLoader) { super(contextClassLoader); this.parentContextClassLoader = contextClassLoader != null ? contextClassLoader : new ClassLoader(Object.class.getClassLoader()) {/*boot classloader*/}; }
public ContextFinder(ClassLoader contextClassLoader) { super(contextClassLoader); this.parentContextClassLoader = contextClassLoader != null ? contextClassLoader : new ClassLoader(Object.class.getClassLoader()) {/*boot classloader*/}; }
public ContextFinder(ClassLoader contextClassLoader) { super(contextClassLoader); this.parentContextClassLoader = contextClassLoader != null ? contextClassLoader : new ClassLoader(Object.class.getClassLoader()) {/*boot classloader*/}; }
public ContextFinder(ClassLoader contextClassLoader) { super(contextClassLoader); this.parentContextClassLoader = contextClassLoader != null ? contextClassLoader : new ClassLoader(Object.class.getClassLoader()) {/*boot classloader*/}; }
public ContextFinder(ClassLoader contextClassLoader) { super(contextClassLoader); this.parentContextClassLoader = contextClassLoader != null ? contextClassLoader : new ClassLoader(Object.class.getClassLoader()) {/*boot classloader*/}; }
public ContextFinder(ClassLoader contextClassLoader) { super(contextClassLoader); this.parentContextClassLoader = contextClassLoader != null ? contextClassLoader : new ClassLoader(Object.class.getClassLoader()) {/*boot classloader*/}; }
ClassLoader cl = new UrlClassLoader(new URL[]{pathToClassAsUrl}); Class<?> compiledClass = cl.loadClass(stringClass);
ClassLoader classloader = new CustomClassLoader(); Class someClass = classloader.loadClass("com.example.SomeClass");
private static final ClassLoader classloader = new JarClassLoader(new InputStream[]{ Play.application().resourceAsStream("path/to/file.jar") }, ThisClass.class.getClassLoader());
void bootstrap() { URL commonUrl = // path to common.jar URL fooUrl; if (shouldUseFoo1()) { fooUrl = // path to Foo1.jar } else { fooUrl = // path fo Foo2.jar } URL[] urls = {fooUrl, commonUrl}; ClassLoader loader = new UrlClassLoader(urls); Class<?> mainClass = loader.loadClass("my.main"); mainClass.newInstance(); // start the app by invoking a constructor }
File janinoSourceDir = new File(PATH_TO_JAVAFILE); File[] srcDir = new File[] { janinoSourceDir }; String encoding = null; ClassLoader parentClassLoader = this.getClass().getClassLoader(); ClassLoader cl = new JavaSourceClassLoader(parentClassLoader, srcDir, encoding);
ClassLoader tClsLoader = new CCLoader(new FileInputStream("C:/commons-io-2.0.1.jar")); Class<?> tClass = tClsLoader.loadClass("org.apache.commons.io.FileExistsException");
ClassLoader myClassLoader = new MyClassLoader(ClassLoader.getSystemClassLoader()); Class<?> generatedClass = Class.forName("pkg.GeneratedClass", true, myClassLoader); Object instance = generatedClass.newInstance();
ClassLoader cl = Thread.currentThread().getContextClassLoader(); ClassLoader myClassLoader = new MyClassLoader(cl); // Try 'cl' before your custom class loading try { Thread.currentThread().setContextClassLoader(myClassLoader); // Do work that requires your ClassLoader to work } finally { // Always restore the previous CCL after work is done Thread.currentThread().setContextClassLoader(cl); }
ClassLoader previous = Thread.currentThread().getContextClassLoader(); try { ClassLoader cl = new AluniteClassLoader(new URL[]{new URL("file://path/to/websphere/client.jar")}, previous); Thread.currentThread().setContextClassLoader(cl); //Service lookup & method invocation } finally { Thread.currentThread().setContextClassLoader(previous); }
//Remember old one ClassLoader orginalClassLoader = Thread.currentThread().getContextClassLoader(); //Set my classloader ClassLoader myClassLoader = new SecureMVELClassLoader(); Thread.currentThread().setContextClassLoader(myClassLoader); System.out.println(MVEL.eval("new com.myapp.insecure.InsecureClass()")); //Set back to original classloader Thread.currentThread().setContextClassLoader(orginalClassLoader);
ClassLoader classLoader = new CustomClassLoader(ClassLoader.getSystemClassLoader()); Class stringClass = (new CustomClassLoader(ClassLoader.getSystemClassLoader())).findClass(packageName+"."+javaFileName); Object t = (Object) stringClass.newInstance();
void compileAndLoad(List<ICompilable> compilables) { Map<String,byte[]> compiled = new HashMap<>(compilables.size()); for(ICompilable c: compilables) compiled.put(c.getFullName(), genBytecode(c)); ClassLoader l = new ClassLoader(CLASS_LOADER) { @Override protected Class<?> findClass(String name) throws ClassNotFoundException { byte[] code = compiled.get(name); if(code == null) throw new ClassNotFoundException(name); return defineClass(name, code, 0, code.length); } }; // the code below this line is questionable; it seems you are relying // on the side effects of a class initializer for(String name: compiled.keySet()) try { Class.forName(name, true, l); } catch (ClassNotFoundException ex) { throw new AssertionError(ex); } }
public class Executor { public void run() { final MyInterface x = new MyClass(); x.f1(); x.f2(); } } public class Test { public static void main(char[] args) throws Exception { final ClassLoader customCl = new customClassLoader(); final Executor e = (Executor) Class.forName("Executor", true, customCl).newInstance(); e.run(); } }