Example usage for java.net URLClassLoader loadClass

List of usage examples for java.net URLClassLoader loadClass

  1. HOME
  2. Java
  3. java
  4. java.net.*
  5. URLClassLoader
  6. loadClass

Introduction

In this page you can find the example usage for java.net URLClassLoader loadClass.

Prototype

public Class<?> loadClass(String name) throws ClassNotFoundException

Source Link

Document

Loads the class with the specified binary name.

Usage

From source file:io.fabric8.maven.core.util.MavenUtil.java

/**
 * Returns true if all the given class names could be found on the given class loader
 *//*from w  ww. jav  a  2s.c  om*/
public static boolean hasAllClasses(MavenProject project, String... classNames) {
    URLClassLoader compileClassLoader = getCompileClassLoader(project);
    for (String className : classNames) {
        try {
            compileClassLoader.loadClass(className);
        } catch (Throwable e) {
            // ignore message
            return false;
        }
    }
    return true;
}

From source file:org.oscarehr.common.hl7.v2.oscar_to_oscar.DynamicHapiLoaderUtils.java

private static void setNoValidate(URLClassLoader classLoader, Class<?> pipedParserClass,
        Object pipedParserInstance)
        throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException,
        InvocationTargetException, SecurityException, NoSuchMethodException {
    Class<?> noValidateClass = classLoader.loadClass("ca.uhn.hl7v2.validation.impl.NoValidation");
    Object noValidateInstance = noValidateClass.newInstance();

    Class<?> validationContextClass = classLoader.loadClass("ca.uhn.hl7v2.validation.ValidationContext");

    Method noValidateMethod = pipedParserClass.getMethod("setValidationContext", validationContextClass);
    noValidateMethod.invoke(pipedParserInstance, new Object[] { noValidateInstance });
}

From source file:org.evosuite.junit.FooTestClassLoader.java

private static Class<?> loadClass(File javaBinDir) {

    URLClassLoader urlClassLoader = null;
    try {// w  w w . ja va  2s  .  c o  m
        URI javaBinURI = javaBinDir.toURI();
        URL javaBinURL = javaBinURI.toURL();
        urlClassLoader = new URLClassLoader(new URL[] { javaBinURL }, Foo.class.getClassLoader());
        Class<?> clazz = urlClassLoader.loadClass(FOO_TEST_CLASS_NAME);
        return clazz;
    } catch (ClassNotFoundException e) {
        return null;
    } catch (MalformedURLException e) {
        return null;
    }
}

From source file:fr.jayasoft.ivy.Main.java

private static void invoke(Ivy ivy, File cache, ModuleDescriptor md, String[] confs, String mainclass,
        String[] args) {//from   w  w  w . j  a  v a 2s.  c  om
    List urls = new ArrayList();

    try {
        XmlReportParser parser = new XmlReportParser();
        Collection all = new LinkedHashSet();
        for (int i = 0; i < confs.length; i++) {
            Artifact[] artifacts = parser.getArtifacts(md.getModuleRevisionId().getModuleId(), confs[i], cache);
            all.addAll(Arrays.asList(artifacts));
        }
        for (Iterator iter = all.iterator(); iter.hasNext();) {
            Artifact artifact = (Artifact) iter.next();

            urls.add(ivy.getArchiveFileInCache(cache, artifact).toURL());
        }
    } catch (Exception ex) {
        throw new RuntimeException("impossible to build ivy cache path: " + ex.getMessage(), ex);
    }

    URLClassLoader classLoader = new URLClassLoader((URL[]) urls.toArray(new URL[urls.size()]),
            Main.class.getClassLoader());

    try {
        Class c = classLoader.loadClass(mainclass);

        Method mainMethod = c.getMethod("main", new Class[] { String[].class });

        // Split up arguments 
        mainMethod.invoke(null, new Object[] { args });
    } catch (ClassNotFoundException cnfe) {
        throw new RuntimeException("Could not find class: " + mainclass, cnfe);
    } catch (SecurityException e) {
        throw new RuntimeException("Could not find main method: " + mainclass, e);
    } catch (NoSuchMethodException e) {
        throw new RuntimeException("Could not find main method: " + mainclass, e);
    } catch (IllegalAccessException e) {
        throw new RuntimeException("No permissions to invoke main method: " + mainclass, e);
    } catch (InvocationTargetException e) {
        throw new RuntimeException("Unexpected exception invoking main method: " + mainclass, e);
    }
}

From source file:org.apache.sysml.runtime.codegen.CodegenUtils.java

private static Class<?> compileClassJavac(String name, String src) {
    try {//from w w w  .  ja  v  a  2  s . c o m
        //create working dir on demand
        if (_workingDir == null)
            createWorkingDir();

        //write input file (for debugging / classpath handling)
        File ftmp = new File(_workingDir + "/" + name.replace(".", "/") + ".java");
        if (!ftmp.getParentFile().exists())
            ftmp.getParentFile().mkdirs();
        LocalFileUtils.writeTextFile(ftmp, src);

        //get system java compiler
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        if (compiler == null)
            throw new RuntimeException("Unable to obtain system java compiler.");

        //prepare file manager
        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null);

        //prepare input source code
        Iterable<? extends JavaFileObject> sources = fileManager
                .getJavaFileObjectsFromFiles(Arrays.asList(ftmp));

        //prepare class path 
        URL runDir = CodegenUtils.class.getProtectionDomain().getCodeSource().getLocation();
        String classpath = System.getProperty("java.class.path") + File.pathSeparator + runDir.getPath();
        List<String> options = Arrays.asList("-classpath", classpath);

        //compile source code
        CompilationTask task = compiler.getTask(null, fileManager, diagnostics, options, null, sources);
        Boolean success = task.call();

        //output diagnostics and error handling
        for (Diagnostic<? extends JavaFileObject> tmp : diagnostics.getDiagnostics())
            if (tmp.getKind() == Kind.ERROR)
                System.err.println("ERROR: " + tmp.toString());
        if (success == null || !success)
            throw new RuntimeException("Failed to compile class " + name);

        //dynamically load compiled class
        URLClassLoader classLoader = null;
        try {
            classLoader = new URLClassLoader(new URL[] { new File(_workingDir).toURI().toURL(), runDir },
                    CodegenUtils.class.getClassLoader());
            return classLoader.loadClass(name);
        } finally {
            IOUtilFunctions.closeSilently(classLoader);
        }
    } catch (Exception ex) {
        LOG.error("Failed to compile class " + name + ": \n" + src);
        throw new DMLRuntimeException("Failed to compile class " + name + ".", ex);
    }
}

From source file:gdt.data.entity.facet.ExtensionHandler.java

/**
 * Get the handler instance.  /*from  w w  w.j av a 2s .  c o m*/
 *  @param entigrator entigrator instance
 *  @param extension$ extension key
 *  @param handlerClass$ class name
 * @return handler instance.
 */

public static Object loadHandlerInstance(Entigrator entigrator, String extension$, String handlerClass$) {
    try {
        System.out.println(
                "ExtensionHandler:loadHandlerInstance:extension=" + extension$ + " handler=" + handlerClass$);

        Object obj = null;
        Class<?> cls = entigrator.getClass(handlerClass$);
        if (cls == null) {
            System.out.println("ExtensionHandler:loadHandlerInstance:1");
            Sack extension = entigrator.getEntityAtKey(extension$);
            String lib$ = extension.getElementItemAt("field", "lib");
            String jar$ = "jar:file:" + entigrator.getEntihome() + "/" + extension$ + "/" + lib$ + "!/";
            ArrayList<URL> urll = new ArrayList<URL>();
            urll.add(new URL(jar$));

            String[] sa = extension.elementListNoSorted("external");
            if (sa != null) {
                File file;
                for (String s : sa) {
                    file = new File(entigrator.getEntihome() + "/" + extension$ + "/" + s);
                    if (file.exists())
                        urll.add(new URL("jar:file:" + file.getPath() + "!/"));
                }
            }
            URL[] urls = urll.toArray(new URL[0]);
            URLClassLoader cl = URLClassLoader.newInstance(urls);

            //   Class<?>cls=entigrator.getClass(handlerClass$);

            cls = cl.loadClass(handlerClass$);

            if (cls == null) {
                System.out.println("ExtensionHandler:loadHandlerInstance:cannot load class =" + handlerClass$);
                return null;
            } else {
                //   System.out.println("ExtensionHandler:loadHandlerInstance:found class ="+handlerClass$);
                entigrator.putClass(handlerClass$, cls);
            }

        }

        try {

            Constructor[] ctors = cls.getDeclaredConstructors();
            System.out.println("ExtensionHandler:loadHandlerInstance:ctors=" + ctors.length);
            Constructor ctor = null;
            for (int i = 0; i < ctors.length; i++) {
                ctor = ctors[i];
                if (ctor.getGenericParameterTypes().length == 0)
                    break;
            }
            ctor.setAccessible(true);
            obj = ctor.newInstance();

        } catch (java.lang.NoClassDefFoundError ee) {
            System.out.println("ExtensionHandler:loadHandlerInstance:" + ee.toString());
            return null;
        }
        //if(obj!=null)
        System.out.println("ExtensionHandler:loadHandlerInstance:obj=" + obj.getClass().getName());
        return obj;
    } catch (Exception e) {
        Logger.getLogger(ExtensionHandler.class.getName()).severe(e.toString());
        return null;
    }

}

From source file:gdt.data.entity.facet.ExtensionHandler.java

private static FacetHandler[] listExtensionHandlers(Entigrator entigrator, String extension$) {
    try {//from  w  ww.  j a v  a 2s . c om
        System.out.println("ExtesionHandler:listExtensionHandlers:extension=" + extension$);
        Sack extension = entigrator.getEntityAtKey(extension$);
        String lib$ = extension.getElementItemAt("field", "lib");
        String[] sa = extension.elementList("content.fhandler");
        if (sa == null)
            return null;

        ArrayList<FacetHandler> fl = new ArrayList<FacetHandler>();
        FacetHandler fh;
        Class<?> cls;
        String jar$ = "jar:file:" + entigrator.getEntihome() + "/" + extension$ + "/" + lib$ + "!/";
        URL[] urls = { new URL(jar$) };
        URLClassLoader cl = URLClassLoader.newInstance(urls);
        for (String aSa : sa) {
            try {
                //         System.out.println("ExtesionHandler:listExtensionHandlers:jar="+jar$);
                cls = cl.loadClass(aSa);
                fh = (FacetHandler) cls.newInstance();
                fl.add(fh);
            } catch (Exception ee) {
                Logger.getLogger(ExtensionHandler.class.getName()).severe("load class: " + ee.toString());
            }
        }
        return fl.toArray(new FacetHandler[0]);
    } catch (Exception e) {
        Logger.getLogger(ExtensionHandler.class.getName()).severe(e.toString());
        return null;
    }
}

From source file:request.processing.ServletLoader.java

public static void loadServlet(String servletDir) {
    try {/*from  w w  w  . j  av a2s.c om*/
        JarFile jarFile = new JarFile(servletDir);
        Enumeration<JarEntry> e = jarFile.entries();

        URL[] urls = { new URL("jar:file:" + servletDir + "!/") };
        URLClassLoader cl = URLClassLoader.newInstance(urls);
        while (e.hasMoreElements()) {
            try {
                JarEntry je = (JarEntry) e.nextElement();
                if (je.isDirectory() || !je.getName().endsWith(".class")) {
                    continue;
                }
                String className = je.getName().substring(0, je.getName().length() - 6);
                className = className.replace('/', '.');
                Class c = cl.loadClass(className);
                if (Servlet.class.isAssignableFrom(c)) {
                    Constructor<Servlet> constructor = c.getConstructor();
                    Servlet i = constructor.newInstance();
                    namesToServlets.put(c.getSimpleName(), i);
                } else {
                    continue;
                }

            } catch (ClassNotFoundException cnfe) {
                System.err.println("Class not found");
                cnfe.printStackTrace();
            } catch (NoSuchMethodException e1) {
                System.err.println("No such method");
                e1.printStackTrace();
            } catch (SecurityException e1) {
                System.err.println("Security Exception");
                e1.printStackTrace();
            } catch (InstantiationException e1) {
                System.err.println("Instantiation Exception");
                e1.printStackTrace();
            } catch (IllegalAccessException e1) {
                System.err.println("IllegalAccessException");
                e1.printStackTrace();
            } catch (IllegalArgumentException e1) {
                System.err.println("IllegalArgumentException");
                e1.printStackTrace();
            } catch (InvocationTargetException e1) {
                System.err.println("InvocationTargetException");
                e1.printStackTrace();
            }

        }
        jarFile.close();
    } catch (IOException e) {
        System.err.println("Not a jarFile, no biggie. Moving on.");
    }
}

From source file:org.apache.stratos.cartridge.agent.statistics.publisher.PluginLoader.java

public static List<Class> loadPluginClassesFromJar(File jarPath, Class pluginInterface) {
    List<Class> listeners = new LinkedList<Class>();

    try {/*from  w  w  w .ja v  a2s. c  o m*/
        URLClassLoader loader = new URLClassLoader(new URL[] { jarPath.toURI().toURL() });
        JarFile jar = new JarFile(jarPath);
        Enumeration<? extends JarEntry> jarEnum = jar.entries();

        log.trace("Scanning jar file " + jarPath);

        while (jarEnum.hasMoreElements()) {
            ZipEntry zipEntry = jarEnum.nextElement();
            String fileName = zipEntry.getName();

            if (fileName.endsWith(".class")) {
                log.trace("Considering jar entry " + fileName);
                try {
                    String className = fileName.replace(".class", "").replace("/", ".");
                    Class cls = loader.loadClass(className);
                    log.trace("Loaded class " + className);

                    if (hasInterface(cls, pluginInterface)) {
                        log.trace("Class has " + pluginInterface.getName() + " interface; adding ");
                        listeners.add(cls);
                    }
                } catch (ClassNotFoundException e) {
                    log.error("Unable to load class from " + fileName + " in " + jarPath);
                }
            }
        }

    } catch (IOException e) {
        log.error("Unable to open JAR file " + jarPath, e);
    }

    return listeners;
}

From source file:org.eclipse.wb.internal.swing.laf.LafUtils.java

/**
 * Opens given <code>jarFile</code>, loads every class inside own {@link ClassLoader} and checks
 * loaded class for to be instance of {@link LookAndFeel}. Returns the array of {@link LafInfo}
 * containing all found {@link LookAndFeel} classes.
 * /*from w  w  w.j av a 2 s  .c om*/
 * @param jarFileName
 *          the absolute OS path pointing to source JAR file.
 * @param monitor
 *          the progress monitor which checked for interrupt request.
 * @return the array of {@link UserDefinedLafInfo} containing all found {@link LookAndFeel}
 *         classes.
 */
public static UserDefinedLafInfo[] scanJarForLookAndFeels(String jarFileName, IProgressMonitor monitor)
        throws Exception {
    List<UserDefinedLafInfo> lafList = Lists.newArrayList();
    File jarFile = new File(jarFileName);
    URLClassLoader ucl = new URLClassLoader(new URL[] { jarFile.toURI().toURL() });
    JarFile jar = new JarFile(jarFile);
    Enumeration<?> entries = jar.entries();
    while (entries.hasMoreElements()) {
        JarEntry entry = (JarEntry) entries.nextElement();
        String entryName = entry.getName();
        if (entry.isDirectory() || !entryName.endsWith(".class") || entryName.indexOf('$') >= 0) {
            continue;
        }
        String className = entryName.replace('/', '.').replace('\\', '.');
        className = className.substring(0, className.lastIndexOf('.'));
        Class<?> clazz = null;
        try {
            clazz = ucl.loadClass(className);
        } catch (Throwable e) {
            continue;
        }
        // check loaded class to be a non-abstract subclass of javax.swing.LookAndFeel class
        if (LookAndFeel.class.isAssignableFrom(clazz) && !Modifier.isAbstract(clazz.getModifiers())) {
            // use the class name as name of LAF
            String shortClassName = CodeUtils.getShortClass(className);
            // strip trailing "LookAndFeel"
            String lafName = StringUtils.chomp(shortClassName, "LookAndFeel");
            lafList.add(new UserDefinedLafInfo(StringUtils.isEmpty(lafName) ? shortClassName : lafName,
                    className, jarFileName));
        }
        // check for Cancel button pressed
        if (monitor.isCanceled()) {
            return lafList.toArray(new UserDefinedLafInfo[lafList.size()]);
        }
        // update ui
        while (DesignerPlugin.getStandardDisplay().readAndDispatch()) {
        }
    }
    return lafList.toArray(new UserDefinedLafInfo[lafList.size()]);
}