Trouver une classe quelque part dans des dizaines de fichiers JAR?

Comment trouver un nom de classe particulier dans de nombreux fichiers jar?

(Recherche du nom de classe réel, pas des classes qui le référencent.)

Eclipse peut le faire, il suffit de créer un projet (temporaire) et de placer vos bibliothèques sur le classpath des projets. Ensuite, vous pouvez facilement trouver les classes.

Un autre outil qui me vient à l’esprit est Java Decomstackr. Il peut ouvrir beaucoup de bocaux à la fois et aide également à trouver des cours.

Unix

Utilisez les commandes jar (ou unzip -v ), grep et find .

Par exemple, les éléments suivants répertorient tous les fichiers de classe correspondant à un nom donné:

 for i in *.jar; do jar -tvf "$i" | grep -Hsi ClassName && echo "$i"; done 

Si vous connaissez la liste complète des archives Java que vous souhaitez rechercher, vous pouvez les placer toutes dans le même répertoire en utilisant des liens (symboliques).

Ou utilisez find (avec sensibilité à la casse) pour trouver le fichier JAR contenant un nom de classe donné:

 find path/to/libs -name '*.jar' -exec grep -Hls ClassName {} \; 

Par exemple, pour trouver le nom de l’archive contenant IdentityHashingStrategy :

 $ find . -name "*.jar" -exec grep -Hsli IdentityHashingStrategy {} \; ./trove-3.0.3.jar 

Si le fichier JAR peut se trouver n’importe où dans le système et que la commande de locate est disponible:

 for i in $(locate "*.jar"); do echo $i; jar -tvf $i | grep -Hsi ClassName; done 

les fenêtres

Ouvrez une invite de commande , accédez au répertoire (ou au répertoire ancêtre) contenant les fichiers JAR, puis:

 for /R %G in (*.jar) do @jar -tvf "%G" | find "ClassName" > NUL && echo %G 

Voici comment cela fonctionne:

  1. for /R %G in (*.jar) do – boucle sur tous les fichiers JAR, parcourant récursivement les répertoires; stocker le nom du fichier dans% G.
  2. @jar -tvf "%G" | – exécuter la commande Java Archive pour répertorier tous les noms de fichiers dans l’archive donnée et écrire les résultats dans la sortie standard; le symbole @ supprime l’impression de l’invocation de la commande.
  3. find "ClassName" > NUL – recherche entrée standard, provenant de la sortie de la commande jar, pour le nom de classe donné; Cela placera ERRORLEVEL à 1 si il n’y a pas de correspondance (sinon 0).
  4. && echo %G – si ERRORLEVEL est différent de zéro, écrivez le nom du fichier d’archive Java sur la sortie standard (la console).

Web

Utilisez un moteur de recherche qui parsing les fichiers JAR .

il y a quelque temps, j’ai écrit un programme juste pour cela: https://github.com/javalite/jar-explorer

 grep -l "classname" *.jar 

vous donne le nom du pot

 find . -name "*.jar" -exec jar -t -f {} \; | grep "classname" 

vous donne le paquet de la classe

 #!/bin/bash pattern=$1 shift for jar in $(find $* -type f -name "*.jar") do match=`jar -tvf $jar | grep $pattern` if [ ! -z "$match" ] then echo "Found in: $jar" echo "$match" fi done 

Je ne connaissais pas d’utilitaire pour le faire quand je suis tombé sur ce problème, alors j’ai écrit ceci:

 public class Main { /** * */ private static Ssortingng CLASS_FILE_TO_FIND = "class.to.find.Here"; private static List foundIn = new LinkedList(); /** * @param args the first argument is the path of the file to search in. The second may be the * class file to find. */ public static void main(Ssortingng[] args) { if (!CLASS_FILE_TO_FIND.endsWith(".class")) { CLASS_FILE_TO_FIND = CLASS_FILE_TO_FIND.replace('.', '/') + ".class"; } File start = new File(args[0]); if (args.length > 1) { CLASS_FILE_TO_FIND = args[1]; } search(start); System.out.println("------RESULTS------"); for (Ssortingng s : foundIn) { System.out.println(s); } } private static void search(File start) { try { final FileFilter filter = new FileFilter() { public boolean accept(File pathname) { return pathname.getName().endsWith(".jar") || pathname.isDirectory(); } }; for (File f : start.listFiles(filter)) { if (f.isDirectory()) { search(f); } else { searchJar(f); } } } catch (Exception e) { System.err.println("Error at: " + start.getPath() + " " + e.getMessage()); } } private static void searchJar(File f) { try { System.out.println("Searching: " + f.getPath()); JarFile jar = new JarFile(f); ZipEntry e = jar.getEntry(CLASS_FILE_TO_FIND); if (e == null) { e = jar.getJarEntry(CLASS_FILE_TO_FIND); if (e != null) { foundIn.add(f.getPath()); } } else { foundIn.add(f.getPath()); } } catch (IOException e) { e.printStackTrace(); } } } 

Pour localiser les jars correspondant à une chaîne donnée:

find . -name \*.jar -exec grep -l YOUR_CLASSNAME {} \;

Il existe également deux utilitaires différents appelés “JarScan” qui font exactement ce que vous demandez: JarScan (inetfeedback.com) et JarScan (java.net)

Le script user1207523 fonctionne très bien pour moi. Voici une variante qui recherche les fichiers jar de manière récurrente en utilisant find au lieu de simple expansion;

 #!/bin/bash for i in `find . -name '*.jar'`; do jar -tf "$i" | grep $1 | xargs -I{} echo -e "$i : {}" ; done 

Je l’ai toujours utilisé sous Windows et cela a fonctionné exceptionnellement bien.

 findstr /s /m /c:"package/classname" *.jar, where 

findstr.exe est livré en standard avec Windows et les parameters:

  • / s = récursivement
  • / m = affiche uniquement le nom du fichier s’il y a une correspondance
  • / c = chaîne littérale (dans ce cas, le nom de votre package + les noms de classe séparés par ‘/’)

J’espère que cela aide quelqu’un.

Une solution de bash script utilisant unzip (zipinfo) . Testé sur Ubuntu 12 .

 #!/bin/bash # ./jarwalker.sh "/a/Starting/Path" "aClassName" IFS=$'\n' jars=( $( find -P "$1" -type f -name "*.jar" ) ) for jar in ${jars[*]} do classes=( $( zipinfo -1 ${jar} | awk -F '/' '{print $NF}' | grep .class | awk -F '.' '{print $1}' ) ) if [ ${#classes[*]} -ge 0 ]; then for class in ${classes[*]} do if [ ${class} == "$2" ]; then echo "Found in ${jar}" fi done fi done 

J’ai trouvé cette nouvelle façon

 bash $ ls -1 | xargs -i -t jar -tvf '{}'| grep Abstract jar -tvf activation-1.1.jar jar -tvf antisamy-1.4.3.jar 2263 Thu Jan 13 21:38:10 IST 2011 org/owasp/validator/html/scan/AbstractAntiSamyScanner.class ... 

Donc, cela répertorie le jar et la classe si elle est trouvée, si vous voulez, vous pouvez donner ls -1 * .jar ou entrer xargs avec find command HTH Someone.

Vérifiez JBoss Tattletale ; Même si je ne l’ai jamais utilisé personnellement, cela semble être l’outil qu’il vous faut.

Utilisez simplement FindClassInJars util, c’est un simple programme swing, mais utile. Vous pouvez vérifier le code source ou télécharger le fichier JAR à l’ adresse http://code.google.com/p/find-class-in-jars/.

Je ne sais pas pourquoi les scripts ici n’ont jamais vraiment fonctionné pour moi. Cela marche:

 #!/bin/bash for i in *.jar; do jar -tf "$i" | grep $1 | xargs -I{} echo -e "$i : {}" ; done 

Pour rechercher tous les fichiers jar dans un répertoire donné pour une classe particulière, vous pouvez le faire:

 ls *.jar | xargs grep -F MyClass 

ou, encore plus simple,

 grep -F MyClass *.jar 

La sortie ressemble à ceci:

 Binary file foo.jar matches 

C’est très rapide car l’option -F signifie rechercher une chaîne fixe, donc elle ne charge pas le moteur regex pour chaque invocation grep. Si nécessaire, vous pouvez toujours omettre l’option -F et utiliser des expressions rationnelles.

Script pour trouver le fichier JAR: find_jar.sh

 IFS=$(echo -en "\n\b") # Set the field separator newline for f in `find ${1} -iname *.jar`; do jar -tf ${f}| grep --color $2 if [ $? == 0 ]; then echo -n "Match found: " echo -e "${f}\n" fi done unset IFS 

Utilisation: ./find_jar.sh

Ceci est similaire à la plupart des réponses données ici. Mais il ne produit que le nom du fichier, si grep trouve quelque chose. Si vous voulez supprimer la sortie de grep, vous pouvez la redirect vers / dev / null mais je préfère voir la sortie de grep pour pouvoir utiliser des noms de classes partiels et trouver celui qui convient dans une liste de résultats.

Le nom de la classe peut être à la fois un nom de classe simple comme “Ssortingng” ou un nom complet comme “java.lang.Ssortingng”

Pour append encore un autre outil … c’est un outil très simple et utile pour Windows. Un simple fichier exe sur lequel vous cliquez, donnez-lui un répertoire dans lequel rechercher, un nom de classe et il trouvera le fichier jar contenant cette classe. Oui, c’est récursif.

http://sourceforge.net/projects/jarfinder/

Vous pouvez trouver une classe dans un répertoire plein de jars avec un peu de shell:

À la recherche de la classe “FooBar”:

 LIB_DIR=/some/dir/full/of/jarfiles for jarfile in $(find $LIBDIR -name "*.jar"); do echo "--------$jarfile---------------" jar -tvf $jarfile | grep FooBar done 

Une chose à append à tout ce qui précède: si l’exécutable jar n’est pas disponible (il est fourni avec le JDK mais pas avec le JRE), vous pouvez utiliser unzip (ou WinZip ou autre) pour accomplir la même chose.

auto-promotion sans vergogne, mais vous pouvez essayer un utilitaire que j’ai écrit: http://sourceforge.net/projects/zfind

Il supporte la plupart des fichiers d’archive / compressés les plus courants (jar, zip, tar, tar.gz, etc.) et contrairement à beaucoup d’autres jar / zip, supporte les fichiers zip nesteds (zip dans zip, jar dans jar etc.) jusqu’à une profondeur illimitée.

Un peu tard pour la fête, mais quand même …

J’ai utilisé JarBrowser pour trouver dans quel fichier une classe particulière est présente. Il a une interface graphique facile à utiliser qui vous permet de parcourir le contenu de tous les jars du chemin sélectionné.

Le script suivant vous aidera

 for file in *.jar do # do something on "$file" echo "$file" /usr/local/jdk/bin/jar -tvf "$file" | grep '$CLASSNAME' done 

Celui-ci fonctionne bien dans MinGW (environnement Windows bash) ~ gitbash

Mettez cette fonction dans votre fichier .bashrc dans votre répertoire HOME:

 # this function helps you to find a jar file for the class function find_jar_of_class() { OLD_IFS=$IFS IFS=$'\n' jars=( $( find -type f -name "*.jar" ) ) for i in ${jars[*]} ; do if [ ! -z "$(jar -tvf "$i" | grep -Hsi $1)" ] ; then echo "$i" fi done IFS=$OLD_IFS } 

Grepj est un utilitaire de ligne de commande pour rechercher des classes dans les fichiers jar. Je suis l’auteur de l’utilitaire.

Vous pouvez exécuter l’utilitaire comme grepj package.Class my1.jar my2.war my3.ear

Plusieurs fichiers jar, ear, war peuvent être fournis. Pour une utilisation avancée, utilisez find pour obtenir une liste des pots à rechercher.

Vérifiez ce plugin pour eclipse qui peut faire le travail que vous recherchez.

https://marketplace.eclipse.org/content/jarchiveexplorer

Sous un environnement Linux, vous pouvez effectuer les opérations suivantes:

 $ find  -name *.jar -print0 | xargs -0 -l jar tf | grep  

name est le nom du fichier de classe que vous recherchez dans les jars répartis dans la hiérarchie des répertoires enracinés dans le répertoire base_dir .

Vous pouvez utiliser locate et grep :

 locate jar | xargs grep 'my.class' 

Assurez-vous d’exécuter updatedb avant d’utiliser locate .

Utilisez ceci .. vous pouvez trouver n’importe quel fichier dans classpath .. garanti ..

 import java.net.URL; import java.net.URLClassLoader; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream; public class FileFinder { public static void main(Ssortingng[] args) throws Exception { Ssortingng file = ; ClassLoader cl = ClassLoader.getSystemClassLoader(); URL[] urls = ((URLClassLoader)cl).getURLs(); for(URL url: urls){ listFiles(file, url); } } private static void listFiles(Ssortingng file, URL url) throws Exception{ ZipInputStream zip = new ZipInputStream(url.openStream()); while(true) { ZipEntry e = zip.getNextEntry(); if (e == null) break; Ssortingng name = e.getName(); if (name.endsWith(file)) { System.out.println(url.toSsortingng() + " -> " + name); } } } } 

En eclipse, vous pouvez utiliser l’ancien plugin jarsearch