Loading classes with reflection

Question

hello,
I have a package named CSP with an Interface A.
this package(distributed as jar) may change during time, so I would like that my gui updates its components list, which consists in all CSP's classes implementing interface A.
How can I determine what are all classes, inside CSP, implementing A?
Thanks.
Paolo

Answer 1

Since I have done that a couple years ago :-)
* Finds all classes from any given set of locations that implement any given interface.
* @author Jean-Francois Briere
import java.io.*;
import java.util.*;
import java.util.zip.*;
import java.net.*;
import java.lang.reflect.*;
public class InterfaceFinder
    public InterfaceFinder()
     * Finds all classes from any given set of locations that implement any given interface.
     * @param interfaceName Name of interface to search for classes that implement it.
     * @param classPath String of folder and/or archive name, separated by the classpath separator,
     *                  that represents the locations to search the classes.
     * @return An array of 0 to more InterfaceFinder.Result objects,
     *         one per location that has implemented classes.
    public InterfaceFinder.Result[] findImplementingClasses(String interfaceName, String classPath)
        return findImplementingClasses(interfaceName, readClassPath(classPath));
     * Finds all classes from any given set of locations that implement any given interface.
     * @param interfaceName Name of interface to search for classes that implement it.
     * @param fileArr Array of folder and/or archive File objects that represents the locations to search the classes.
     * @return An array of 0 to more InterfaceFinder.Result objects,
     *         one per location that has implemented classes.
    public InterfaceFinder.Result[] findImplementingClasses(String interfaceName, File[] fileArr)
        URL[] urlArr = convertToUrls(fileArr);
        URLClassLoader ucl = new URLClassLoader(urlArr);
        ArrayList resList = new ArrayList();
        for (int i = 0; i < urlArr.length; i++)
            File file = new File(urlArr.getPath());
String ext = file.getName().toLowerCase();
ArrayList classList = new ArrayList();
if (ext.endsWith(".jar"))
findInZip(file, ucl, interfaceName, classList);
else if (ext.endsWith(".zip"))
findInZip(file, ucl, interfaceName, classList);
else // dir
findInDir(file, ucl, interfaceName, classList);
if (classList.size() > 0)
InterfaceFinder.Result result = new InterfaceFinder.Result();
Class[] classArr = new Class[classList.size()];
classList.toArray(classArr);
result.interfaceName = interfaceName;
result.location = file;
result.implementingClasses = classArr;
resList.add(result);
InterfaceFinder.Result[] resArr = new InterfaceFinder.Result[resList.size()];
resList.toArray(resArr);
return resArr;
private File[] readClassPath(String classPath)
StringTokenizer strTok = new StringTokenizer(classPath, File.pathSeparator);
List fileList = new ArrayList();
while (strTok.hasMoreTokens())
fileList.add(new File(strTok.nextToken()));
File[] fileArr = new File[fileList.size()];
fileList.toArray(fileArr);
return fileArr;
* This converts to URL objects only File objects that represents existing files
* which are directories, jar or zip files. So any other File objects are skipped.
private URL[] convertToUrls(File[] fileArr)
List urlList = new ArrayList();
for (int i = 0; i < fileArr.length; i++)
try
if (fileArr[i].isDirectory())
urlList.add(fileArr[i].toURL());
else if (fileArr[i].exists())
String ext = fileArr[i].getName().toLowerCase();
if (ext.endsWith(".jar"))
urlList.add(fileArr[i].toURL());
else if (ext.endsWith(".zip"))
urlList.add(fileArr[i].toURL());
catch (MalformedURLException e)
URL[] urlArr = new URL[urlList.size()];
urlList.toArray(urlArr);
return urlArr;
private void findInDir(File dir, URLClassLoader ucl, String interfaceName, ArrayList classList)
FileFilter filter = new FileFilter()
public boolean accept(File pathname)
if (pathname.isDirectory())
return true;
else if (pathname.getName().toLowerCase().endsWith(".class"))
return true;
return false;
findInDir0(dir, dir, ucl, interfaceName, filter, classList);
private void findInDir0(File root, File dir, URLClassLoader ucl, String interfaceName, FileFilter filter, ArrayList classList)
File[] fileArr = dir.listFiles(filter);
if (fileArr == null)
return;
for (int i = 0; i < fileArr.length; i++)
if (fileArr[i].isDirectory())
findInDir0(root, fileArr[i], ucl, interfaceName, filter, classList);
else // .class files
String fileName = fileArr[i].getPath().substring(root.getPath().length() + 1);
String className = convertFileToClassName(fileName);
verifyInterface(className, ucl, interfaceName, classList);
private void findInZip(File file, URLClassLoader ucl, String interfaceName, ArrayList classList)
ZipFile zipFile = null;
try
zipFile = new ZipFile(file);
Enumeration enum = zipFile.entries();
while (enum.hasMoreElements())
ZipEntry entry = (ZipEntry)enum.nextElement();
String entryName = entry.getName();
if (entryName.endsWith(".class"))
String className = convertFileToClassName(entryName);
verifyInterface(className, ucl, interfaceName, classList);
catch (IOException e)
finally // be sure to close the archive
if (zipFile != null)
try { zipFile.close(); }
catch (IOException e) {}
private String convertFileToClassName(String fileName)
String className = fileName.substring(0, fileName.length() - 6); // remove .class
className = className.replace('/', '.');
className = className.replace('\\', '.');
return className;
private void verifyInterface(String className, URLClassLoader ucl, String interfaceName, ArrayList classList)
try
Class cls = Class.forName(className, false, ucl);
if (cls.isInterface())
return;
Class cls0 = cls;
while (cls0 != null)
if (verifyInterface0(cls0, interfaceName))
classList.add(cls);
break;
cls0 = cls0.getSuperclass(); // search for possible parent class
catch (Exception e)
private boolean verifyInterface0(Class cls0, String interfaceName)
Class[] interfaceArr = cls0.getInterfaces();
for (int i = 0; i < interfaceArr.length; i++)
if (interfaceArr[i].getName().equals(interfaceName))
return true;
else
return verifyInterface0(interfaceArr[i], interfaceName); // search for possible parent interfaces
return false;
* Holder of the location and its classes found to implement the named interface.
public class Result
public String interfaceName;
public File location;
public Class[] implementingClasses;
This is very easy to use.
For instance if you want to look for the a.b.c.TestIf interface on different folder/jar locations:
InterfaceFinder.Result[] resultArray = new InterfaceFinder().findImplementingClasses("a.b.c.TestIf", "someFolder;someJarFile;someOtherJarFile");