Ciao. Ho sempre avuto dei problemi con le soluzioni sopra (e su altri siti).
Come sviluppatore, sto programmando un componente aggiuntivo per un'API. L'API impedisce l'uso di librerie esterne o strumenti di terze parti. L'installazione consiste anche in una combinazione di codice in file jar o zip e file di classe che si trovano direttamente in alcune directory. Quindi il mio codice doveva essere in grado di funzionare in qualsiasi configurazione. Dopo molte ricerche ho escogitato un metodo che funzionerà in almeno il 95% di tutte le configurazioni possibili.
Il seguente codice è sostanzialmente il metodo overkill che funzionerà sempre.
Il codice:
Questo codice analizza un determinato pacchetto per tutte le classi incluse in esso. Funzionerà solo per tutte le classi in corso ClassLoader.
/**
* Private helper method
*
* @param directory
* The directory to start with
* @param pckgname
* The package name to search for. Will be needed for getting the
* Class object.
* @param classes
* if a file isn't loaded but still is in the directory
* @throws ClassNotFoundException
*/
private static void checkDirectory(File directory, String pckgname,
ArrayList<Class<?>> classes) throws ClassNotFoundException {
File tmpDirectory;
if (directory.exists() && directory.isDirectory()) {
final String[] files = directory.list();
for (final String file : files) {
if (file.endsWith(".class")) {
try {
classes.add(Class.forName(pckgname + '.'
+ file.substring(0, file.length() - 6)));
} catch (final NoClassDefFoundError e) {
// do nothing. this class hasn't been found by the
// loader, and we don't care.
}
} else if ((tmpDirectory = new File(directory, file))
.isDirectory()) {
checkDirectory(tmpDirectory, pckgname + "." + file, classes);
}
}
}
}
/**
* Private helper method.
*
* @param connection
* the connection to the jar
* @param pckgname
* the package name to search for
* @param classes
* the current ArrayList of all classes. This method will simply
* add new classes.
* @throws ClassNotFoundException
* if a file isn't loaded but still is in the jar file
* @throws IOException
* if it can't correctly read from the jar file.
*/
private static void checkJarFile(JarURLConnection connection,
String pckgname, ArrayList<Class<?>> classes)
throws ClassNotFoundException, IOException {
final JarFile jarFile = connection.getJarFile();
final Enumeration<JarEntry> entries = jarFile.entries();
String name;
for (JarEntry jarEntry = null; entries.hasMoreElements()
&& ((jarEntry = entries.nextElement()) != null);) {
name = jarEntry.getName();
if (name.contains(".class")) {
name = name.substring(0, name.length() - 6).replace('/', '.');
if (name.contains(pckgname)) {
classes.add(Class.forName(name));
}
}
}
}
/**
* Attempts to list all the classes in the specified package as determined
* by the context class loader
*
* @param pckgname
* the package name to search
* @return a list of classes that exist within that package
* @throws ClassNotFoundException
* if something went wrong
*/
public static ArrayList<Class<?>> getClassesForPackage(String pckgname)
throws ClassNotFoundException {
final ArrayList<Class<?>> classes = new ArrayList<Class<?>>();
try {
final ClassLoader cld = Thread.currentThread()
.getContextClassLoader();
if (cld == null)
throw new ClassNotFoundException("Can't get class loader.");
final Enumeration<URL> resources = cld.getResources(pckgname
.replace('.', '/'));
URLConnection connection;
for (URL url = null; resources.hasMoreElements()
&& ((url = resources.nextElement()) != null);) {
try {
connection = url.openConnection();
if (connection instanceof JarURLConnection) {
checkJarFile((JarURLConnection) connection, pckgname,
classes);
} else if (connection instanceof FileURLConnection) {
try {
checkDirectory(
new File(URLDecoder.decode(url.getPath(),
"UTF-8")), pckgname, classes);
} catch (final UnsupportedEncodingException ex) {
throw new ClassNotFoundException(
pckgname
+ " does not appear to be a valid package (Unsupported encoding)",
ex);
}
} else
throw new ClassNotFoundException(pckgname + " ("
+ url.getPath()
+ ") does not appear to be a valid package");
} catch (final IOException ioex) {
throw new ClassNotFoundException(
"IOException was thrown when trying to get all resources for "
+ pckgname, ioex);
}
}
} catch (final NullPointerException ex) {
throw new ClassNotFoundException(
pckgname
+ " does not appear to be a valid package (Null pointer exception)",
ex);
} catch (final IOException ioex) {
throw new ClassNotFoundException(
"IOException was thrown when trying to get all resources for "
+ pckgname, ioex);
}
return classes;
}
Questi tre metodi ti offrono la possibilità di trovare tutte le classi in un determinato pacchetto.
Lo usi in questo modo:
getClassesForPackage("package.your.classes.are.in");
La spiegazione:
Il metodo prima ottiene la corrente ClassLoader. Recupera quindi tutte le risorse che contengono detto pacchetto e itera questi URLs. Quindi crea un URLConnectione determina quale tipo di URl abbiamo. Può essere una directory ( FileURLConnection) o una directory all'interno di un file jar o zip ( JarURLConnection). A seconda del tipo di connessione, verranno chiamati due metodi diversi.
Per prima cosa vediamo cosa succede se è un FileURLConnection.
Controlla innanzitutto se il file passato esiste ed è una directory. In tal caso, controlla se si tratta di un file di classe. In tal caso Class, verrà creato e inserito un oggetto ArrayList. Se non è un file di classe ma è una directory, semplicemente eseguiamo l'iterazione e facciamo la stessa cosa. Tutti gli altri casi / file verranno ignorati.
Se URLConnectionè un JarURLConnection, verrà chiamato l'altro metodo di supporto privato. Questo metodo scorre su tutte le voci nell'archivio zip / jar. Se una voce è un file di classe ed è all'interno del pacchetto Class, verrà creato e archiviato un oggetto nel file ArrayList.
Dopo che tutte le risorse sono state analizzate (il metodo principale) restituisce il ArrayListcontenimento di tutte le classi in un determinato pacchetto, che la corrente ClassLoaderconosce.
Se il processo fallisce in qualsiasi momento ClassNotFoundExceptionverrà lanciato un conteggio di informazioni dettagliate sulla causa esatta.